js怎么实现计算器的括号功能

在JavaScript中实现计算器的括号功能，核心在于解析并正确计算包含括号的数学表达式。这需要用到递归、栈数据结构、正则表达式等编程技巧。

首先，确保你能正确解析并计算基本的数学表达式。然后，通过递归或栈的方式处理括号的嵌套。

一、前置知识：数学表达式的解析

在实现计算器功能之前，理解如何解析和计算数学表达式是关键。一般来说，解析表达式可以分为以下几个步骤：

词法分析：将输入的字符串转换为一组有意义的标记（token），如数字、运算符和括号。
语法分析：将标记序列转换为树形结构（抽象语法树，AST）。
计算：遍历抽象语法树并计算结果。

二、实现计算器的基础功能

在开始处理括号之前，确保你的计算器能处理没有括号的简单表达式。以下是一个简单的实现：

function evaluateExpression(expression) {
    return Function('"use strict";return (' + expression + ')')();
}
console.log(evaluateExpression("3 + 5 * 2")); // 输出 13

三、处理括号的逻辑

为了处理括号，我们需要修改解析逻辑，使其能够识别并处理嵌套的括号。以下是一个示例实现：

function evaluateExpression(expression) {
    let tokens = tokenize(expression);
    let [result, _] = parseTokens(tokens, 0);
    return result;
}
function tokenize(expression) {
    let tokens = [];
    let number = '';
    for (let char of expression) {
        if ('0123456789'.includes(char)) {
            number += char;
        } else {
            if (number) {
                tokens.push(Number(number));
                number = '';
            }
            if (char.trim()) {
                tokens.push(char);
            }
        }
    }
    if (number) {
        tokens.push(Number(number));
    }
    return tokens;
}
function parseTokens(tokens, index) {
    let stack = [];
    let num = 0;
    let sign = '+';
    while (index < tokens.length) {
        let token = tokens[index];
        if (typeof token === 'number') {
            num = token;
        } else if (token === '(') {
            [num, index] = parseTokens(tokens, index + 1);
        } else if (token === ')') {
            break;
        } else {
            sign = token;
        }
        if (!('0123456789'.includes(token)) || index === tokens.length - 1) {
            if (sign === '+') stack.push(num);
            else if (sign === '-') stack.push(-num);
            else if (sign === '*') stack.push(stack.pop() * num);
            else if (sign === '/') stack.push(stack.pop() / num);
            num = 0;
        }
        index++;
    }
    return [stack.reduce((a, b) => a + b, 0), index];
}
console.log(evaluateExpression("3 + (2 * (5 + 1))")); // 输出 15

四、递归处理括号

为了更有效地处理嵌套括号，我们可以使用递归来解析表达式。递归解析的核心思想是遇到左括号时递归调用，遇到右括号时返回当前计算结果。

function evaluateExpression(expression) {
    return parseExpression(expression, 0).result;
}
function parseExpression(expression, index) {
    let operands = [];
    let operators = [];
    let num = 0;
    let sign = 1;
    while (index < expression.length) {
        let char = expression[index];
        if (char === ' ') {
            index++;
        } else if (char === '(') {
            let innerResult = parseExpression(expression, index + 1);
            num = innerResult.result;
            index = innerResult.index;
        } else if (char === ')') {
            operands.push(num * sign);
            return { result: compute(operands, operators), index: index };
        } else if ('0123456789'.includes(char)) {
            num = num * 10 + parseInt(char);
            index++;
        } else {
            operands.push(num * sign);
            num = 0;
            sign = (char === '-') ? -1 : 1;
            if (char === '+' || char === '-') {
                operators.push(char);
            }
            index++;
        }
    }
    operands.push(num * sign);
    return { result: compute(operands, operators), index: index };
}
function compute(operands, operators) {
    let result = operands[0];
    for (let i = 0; i < operators.length; i++) {
        if (operators[i] === '+') {
            result += operands[i + 1];
        } else if (operators[i] === '-') {
            result -= operands[i + 1];
        }
    }
    return result;
}
console.log(evaluateExpression("3 + (2 * (5 + 1))")); // 输出 15

五、优化和扩展

在实际应用中，你可能需要处理更多的运算符和错误情况。下面是一些建议：

处理错误输入：确保输入表达式格式正确，捕捉并处理错误。
扩展支持的运算符：增加对乘法、除法等运算符的支持。
优化性能：对于复杂表达式，优化解析和计算过程的性能。

六、总结

实现计算器的括号功能需要对数学表达式进行正确的解析和计算，递归和栈是处理嵌套括号的有效方法。通过逐步解析表达式，处理不同类型的标记，并递归处理括号，可以实现一个功能完善的计算器。

希望这篇文章对你理解和实现JavaScript计算器的括号功能有所帮助。如果你有更复杂的需求，可以进一步扩展和优化代码。