设计模式：二十一.解释器模式_二十解释器模式-CSDN博客

本文链接：https://blog.csdn.net/q493201681/article/details/81208812

解释器模式(Interperter Mode):属于行为型模式的一种。这种模式实现了一个表达式接口，该接口解释了一个特定的上下文。这个模式有两个概念比较难理解，就是终结表达式和非终结表达式。在这里我整理了一下对这两个词的解释。

终结表达式	非终结表达式
通俗的说就是不能单独出现在推导式左边的符号，也就是说终结符不能在进行推导。不是终结符的都是非终结符,是不可拆分的最小元素	非终结符可理解为一个可拆分元素
用来实现语法规则中和终结符相关的操作，不包括其他的解释器。如果用组合模式来构建抽象语法树的话，就相当于组合模式中的叶子对象，可以有多种终结符解释器。	用来实现语法规则中非终结符相关的操作，通常一个解释器对应一个语法规则，可以包含其他解释器，如果用组合模式构建抽象语法树的话，就相当于组合模式中的组合对象。
实现与文法中的终结符相关联的解释操作	文法中的非终结符实现解释操作，对文法中的每一条规则R1,R2……Rn都需要一个具体的非终结符表达式类

又和之前安排上了，正则表达式就是一个典型的解释器模式的应用。

1. 意图：

定义：给定一个语言，定义它的文法的一种表示，并定义一个解释器，这个解释器使用该表示来解释语言的句子。

2. 如何使用：

如何解决：对于一些固定文法构建一个解释句子的解释器。如果一种特定的类型的问题发生的频率足够高，那么可能就值得将该问题的各个实例表述为一个简单语言中的句子。这样就构建了一个解释器，该解释器通过解释这些句子来解决问题。构建语法树，定义终结符与非终结符。构建环境类，包含解释器之外的一些全局信息。

优点：1.可扩展性好，灵活。2.增加了新的解释表达式的方式。3.易于实现简单方法。
缺点:1.可利用场景比较少。2.对于复杂的文法比较难维护。3.解释器模式会引起类膨胀。4.解释器模式采用递归调用方法。

使用场景：1.编译器，运算表达式计算。2.可以将一个需要解释执行的语言中的句子表示为一个抽象语法树。3.一些重复出现的问题可以用一种简单的语言来进行表达。4.一个简单语法需要解释的场景。

注意事项：可利用场景比较少。

3. UML模板：

4. 代码：


public class InterperterMode : MonoBehaviour
{
    void Start()
    {
        Context context = new Context();
        IList<AbstractExpression> list = new List<AbstractExpression>();
        list.Add(new TerminalExpression());
        list.Add(new NonterminalExpression());
        list.Add(new TerminalExpression());
        list.Add(new TerminalExpression());
        foreach (AbstractExpression exp in list)
        {
            exp.Interpret(context);
        }
    }
}
//抽象表达式，声明一个抽象的解释操作，这个接口为抽象语法树中所有的节点所共享。
public abstract class AbstractExpression
{
    public abstract void Interpret(Context context);
}
//终结符表达式，实现与文法中终结符相关联的解释操作
public class TerminalExpression : AbstractExpression
{
    public override void Interpret(Context context)
    {
        Debug.Log("终端解释器");
    }
}
//非终结符表达式，为文法中的非终结符实现解释操作。对文法中的每一条规则R1,R2******都需要一个具体的非终结符表达式
public class NonterminalExpression : AbstractExpression
{
    public override void Interpret(Context context)
    {
        Debug.Log("非终端解释器");
    }
}
//包含解释器之外的一些全局信息
public class Context
{
    private string input;
    public string Input
    {
        get { return input; }
        set { input = value; }
    }
    private string output;
    public string Output
    {
        get { return output; }
        set { output = value; }
    }
}

5. 实例：

UML图

代码


public class InterperterModeDemo : MonoBehaviour
{
    void Start()
    {
        PlayContext context = new PlayContext();
        //音乐-上海滩
        Debug.Log("上海滩: ");
        // context.PlayText = "O 2 E 0.5 G 0.5 A 3 E 0.5 G 0.5 D 3 E 0.5 G 0.5 G 0.5 A 0.5 O 3 C 1 O 2 A 0.5 G 1 C 0.5 E 0.5 D 3";
        context.PlayText = "T 500 O 2 E 0.5 G 0.5 A 3 E 0.5 G 0.5 D 3 E 0.5 G 0.5 A 0.5 O 3 C 1 O 2 A 0.5 G 1 C 0.5 E 0.5 D 3";
        Expression expression = null;
        try
        {
            while (context.PlayText.Length > 0)
            {
                string str = context.PlayText.Substring(0, 1);
                switch (str)
                {
                    case "O":
                        //当首字段是O时，则表达式实例化为音阶
                        expression = new Scale();
                        break;
                    //当首字母是CDEFGAB,以及休止符P时，则实例化音符
                    case "C":
                    case "D":
                    case "E":
                    case "F":
                    case "G":
                    case "A":
                    case "B":
                    case "P":
                        expression = new Note();
                        break;
                    case "T":
                        expression = new Speed();
                        break;
                }
                expression.Interpret(context);
            }
        }
        catch (Exception ex)
        {
            Debug.Log(ex.Message);
        }
    }
}
public class PlayContext
{
    //演奏文本
    private string text;
    public string PlayText
    {
        get { return text; }
        set { text = value; }
    }
}
public abstract class Expression
{
    //解释器
    public void Interpret(PlayContext context)
    {
        if (context.PlayText.Length == 0)
        {
            return;
        }
        else
        {
            //此方法用于将当前的演奏文本第一条命令获得命令字母和其参数值。
            //例如"O 3 E 0.5 G 0.5 A 3" 则playKey为O，而playValue为3
            string playKey = context.PlayText.Substring(0, 1);
            context.PlayText = context.PlayText.Substring(2);
            double playValue = Convert.ToDouble(context.PlayText.Substring(0, context.PlayText.IndexOf(" ")));
            //获得playKey和playValue后将其从演奏文本中移除。例如"O 3 E 0.5 G 0.5 A 3" 变成了"E 0.5 G 0.5 A 3"
            context.PlayText = context.PlayText.Substring(context.PlayText.IndexOf(" ") + 1);
            Excute(playKey, playValue);
        }
    }
    //抽象方法"执行",不同的文法子类，有不同的执行处理
    public abstract void Excute(string key, double value);
}
//音符类
public class Note : Expression
{
    public override void Excute(string key, double value)
    {
        string note = "";
        switch (key)
        {
            case "C":
                note = "1";
                break;
            case "D":
                note = "2";
                break;
            case "E":
                note = "3";
                break;
            case "F":
                note = "4";
                break;
            case "G":
                note = "5";
                break;
            case "A":
                note = "6";
                break;
            case "B":
                note = "7";
                break;
        }
        Debug.LogFormat("{0}", note);
    }
}
//音符类
public class Scale : Expression
{
    public override void Excute(string key, double value)
    {
        string scale = "";
        //如果获得key值为O 并且value是1则演奏低音，2则是中音，3则是高音
        switch (Convert.ToInt32(value))
        {
            case 1:
                scale = "低音";
                break;
            case 2:
                scale = "中音";
                break;
            case 3:
                scale = "高音";
                break;
        }
        Debug.LogFormat("{0}", scale);
    }
}
//音速类
public class Speed : Expression
{
    public override void Excute(string key, double value)
    {
        string speed = "";
        if (value < 500)
            speed = "快速";
        else if (value >= 1000)
            speed = "慢速";
        else
            speed = "中速";
        Debug.LogFormat("{0} ", speed);
    }
}