如何用JavaScript实现一个简单的解释器或虚拟机？

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

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>

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

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