java执行JavaScriptUtil运转

import javax.script.Invocable;
import javax.script.ScriptEngine;
import javax.script.ScriptEngineManager;
import javax.script.ScriptException;
import java.util.Map;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class JavaScriptUtil {

    public static Object calculateRatio(Map<String, Object> column,Map<String, Object> row) throws ScriptException, NoSuchMethodException {
        ScriptEngineManager manager = new ScriptEngineManager();
        ScriptEngine engine = manager.getEngineByName("nashorn");
        // 如果还是没有引擎可用，抛出明确异常
        if (engine == null) {
            if(column.get("filed") != null){
                return row.get(column.get("filed"));
            }
            return "";
        }
        // 注入数据到JS环境
        engine.put("row", row);
        // 根据引擎类型使用不同的语法
        String formatter = column.get("formatter").toString();
        String converted = "function calculateRatio(row) {"+convertJsForNashorn(formatter)+"}";
        engine.eval(converted);
        // 调用函数
        Object result = ((Invocable)engine).invokeFunction("calculateRatio", row);
        return result.toString();
    }

    public static void main(String[] args) throws ScriptException, NoSuchMethodException {
        Map<String, Object> column = Map.of("formatter", "let { Z, V } = row; // Z=计划品, V=检验量 \n" +
                "if(Z == 0){\n" +
                "  return 0; \n" +
                "}else{\n" +
                " return parseFloat((((Z/V) * 100)).toFixed(3));\n" +
                "}", "V", 100);
        Map<String, Object> row = Map.of("Z", 20, "V", 100);
        System.out.println(calculateRatio(column,row)); // 输出 25.0
    }

    /**
     * 转换JavaScript代码为Nashorn兼容格式
     * @param jsCode 原始JavaScript代码
     * @return 转换后的JavaScript代码
     */
    public static String convertJsForNashorn(String jsCode) {
        // 1. 转换let/const为var
        String converted = convertVariableDeclarations(jsCode);

        // 2. 处理解构赋值
        converted = convertDestructuringAssignments(converted);

        // 3. 其他可能的转换可以在这里添加

        return converted;
    }

    /**
     * 将let和const转换为var
     */
    private static String convertVariableDeclarations(String jsCode) {
        // 替换所有let和const为var，但排除函数声明中的情况
        String pattern = "(?<!(function\\s+|\\w+\\s*\\.))\\b(let|const)\\b";
        return jsCode.replaceAll(pattern, "var");
    }

    /**
     * 处理解构赋值转换为传统赋值
     */
    private static String convertDestructuringAssignments(String jsCode) {
        // 匹配类似 let { Z, V } = row; 的模式
        Pattern pattern = Pattern.compile("var\\s*\\{([^}]+)\\}\\s*=\\s*(\\w+)\\s*;");
        Matcher matcher = pattern.matcher(jsCode);

        StringBuffer sb = new StringBuffer();
        while (matcher.find()) {
            String variables = matcher.group(1).trim();
            String sourceObject = matcher.group(2).trim();

            // 处理每个解构变量
            String[] vars = variables.split(",");
            StringBuilder replacements = new StringBuilder();

            for (String var : vars) {
                var = var.trim();
                if (var.isEmpty()) continue;

                // 处理可能的别名情况，如 { Z: alias }
                if (var.contains(":")) {
                    String[] parts = var.split(":");
                    String original = parts[0].trim();
                    String alias = parts[1].trim();
                    replacements.append("var ").append(alias).append("=")
                            .append(sourceObject).append(".").append(original).append(";");
                } else {
                    replacements.append("var ").append(var).append("=")
                            .append(sourceObject).append(".").append(var).append(";");
                }
            }

            matcher.appendReplacement(sb, replacements.toString());
        }
        matcher.appendTail(sb);

        return sb.toString();
    }
}