答案是通过JavaScript实现一个极简算术表达式解释器和虚拟机：首先定义支持数字与加减乘除的AST结构，接着编写递归下降解析器将字符串转为AST，然后实现递归求值函数evaluate对AST进行解释执行，最后扩展为栈式虚拟机，通过compile将AST转为字节码指令，再由runVM基于栈执行得出结果。整个过程体现了“代码即数据”和“逐步求值”的核心思想，构成了构建小型语言运行时的基础路径。

实现一个简单的解释器或虚拟机，核心是理解“代码即数据”和“逐步求值”的思想。JavaScript 由于其动态性和灵活性，非常适合用来构建小型语言的执行环境。下面通过一个极简的算术表达式解释器来说明基本流程。

定义语言结构

我们先设计一种极简的语言，只支持加减乘除和数字。比如表达式：3 + 4 * 2。为了便于处理，先将其转化为抽象语法树（AST）。

AST 节点可以是：

• NumberNode：表示一个数字
• BinaryOpNode：表示二元操作（如 +, -, *, /）

示例 AST 结构：

立即学习“Java免费学习笔记（深入）”；

{
  type: 'BinaryOp',
  operator: '+',
  left: { type: 'Number', value: 3 },
  right: {
    type: 'BinaryOp',
    operator: '*',
    left: { type: 'Number', value: 4 },
    right: { type: 'Number', value: 2 }
  }
}

编写解析器（Parser）

将字符串转换为 AST。这里使用简易递归下降解析器处理中缀表达式（注意优先级）。

简化起见，假设输入格式良好，仅支持整数和 +-*/ 运算符。

Node.js 可靠编程

Node.js 可靠编程技能。避免事件循环阻塞、异步陷阱、ESM 兼容问题和内存泄漏。触发词：Node.js 开发、async/await、流处理、性能优化、安全编码。

下载

function parse(expression) {
  let pos = 0;
<p>function peek() {
return expression[pos] || null;
}</p><p>function consume() {
return expression[pos++];
}</p><p>function skipWhitespace() {
while (peek() === ' ') consume();
}</p><p>function parseNumber() {
let num = '';
while (/[0-9]/.test(peek())) {
num += consume();
}
return { type: 'Number', value: parseInt(num, 10) };
}</p><p>function parseFactor() {
skipWhitespace();
if (/[0-9]/.test(peek())) {
return parseNumber();
} else if (peek() === '(') {
consume(); // '('
const node = parseExpression();
consume(); // ')'
return node;
}
}</p><p>function parseTerm() {
let node = parseFactor();
while (peek() === '*' || peek() === '/') {
const op = consume();
node = {
type: 'BinaryOp',
operator: op,
left: node,
right: parseFactor()
};
}
return node;
}</p><p>function parseExpression() {
let node = parseTerm();
while (peek() === '+' || peek() === '-') {
const op = consume();
node = {
type: 'BinaryOp',
operator: op,
left: node,
right: parseTerm()
};
}
return node;
}</p><p>return parseExpression();
}</p>

实现解释器（Evaluator）

解释器遍历 AST 并计算结果。

function evaluate(ast) {
  switch (ast.type) {
    case 'Number':
      return ast.value;
    case 'BinaryOp':
      const left = evaluate(ast.left);
      const right = evaluate(ast.right);
      switch (ast.operator) {
        case '+': return left + right;
        case '-': return left - right;
        case '*': return left * right;
        case '/': return left / right;
      }
  }
}

使用示例：

const code = "3 + 4 * 2";
const ast = parse(code);
const result = evaluate(ast);
console.log(result); // 输出 11

扩展为简单虚拟机（VM）

如果想更接近虚拟机模型，可以用栈来执行指令。

先将 AST 编译为字节码：

function compile(ast) {
  const instructions = [];
  function emit(op, value) {
    instructions.push({ op, value });
  }
<p>function walk(node) {
switch (node.type) {
case 'Number':
emit('PUSH', node.value);
break;
case 'BinaryOp':
walk(node.left);
walk(node.right);
emit('OP', node.operator);
break;
}
}</p><p>walk(ast);
return instructions;
}</p>

然后实现一个基于栈的虚拟机：

function runVM(instructions) {
  const stack = [];
  for (const instr of instructions) {
    switch (instr.op) {
      case 'PUSH':
        stack.push(instr.value);
        break;
      case 'OP':
        const b = stack.pop();
        const a = stack.pop();
        let result;
        switch (instr.value) {
          case '+': result = a + b; break;
          case '-': result = a - b; break;
          case '*': result = a * b; break;
          case '/': result = a / b; break;
        }
        stack.push(result);
        break;
    }
  }
  return stack[0];
}

运行方式：

const ast = parse("3 + 4 * 2");
const bytecode = compile(ast);
const vmResult = runVM(bytecode);
console.log(vmResult); // 11

基本上就这些。从词法分析、语法解析到解释执行或编译运行，这是构建语言的基础路径。不复杂但容易忽略细节，比如运算符优先级和错误处理。后续可加入变量、函数、作用域等特性，逐步演变为完整的小型语言运行时。