上篇文章,我们讲了命令模式。命令模式将请求封装成对象,方便作为函数参数传递和赋值给变量。它主要的应用场景是给命令的执行附加功能,换句话说,就是控制命令的执行,比如,排队、异步、延迟执行命令、给命令执行记录日志、撤销重做命令等等。总体上来讲,命令模式的应用范围并不广。
今天,我们来学习解释器模式,它用来描述如何构建一个简单的“语言”解释器。比起命令模式,解释器模式更加小众,只在一些特定的领域会被用到,比如编译器、规则引擎、正则表达式。所以,解释器模式也不是我们学习的重点,你稍微了解一下就可以了。

解释器模式的原理和实现

解释器模式的英文翻译是 Interpreter Design Pattern。在 GoF 的《设计模式》一书中,它是这样定义的:

Interpreter pattern is used to defines a grammatical representation for a language and provides an interpreter to deal with this grammar.

翻译成中文就是:解释器模式为某个语言定义它的语法(或者叫文法)表示,并定义一个解释器用来处理这个语法。
看了定义,你估计会一头雾水,因为这里面有很多我们平时开发中很少接触的概念,比如“语言”“语法”“解释器”。实际上,这里的“语言”不仅仅指我们平时说的中、英、日、法等各种语言。从广义上来讲,只要是能承载信息的载体,我们都可以称之为“语言”,比如,古代的结绳记事、盲文、哑语、摩斯密码等。

要想了解“语言”表达的信息,我们就必须定义相应的语法规则。这样,书写者就可以根据语法规则来书写“句子”(专业点的叫法应该是“表达式”),阅读者根据语法规则来阅读“句子”,这样才能做到信息的正确传递。而我们要讲的解释器模式,其实就是用来实现根据语法规则解读“句子”的解释器。

为了让你更好地理解定义,我举一个比较贴近生活的例子来解释一下。

实际上,理解这个概念,我们可以类比中英文翻译。我们知道,把英文翻译成中文是有一定规则的。这个规则就是定义中的“语法”。我们开发一个类似 Google Translate 这样的翻译器,这个翻译器能够根据语法规则,将输入的中文翻译成英文。这里的翻译器就是解释器模式定义中的“解释器”。

刚刚翻译器这个例子比较贴近生活,现在,我们再举个更加贴近编程的例子。

假设我们定义了一个新的加减乘除计算“语言”,语法规则如下:

  • 运算符只包含加、减、乘、除,并且没有优先级的概念;
  • 表达式(也就是前面提到的“句子”)中,先书写数字,后书写运算符,空格隔开;
  • 按照先后顺序,取出两个数字和一个运算符计算结果,结果重新放入数字的最头部位置,循环上述过程,直到只剩下一个数字,这个数字就是表达式最终的计算结果。

我们举个例子来解释一下上面的语法规则。
比如" 8 3 2 4 - + *" 这样一个表达式,我们按照上面的语法规则来处理,取出数字“8 3”“-”运算符,计算得到 5,于是表达式就变成了“ 5 2 4 + * ”。然后,我们再取出“ 5 2 ”“ + ”运算符,计算得到 7,表达式就变成了“ 7 4 * ”。最后,我们取出“ 7 4” “ * ” 运算符,最终得到的结果就是 28。看懂了上面的语法规则,我们将它用代码实现出来,如下所示。代码非常简单,用户按照上面的规则书写表达式,传递给 interpret() 函数,就可以得到最终的计算结果。

<?php
namespace DesignPatterns\Interpreter\v1;
/**
 * Class ExpressionInterpreter
 * @package DesignPatterns\Interpreter\example1
 */
class ExpressionInterpreter
{
    private $numbers = [];
    public function interpret(string $expression)
    {
        $elements = explode(" ",$expression);
        $length = count($elements);
        for ($i = 0; $i < ($length +1)/2;$i++) {
            $this->numbers[] = $elements[$i];
        }
        for ($i= ($length+1)/2; $i< $length;$i++) {
            $operator = $elements[$i];
            if (!in_array($operator,array('+','-','*','/'))) {
                throw new \Exception("表达式无效");
            }

            $number1 = array_shift($this->numbers);
            $number2 = array_shift($this->numbers);
            $result = 0;

            if ($elements[$i] == '+') {
                $result = $number1 + $number2;
            }elseif ($elements[$i] == '-') {
                $result = $number1 - $number2;
            }elseif ($elements[$i] == '*') {
                $result = $number1 * $number2;
            }elseif ($elements[$i] == '/') {
                $result = $number1 / $number2;
            }
            array_unshift($this->numbers,$result);
        }
        if (count($this->numbers) != 1) {
            throw  new  \Exception("表达式无效");
        }

        return array_pop($this->numbers);
    }
}

//clientCode
$str = "8 3 2 4 - + *";
$e = new ExpressionInterpreter();

echo $e->interpret($str);
//结果 28

在上面的代码实现中,语法规则的解析逻辑都集中在一个函数中,对于简单的语法规则的解析,这样的设计就足够了。但是,对于复杂的语法规则的解析,逻辑复杂,代码量多,所有的解析逻辑都耦合在一个函数中,这样显然是不合适的。这个时候,我们就要考虑拆分代码,将解析逻辑拆分到独立的小类中。

该怎么拆分呢?我们可以借助解释器模式。解释器模式的代码实现比较灵活,没有固定的模板。我们前面也说过,应用设计模式主要是应对代码的复杂性,实际上,解释器模式也不例外。它的代码实现的核心思想,就是将语法解析的工作拆分到各个小类中,以此来避免大而全的解析类。一般的做法是,将语法规则拆分成一些小的独立的单元,然后对每个单元进行解析,最终合并为对整个语法规则的解析。

前面定义的语法规则有两类表达式,一类是数字,一类是运算符,运算符又包括加减乘除。利用解释器模式,我们把解析的工作拆分到 NumberExpression、AdditionExpression、SubstractionExpression、MultiplicationExpression、DivisionExpression 这样五个解析类中。

按照这个思路,我们对代码进行重构,重构之后的代码如下所示。当然,因为加减乘除表达式的解析比较简单,利用解释器模式的设计思路,看起来有点过度设计。不过呢,这里我主要是为了解释原理,你明白意思就好,不用过度细究这个例子。
Expression.php

<?php
namespace DesignPatterns\Interpreter\v2;

interface Expression
{
    public function interpret();
}

NumberExpression.php

<?php
namespace DesignPatterns\Interpreter\v2;

class NumberExpression implements Expression
{
    private $number;

    public function __construct($number)
    {
        $this->number = $number;
    }

    public function interpret()
    {
        return $this->number;
    }
}

AdditionExpression.php

<?php
namespace DesignPatterns\Interpreter\v2;

class AdditionExpression implements Expression
{
    private $exp1;
    private $exp2;

    public function __construct(Expression $exp1,Expression $exp2)
    {
        $this->exp1 = $exp1;
        $this->exp2 = $exp2;
    }

    public function interpret()
    {
        return $this->exp1->interpret() + $this->exp2->interpret();
    }
}

SubstractionExpression.php

<?php
namespace DesignPatterns\Interpreter\v2;

class SubstractionExpression implements Expression
{
    private $exp1;
    private $exp2;

    public function __construct(Expression $exp1,Expression $exp2)
    {
        $this->exp1 = $exp1;
        $this->exp2 = $exp2;
    }

    public function interpret()
    {
       return $this->exp1->interpret() - $this->exp2->interpret();
    }
}

MultiplicationExpression.php

<?php
namespace DesignPatterns\Interpreter\v2;


class MultiplicationExpression implements Expression
{
    private $exp1;
    private $exp2;

    public function __construct(Expression $exp1,Expression $exp2)
    {
        $this->exp1 = $exp1;
        $this->exp2 = $exp2;
    }

    public function interpret()
    {
       return $this->exp1->interpret() * $this->exp2->interpret();
    }
}

DivisionExpression.php

<?php
namespace DesignPatterns\Interpreter\v2;

class DivisionExpression implements Expression
{
    private $exp1;
    private $exp2;

    public function __construct(Expression $exp1,Expression $exp2)
    {
        $this->exp1 = $exp1;
        $this->exp2 = $exp2;
    }

    public function interpret()
    {
        return $this->exp1->interpret() / $this->exp2->interpret();
    }
}

ExpressionInterpreter.php

<?php
namespace DesignPatterns\Interpreter\v2;
require dirname(__DIR__).'/../vendor/autoload.php';

class ExpressionInterpreter
{
    private $numbers = [];
    public function interpret(string $expression)
    {
        $elements = explode(" ",$expression);
        $length = count($elements);
        for ($i = 0; $i < ($length +1)/2;$i++) {
            $this->numbers[] = new NumberExpression($elements[$i]);
        }
        for ($i= ($length+1)/2; $i< $length;$i++) {
            $operator = $elements[$i];
            if (!in_array($operator,array('+','-','*','/'))) {
                throw new \Exception("表达式无效");
            }

            $exp1 = array_shift($this->numbers);
            $exp2 = array_shift($this->numbers);
            $combinedExp = null;

            if ($elements[$i] == '+') {
                $combinedExp = new AdditionExpression($exp1,$exp2);
            }elseif ($elements[$i] == '-') {
                $combinedExp = new SubstractionExpression($exp1,$exp2);
            }elseif ($elements[$i] == '*') {
                $combinedExp = new MultiplicationExpression($exp1,$exp2);
            }elseif ($elements[$i] == '/') {
                $combinedExp = new DivisionExpression($exp1,$exp2);
            }
            $result = $combinedExp->interpret();
            array_unshift($this->numbers,new NumberExpression($result));
        }
        if (count($this->numbers) != 1) {
            throw  new  \Exception("表达式无效");
        }

        return array_pop($this->numbers)->interpret();
    }
}
//ClientCode
$str = "8 3 2 4 - + *";
$e = new ExpressionInterpreter();

echo $e->interpret($str);
//结果28

总结

解释器模式为某个语言定义它的语法(或者叫文法)表示,并定义一个解释器用来处理这个语法。实际上,这里的“语言”不仅仅指我们平时说的中、英、日、法等各种语言。从广义上来讲,只要是能承载信息的载体,我们都可以称之为“语言”,比如,古代的结绳记事、盲文、哑语、摩斯密码等。

要想了解“语言”要表达的信息,我们就必须定义相应的语法规则。这样,书写者就可以根据语法规则来书写“句子”(专业点的叫法应该是“表达式”),阅读者根据语法规则来阅读“句子”,这样才能做到信息的正确传递。而我们要讲的解释器模式,其实就是用来实现根据语法规则解读“句子”的解释器。

解释器模式的代码实现比较灵活,没有固定的模板。我们前面说过,应用设计模式主要是应对代码的复杂性,解释器模式也不例外。它的代码实现的核心思想,就是将语法解析的工作拆分到各个小类中,以此来避免大而全的解析类。一般的做法是,将语法规则拆分一些小的独立的单元,然后对每个单元进行解析,最终合并为对整个语法规则的解析。

参考文章 :解释器模式:如何设计实现一个自定义接口告警规则功能?

github示例 :https://github.com/yangpanyao/design-patterns/tree/master/Interpreter

Last modification:July 20th, 2020 at 09:41 pm