在PHP中实现自定义数学表达式解析器和评估器

答案是：通过分步实现词法分析、Shunting Yard算法解析和RPN求值，可构建安全可控的PHP数学表达式求值器。1. tokenize函数将输入拆分为数字、变量、操作符等标记；2. parseToRPN使用Shunting Yard算法按优先级和结合性转换为逆波兰表示；3. evaluateRPN利用栈结构结合变量上下文计算结果；4. evaluateExpression整合流程并处理异常；5. 示例显示支持变量和标准运算，具备安全性、可扩展性与错误处理能力，适用于需避免eval()风险的场景。

Creating a custom mathematical expression parser and evaluator in PHP can be useful when you need more control than eval() provides—especially for security, extensibility, or educational purposes. While eval() can execute expressions, it's dangerous with untrusted input and lacks flexibility. Building your own parser allows you to safely evaluate expressions like 2 + 3 * (4 - 1) while supporting variables, functions, and error handling.

Here’s how to implement a simple yet effective mathematical expression parser and evaluator in PHP.

1. Tokenization: Breaking the Input into Meaningful Parts

The first step is to convert the input string into tokens—numbers, operators, parentheses, variables, and functions.

function tokenize($expression) {
    $tokens = [];
    $length = strlen($expression);
    $i = 0;

    while ($i < $length) {
        $char = $expression[$i];

        if (ctype_digit($char) || $char === '.') {
            $num = '';
            while ($i < $length && (ctype_digit($expression[$i]) || $expression[$i] === '.')) {
                $num .= $expression[$i++];
            }
            $tokens[] = ['type' => 'number', 'value' => (float)$num];
            $i--;
        } elseif (ctype_alpha($char)) {
            $var = '';
            while ($i < $length && ctype_alnum($expression[$i])) {
                $var .= $expression[$i++];
            }
            $tokens[] = ['type' => 'variable', 'value' => $var];
            $i--;
        } elseif (in_array($char, ['+', '-', '*', '/', '^', '(', ')'])) {
            $tokens[] = ['type' => 'operator', 'value' => $char];
        } elseif ($char === ' ') {
            // Skip whitespace
        } else {
            throw new Exception("Unknown character: $char");
        }
        $i++;
    }

    return $tokens;
}

This tokenizer handles numbers (including decimals), variables (like x, y1), operators, and parentheses.

2. Parsing with Shunting Yard Algorithm (Convert to RPN)

We’ll use the Shunting Yard algorithm by Edsger Dijkstra to convert infix notation (standard math) to Reverse Polish Notation (RPN), which is easier to evaluate.

function parseToRPN($tokens) {
    $output = [];
    $operators = [];
    $precedence = ['+' => 1, '-' => 1, '*' => 2, '/' => 2, '^' => 3];
    $associativity = ['+' => 'left', '-' => 'left', '*' => 'left', '/' => 'left', '^' => 'right'];

    foreach ($tokens as $token) {
        if ($token['type'] === 'number' || $token['type'] === 'variable') {
            $output[] = $token;
        } elseif ($token['value'] === '(') {
            $operators[] = $token;
        } elseif ($token['value'] === ')') {
            while (!empty($operators) && end($operators)['value'] !== '(') {
                $output[] = array_pop($operators);
            }
            array_pop($operators); // Remove '('
        } elseif ($token['type'] === 'operator') {
            $op = $token['value'];
            while (
                !empty($operators) &&
                ($top = end($operators))['value'] !== '(' &&
                isset($precedence[$top['value']]) &&
                (
                    ($associativity[$op] === 'left' && $precedence[$op] <= $precedence[$top['value']]) ||
                    ($associativity[$op] === 'right' && $precedence[$op] < $precedence[$top['value']])
                )
            ) {
                $output[] = array_pop($operators);
            }
            $operators[] = $token;
        }
    }

    while (!empty($operators)) {
        $output[] = array_pop($operators);
    }

    return $output;
}

This algorithm respects operator precedence and associativity (e.g., ^ is right-associative).

3. Evaluating the RPN Expression

Now evaluate the RPN using a stack. Variables are resolved from a provided context (e.g., ['x' => 5]).

function evaluateRPN($rpn, $variables = []) {
    $stack = [];

    foreach ($rpn as $token) {
        if ($token['type'] === 'number') {
            $stack[] = $token['value'];
        } elseif ($token['type'] === 'variable') {
            if (!isset($variables[$token['value']])) {
                throw new Exception("Undefined variable: " . $token['value']);
            }
            $stack[] = $variables[$token['value']];
        } elseif ($token['type'] === 'operator') {
            if (count($stack) < 2) {
                throw new Exception("Invalid expression");
            }
            $b = array_pop($stack);
            $a = array_pop($stack);
            switch ($token['value']) {
                case '+': $stack[] = $a + $b; break;
                case '-': $stack[] = $a - $b; break;
                case '*': $stack[] = $a * $b; break;
                case '/': 
                    if ($b == 0) throw new Exception("Division by zero");
                    $stack[] = $a / $b; 
                    break;
                case '^': $stack[] = pow($a, $b); break;
                default: throw new Exception("Unknown operator: " . $token['value']);
            }
        }
    }

    if (count($stack) !== 1) {
        throw new Exception("Invalid expression");
    }

    return $stack[0];
}

4. Putting It All Together

Now create a simple wrapper function:

function evaluateExpression($expression, $variables = []) {
    try {
        $tokens = tokenize($expression);
        $rpn = parseToRPN($tokens);
        return evaluateRPN($rpn, $variables);
    } catch (Exception $e) {
        return "Error: " . $e->getMessage();
    }
}

5. Usage Example

echo evaluateExpression("2 + 3 * (4 - 1)"); // Output: 11
echo evaluateExpression("x + y * 2", ['x' => 5, 'y' => 3]); // Output: 11
echo evaluateExpression("z ^ 2", ['z' => 4]); // Output: 16

Key Features & Benefits

• Safe: No use of eval(), so no code injection.
• Extensible: You can add functions (e.g., sin, sqrt) by extending the tokenizer and evaluator.
• Error Handling: Clear messages for undefined variables, syntax issues, or division by zero.
• Supports Variables: Useful for dynamic expressions in forms, calculators, or rule engines.

Possible Enhancements

• Support for built-in math functions (e.g., sin(x)).
• Unary operators (e.g., -5, +3).
• Better error recovery and syntax validation.
• Custom operator definitions.

Building your own parser gives deep insight into how programming languages and calculators work. While tools like eval() or external libraries exist, a custom parser offers control, safety, and learning value.

Basically, it's not complex once you break it down—tokenize, parse, evaluate.

以上是在PHP中实现自定义数学表达式解析器和评估器的详细内容。更多信息请关注PHP中文网其他相关文章！