Wie erstellt man einen Rechner in PHP mit dem Shunting Yard-Algorithmus?

Wie erstelle ich einen Taschenrechner in PHP?

In PHP erfordert das Erstellen eines Taschenrechners das Parsen und Auswerten der von einem Benutzer eingegebenen mathematischen Ausdrücke. Dies kann eine Herausforderung sein, da es darum geht, Benutzereingaben zu verarbeiten und mathematische Operationen anzuwenden.

Verwendung des Rangierbahnhof-Algorithmus

Ein empfohlener Ansatz ist die Nutzung des Rangierbahnhof-Algorithmus. Dieser Algorithmus wandelt mathematische Ausdrücke in die umgekehrte polnische Notation (RPN) um, die einfacher auszuwerten ist.

Beispielimplementierung

Hier ist ein vereinfachtes Beispiel für die Verwendung des Shunting Yard-Algorithmus:

// Terminal expression abstract class
abstract class TerminalExpression {

    public function operate() {
        return $this->value;
    }

    public function isOperator() {
        return false;
    }

    public function isParenthesis() {
        return false;
    }

    public function isNoOp() {
        return false;
    }
}

// Operator expression abstract class
abstract class Operator extends TerminalExpression {

    public function isOperator() {
        return true;
    }
}

// Stack implementation
class Stack {

    private $data = [];

    public function push($element) {
        $this->data[] = $element;
    }

    public function peek() {
        return end($this->data);
    }

    public function pop() {
        return array_pop($this->data);
    }
}

// Math class for evaluation
class Math {

    public function evaluate($expression) {
        $stack = $this->parse($expression);
        return $this->run($stack);
    }

    private function parse($expression) {
        $tokens = $this->tokenize($expression);
        $output = new Stack();
        $operators = new Stack();

        foreach ($tokens as $token) {
            $type = TerminalExpression::factory($token);

            if ($type->isOperator()) {
                $this->parseOperator($type, $output, $operators);
            } elseif ($type->isParenthesis()) {
                $this->parseParenthesis($type, $output, $operators);
            } else {
                $output->push($type);
            }
        }

        while (($op = $operators->pop())) {
            if ($op->isParenthesis()) {
                throw new RuntimeException('Mismatched Parenthesis');
            }
            $output->push($op);
        }

        return $output;
    }

    private function run(Stack $stack) {
        while (($operator = $stack->pop()) && $operator->isOperator()) {
            $value = $operator->operate($stack);
            if ($value !== null) {
                $stack->push(TerminalExpression::factory($value));
            }
        }
        return $operator ? $operator->render() : $this->render($stack);
    }

    protected function tokenize($string) {
        return preg_split('((\d+|\+|-|\(|\)|\*|/)|\s+)', $string, null, PREG_SPLIT_NO_EMPTY | PREG_SPLIT_DELIM_CAPTURE);
    }
}

$math = new Math();
$answer = $math->evaluate('(2 + 3) * 4');
var_dump($answer); // int(20)

Dieses Beispiel zeigt, wie der Shunting Yard-Algorithmus verwendet wird, um einen einfachen mathematischen Ausdruck zu analysieren und auszuwerten.

Das obige ist der detaillierte Inhalt vonWie erstellt man einen Rechner in PHP mit dem Shunting Yard-Algorithmus?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!