答案是通过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。这里使用简易递归下降解析器处理中缀表达式（注意优先级）。
简化起见，假设输入格式良好，仅支持整数和 +-*/ 运算符。
function parse(expression) {
let pos = 0;
function peek() {
return expression[pos] || null;
}
function consume() {
return expression[pos++];
}
function skipWhitespace() {
while (peek() === ' ') consume();
}
function parseNumber() {
let num = '';
while (/[0-9]/.test(peek())) {
num += consume();
}
return { type: 'Number', value: parseInt(num, 10) };
}
function parseFactor() {
skipWhitespace();
if (/[0-9]/.test(peek())) {
return parseNumber();
} else if (peek() === '(') {
consume(); // '('
const node = parseExpression();
consume(); // ')'
return node;
}
}
function parseTerm() {
let node = parseFactor();
while (peek() === '*' || peek() === '/') {
const op = consume();
node = {
type: 'BinaryOp',
operator: op,
left: node,
right: parseFactor()
};
}
return node;
}
function parseExpression() {
let node = parseTerm();
while (peek() === '+' || peek() === '-') {
const op = consume();
node = {
type: 'BinaryOp',
operator: op,
left: node,
right: parseTerm()
};
}
return node;
}
return parseExpression();
}
实现解释器（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 });
}
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;
}
}
walk(ast);
return instructions;
}
然后实现一个基于栈的虚拟机：
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
基本上就这些。从词法分析、语法解析到解释执行或编译运行，这是构建语言的基础路径。不复杂但容易忽略细节，比如运算符优先级和错误处理。后续可加入变量、函数、作用域等特性，逐步演变为完整的小型语言运行时。
