refactor: simplify compile.ts by merging loops and reducing redundancy

Author: codehz

src/compile.ts

@@ -80,107 +80,81 @@ export function compile<TResult>(
 ): CompiledData {
   const { shortCircuit = true } = options;
 
-  // 序列化：支持 Proxy, Object, Array 和原始值
   const ast = serializeArgumentToAST(expression);
 
   // 建立变量名到索引的映射
   const variableOrder: string[] = [];
   const variableToIndex = new Map<string, number>();
+  const descToName = new Map<string, string>();
 
-  for (const name of Object.keys(variables)) {
+  for (const [name, value] of Object.entries(variables)) {
     if (!variableToIndex.has(name)) {
       variableToIndex.set(name, variableOrder.length);
       variableOrder.push(name);
     }
-  }
-
-  // 建立 Symbol description -> 变量名 映射（用于占位符替换）
-  const descToName = new Map<string, string>();
-  for (const [name, value] of Object.entries(variables)) {
     const id = getVariableId(value);
-    if (id && id.description) {
+    if (id?.description) {
       descToName.set(id.description, name);
     }
   }
 
   // 转换 AST：将占位符替换为变量名，然后替换为 $N
   const undefinedVars: string[] = [];
   const transformed = transformIdentifiers(ast, (name) => {
-    // 1. 如果是占位符，先替换为变量名
+    // 占位符替换为变量名
     const placeholderMatch = name.match(/^\$\$VAR_(.+)\$\$$/);
     if (placeholderMatch) {
-      const desc = placeholderMatch[1];
-      const varName = descToName.get(desc!);
-      if (!varName) {
-        throw new Error(`Unknown variable placeholder: ${name}`);
-      }
+      const varName = descToName.get(placeholderMatch[1]!);
+      if (!varName) throw new Error(`Unknown variable placeholder: ${name}`);
       name = varName;
     }
 
-    // 2. 将变量名替换为 $N
+    // 变量名替换为 $N
     const index = variableToIndex.get(name);
-    if (index !== undefined) {
-      return `$${index}`;
-    }
+    if (index !== undefined) return `$${index}`;
 
-    // 3. 检查是否为允许的全局对象
-    if (!ALLOWED_GLOBALS.has(name)) {
-      undefinedVars.push(name);
-    }
+    // 检查是否为允许的全局对象
+    if (!ALLOWED_GLOBALS.has(name)) undefinedVars.push(name);
     return name;
   });
 
   if (undefinedVars.length > 0) {
-    throw new Error(`Undefined variable(s): ${[...new Set(undefinedVars)].join(", ")}`);
+    const uniqueVars = [...new Set(undefinedVars)];
+    throw new Error(`Undefined variable(s): ${uniqueVars.join(", ")}`);
   }
 
   // 生成编译后的表达式
   const expressions: CompiledExpression[] = [];
 
   if (shortCircuit) {
-    // 短路求值模式：生成控制流节点
     let nextIndex = variableOrder.length;
 
     function compileAst(node: ASTNode): number {
-      // 检查是否需要短路处理
       if (node.type === "BinaryExpr" && (node.operator === "||" || node.operator === "&&" || node.operator === "??")) {
         return compileShortCircuit(node);
       }
-
       if (node.type === "ConditionalExpr") {
         return compileConditional(node);
       }
-
-      // 普通表达式：直接生成
       const exprStr = generate(node);
-      const idx = nextIndex++;
       expressions.push(exprStr);
-      return idx;
+      return nextIndex++;
     }
 
     function compileShortCircuit(node: ASTNode & { type: "BinaryExpr" }): number {
-      // 递归编译左操作数
       const leftIdx = compileAst(node.left);
 
-      // 生成跳转条件
-      let branchCondition: string;
-      switch (node.operator) {
-        case "||":
-          branchCondition = `$${leftIdx}`;
-          break;
-        case "&&":
-          branchCondition = `!$${leftIdx}`;
-          break;
-        default:
-          branchCondition = `$${leftIdx}!=null`;
-      }
+      const branchConditions: Record<string, string> = {
+        "||": `$${leftIdx}`,
+        "&&": `!$${leftIdx}`,
+        "??": `$${leftIdx}!=null`,
+      };
 
       const branchIdx = expressions.length;
-      expressions.push(["br", branchCondition, 0] as BranchNode);
+      expressions.push(["br", branchConditions[node.operator], 0] as BranchNode);
       nextIndex++;
 
       compileAst(node.right);
-
       const skipCount = expressions.length - branchIdx - 1;
       (expressions[branchIdx] as BranchNode)[2] = skipCount;
 
@@ -217,7 +191,6 @@ export function compile<TResult>(
 
     compileAst(transformed);
   } else {
-    // 原始模式：直接生成表达式字符串
     expressions.push(generate(transformed));
   }