设计模式——20. 解释器模式

最新推荐文章于 2024-08-23 21:42:58 发布
最新推荐文章于 2024-08-23 21:42:58 发布
阅读量249 收藏
点赞数
分类专栏： 设计模式大全 文章标签： 设计模式 解释器模式 golang python java javascript c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/guohuang/article/details/133801226
版权

1. 说明

解释器模式（Interpreter Pattern）是一种行为型设计模式，它用于定义一门语言的语法解析，并为该语言创建解释器。该模式将一个问题或领域表达成一个语言，然后提供一个解释器来解释这种语言中的表达式，以执行特定操作。

要点和组成部分：

  1. 抽象表达式（Abstract Expression）：定义解释器的接口，通常包括一个 interpret 方法，用于解释表达式。
  2. 终结符表达式（Terminal Expression）：实现抽象表达式接口的具体类，代表了语言中的终结符（例如，变量、常量等），其 interpret 方法通常执行具体操作。
  3. 非终结符表达式（Non-terminal Expression）：实现抽象表达式接口的具体类，代表了语言中的非终结符，其 interpret 方法通常包含了对子表达式的解释逻辑。
  4. 上下文环境（Context）：维护了解释器运行时的上下文信息，包括变量、数据等。
  5. 客户端（Client）：创建和配置具体的表达式，并将它们组合成一个表达式树，然后调用解释器来解释该树。

解释器模式的优点：

  • 可扩展性：可以轻松添加新的表达式和规则，而无需修改现有解释器。
  • 易于维护：将语言的语法解析和执行分离，使代码更易于理解和维护。

解释器模式的缺点：

  • 复杂性：解释器模式可能会导致大量的具体表达式类，因此在处理复杂语法时，代码可能会变得冗长。

总之，解释器模式用于定义语言的语法规则和解释表达式的值，它在某些领域中非常有用，但也需要谨慎使用，以避免过度复杂的表达式和类层次结构。

2. 使用的场景

解释器模式通常在以下场景中被使用：

  1. 编程语言解释器：解释器模式最常见的应用之一是编程语言的解释器，例如Python、JavaScript等编程语言都有解释器来解析和执行代码。
  2. 配置文件解析：当需要解析复杂的配置文件或数据格式时，可以使用解释器模式来定义解析规则，并编写解释器来解释配置文件。
  3. 正则表达式引擎：正则表达式的解析和匹配通常使用解释器模式。
  4. 数据库查询解析器：在数据库系统中，查询语言通常需要解释和执行，因此可以使用解释器模式来构建查询解析器。
  5. 自然语言处理：在自然语言处理领域，解释器模式可用于解析和分析自然语言文本。
  6. 数学表达式求值器：解释器模式可用于构建数学表达式求值器，例如计算器应用程序。
  7. 模板引擎：一些模板引擎使用解释器模式来解析模板并生成动态内容。
  8. 游戏开发：在游戏开发中，解释器模式可以用于处理游戏脚本或关卡描述，以及处理游戏中的特定事件和行为。

总之，解释器模式适用于需要解释和执行特定语言或规则的情况，它可以帮助将复杂的语法规则分解成可管理的组件，并实现语法解析和执行的灵活性。但在使用解释器模式时，需要注意确保不会过度复杂化代码结构，以避免维护困难。

3. 应用例子

以下是一个使用Python语言实现的解释器模式示例，演示了如何解释和计算简单的数学表达式：

# 抽象表达式类
class Expression:
    def interpret(self, context):
        pass

# 终结符表达式类 - 数字
class Number(Expression):
    def __init__(self, value):
        self.value = value

    def interpret(self, context):
        return int(self.value)

# 非终结符表达式类 - 加法
class Add(Expression):
    def __init__(self, left, right):
        self.left = left
        self.right = right

    def interpret(self, context):
        return self.left.interpret(context) + self.right.interpret(context)

# 上下文类 - 包含表达式的上下文
class Context:
    def __init__(self):
        self.expression_stack = []

    def push(self, expression):
        self.expression_stack.append(expression)

    def pop(self):
        return self.expression_stack.pop()

    def evaluate(self):
        return self.expression_stack[-1].interpret(self)

# 客户端代码
if __name__ == "__main__":
    # 创建上下文
    context = Context()

    # 构建表达式树：2 + 3
    context.push(Number(2))
    context.push(Number(3))
    context.push(Add(context.pop(), context.pop()))

    # 计算结果
    result = context.evaluate()
    print("计算结果:", result)

在这个示例中，我们定义了抽象表达式类 Expression，终结符表达式类 Number（用于表示数字），以及非终结符表达式类 Add（用于表示加法操作）。上下文类 Context 用于管理表达式树的构建和计算。

在客户端代码中，我们构建了一个表示数学表达式 “2 + 3” 的表达式树，并计算了表达式的结果。这个示例演示了如何使用解释器模式来解释和计算简单的数学表达式。

4. 实现要素

解释器模式的实现要素包括以下部分：

  1. 抽象表达式（Abstract Expression）：定义了解释器的接口，通常包括一个 interpret() 方法，该方法用于解释表达式。
  2. 终结符表达式（Terminal Expression）：继承自抽象表达式，用于表示语法树中的终结符（最小单位）并实现解释方法。
  3. 非终结符表达式（Non-terminal Expression）：继承自抽象表达式，用于表示语法树中的非终结符（复合单位），通常包含多个子表达式，并实现解释方法。
  4. 上下文（Context）：维护解释器的状态，包括解释器需要的信息和数据。上下文对象通常包括一个表达式堆栈，用于构建和管理语法树。

5. UML图

下面是解释器模式的简化UML类图：

+-------------------+        +------------------+
|   Abstract        |        |   Terminal      |
|   Expression      |        |   Expression    |
+-------------------+        +------------------+
|  +interpret()     |        |  +interpret()   |
+-------------------+        +------------------+
       /\                        /\
       |                          |
       |                          |
+-------------------+   +-------------------+
|   Non-terminal    |   |    Context        |
|   Expression      |   |                   |
+-------------------+   +-------------------+
|  +interpret()     |
+-------------------+

在上述UML图中，Abstract Expression 定义了解释器的接口，Terminal Expression 和 Non-terminal Expression 分别表示终结符和非终结符表达式。Context 维护解释器的状态和上下文信息。

实际实现中，根据具体需求，可能需要创建多个具体的终结符表达式和非终结符表达式类来处理不同的语法规则。这些类之间协同工作，构建语法树并执行解释操作。

6. Java/golang/javascrip/C++ 等语言实现方式

6.1 Java实现

上述例子用Java语言实现示例如下：

import java.util.Stack;

// 抽象表达式接口
interface Expression {
    int interpret(Context context);
}

// 终结符表达式类 - 数字
class Number implements Expression {
    private int value;

    public Number(int value) {
        this.value = value;
    }

    @Override
    public int interpret(Context context) {
        return value;
    }
}

// 非终结符表达式类 - 加法
class Add implements Expression {
    private Expression left;
    private Expression right;

    public Add(Expression left, Expression right) {
        this.left = left;
        this.right = right;
    }

    @Override
    public int interpret(Context context) {
        return left.interpret(context) + right.interpret(context);
    }
}

// 上下文类
class Context {
    private Stack<Expression> expressionStack = new Stack<>();

    public void push(Expression expression) {
        expressionStack.push(expression);
    }

    public Expression pop() {
        return expressionStack.pop();
    }
}

public class Main {
    public static void main(String[] args) {
        // 创建上下文
        Context context = new Context();

        // 构建表达式树：2 + 3
        context.push(new Number(2));
        context.push(new Number(3));
        context.push(new Add(context.pop(), context.pop()));

        // 计算结果
        int result = context.pop().interpret(context);
        System.out.println("计算结果: " + result);
    }
}

在这个示例中，我们使用Java语言实现了解释器模式。同样，我们定义了抽象表达式接口 Expression，终结符表达式类 Number 和非终结符表达式类 Add。上下文类 Context 用于管理表达式树的构建和计算。
在客户端代码中，我们构建了一个表示数学表达式 “2 + 3” 的表达式树，并计算了表达式的结果。这个示例演示了如何使用解释器模式来解释和计算简单的数学表达式。

6.2 Golang实现

上述例子用golang实现示例如下：

package main

import "fmt"

// Expression 接口定义了解释器的解释方法
type Expression interface {
        Interpret() int
}

// Number 表示终结符表达式，代表一个数字
type Number struct {
        value int
}

func (n *Number) Interpret() int {
        return n.value
}

// Add 表示非终结符表达式，执行加法操作
type Add struct {
        left  Expression
        right Expression
}

func (a *Add) Interpret() int {
        return a.left.Interpret() + a.right.Interpret()
}

// Context 维护解释器运行时的上下文
type Context struct {
        expressionStack []Expression
}

func (c *Context) Push(expression Expression) {
        c.expressionStack = append(c.expressionStack, expression)
}

func (c *Context) Pop() Expression {
        length := len(c.expressionStack)
        if length == 0 {
                return nil
        }
        expression := c.expressionStack[length-1]
        c.expressionStack = c.expressionStack[:length-1]
        return expression
}

func main() {
        // 创建上下文
        context := &Context{}

        // 构建表达式树：2 + 3
        context.Push(&Number{value: 2})
        context.Push(&Number{value: 3})
        context.Push(&Add{left: context.Pop(), right: context.Pop()})

        // 计算结果
        result := context.Pop().Interpret()
        fmt.Println("计算结果:", result)
}

在这个示例中，我们使用Go语言实现了解释器模式。我们定义了 Expression 接口，Number 和 Add 类来表示终结符和非终结符表达式，以及 Context 类来维护解释器的上下文信息。
在客户端代码中，我们构建了一个表示数学表达式 “2 + 3” 的表达式树，并计算了表达式的结果。这个示例演示了如何使用解释器模式来解释和计算简单的数学表达式。

6.3 Javascript实现

上述例子用javascript实现示例如下：

// 抽象表达式类
class Expression {
  interpret() {}
}

// 终结符表达式类 - 数字
class Number extends Expression {
  constructor(value) {
    super();
    this.value = value;
  }

  interpret() {
    return this.value;
  }
}

// 非终结符表达式类 - 加法
class Add extends Expression {
  constructor(left, right) {
    super();
    this.left = left;
    this.right = right;
  }

  interpret() {
    return this.left.interpret() + this.right.interpret();
  }
}

// 上下文类
class Context {
  constructor() {
    this.expressionStack = [];
  }

  push(expression) {
    this.expressionStack.push(expression);
  }

  pop() {
    return this.expressionStack.pop();
  }
}

// 客户端代码
const context = new Context();

// 构建表达式树：2 + 3
context.push(new Number(2));
context.push(new Number(3));
context.push(new Add(context.pop(), context.pop()));

// 计算结果
const result = context.pop().interpret();
console.log("计算结果:", result);

在这个示例中，我们使用JavaScript语言实现了解释器模式。我们定义了抽象表达式类 Expression，终结符表达式类 Number 和非终结符表达式类 Add。上下文类 Context 用于管理表达式树的构建和计算。
在客户端代码中，我们构建了一个表示数学表达式 “2 + 3” 的表达式树，并计算了表达式的结果。这个示例演示了如何使用解释器模式来解释和计算简单的数学表达式。

6.4 C++实现

上述例子用C++实现如下：

#include <iostream>
#include <stack>

// 抽象表达式类
class Expression {
public:
    virtual int interpret() = 0;
};

// 终结符表达式类 - 数字
class Number : public Expression {
private:
    int value;

public:
    Number(int val) : value(val) {}

    int interpret() override {
        return value;
    }
};

// 非终结符表达式类 - 加法
class Add : public Expression {
private:
    Expression* left;
    Expression* right;

public:
    Add(Expression* l, Expression* r) : left(l), right(r) {}

    int interpret() override {
        return left->interpret() + right->interpret();
    }
};

// 上下文类
class Context {
private:
    std::stack<Expression*> expressionStack;

public:
    void push(Expression* expression) {
        expressionStack.push(expression);
    }

    Expression* pop() {
        if (expressionStack.empty()) {
            return nullptr;
        }
        Expression* expression = expressionStack.top();
        expressionStack.pop();
        return expression;
    }
};

int main() {
    // 创建上下文
    Context context;

    // 构建表达式树：2 + 3
    context.push(new Number(2));
    context.push(new Number(3));
    context.push(new Add(context.pop(), context.pop()));

    // 计算结果
    int result = context.pop()->interpret();
    std::cout << "计算结果: " << result << std::endl;

    return 0;
}

在这个示例中，我们使用C++语言实现了解释器模式。我们定义了抽象表达式类 Expression，终结符表达式类 Number 和非终结符表达式类 Add。上下文类 Context 用于管理表达式树的构建和计算。
在客户端代码中，我们构建了一个表示数学表达式 “2 + 3” 的表达式树，并计算了表达式的结果。这个示例演示了如何使用解释器模式来解释和计算简单的数学表达式。

7. 练习题

假设你正在为一个简单的文本处理器编写代码，该文本处理器需要能够解释特定的自定义标记以将文本中的变量替换为实际值。你需要设计一个解释器模式来实现这个功能。
假设有以下自定义标记：

  1. {Var1}：代表变量1。
  2. {Var2}：代表变量2。
  3. {Var3}：代表变量3。

要求：

  1. 编写一个解释器，将文本中的这些标记解释为实际的变量值。
  2. 编写一个使用解释器的示例代码，将文本中的标记替换为变量值，并输出最终的文本。例如，如果输入的文本是：“Hello, {Var1}! Your score is {Var2}.”，变量1的值是 “John”，变量2的值是 “90”，那么最终的输出应该是：“Hello, John! Your score is 90.”。

你可以使用 C++、Java、Python 或任何其他编程语言来实现这个练习。
你可以在评论区里或者私信我回复您的答案，这样我或者大家都能帮你解答，期待着你的回复~

guohuang
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
设计模式——JAVA.docx
04-03
- **行为型模式**（共11种）：策略模式、模板方法模式、观察者模式、迭代子模式、责任链模式、命令模式、备忘录模式、状态模式、访问者模式、中介者模式、解释器模式。 每一种设计模式都有其特定的应用场景和解决的...
《java设计模式》课后习题模拟试题解答——刘伟.zip
12-26
本资料“《java设计模式》课后习题模拟试题解答——刘伟.zip”主要涵盖了Java设计模式的学习与应用，特别是针对刘伟教授的相关课程的课后习题及模拟试题的解答。 设计模式分为三大类：创建型、结构型和行为型模式。...
解释器模式(Interpreter Pattern)
weixin_34315189的博客
09-20 126
动机(Motivate):     在软件构建过程中，如果某一特定领域的问题比较复杂，类似的模式不断重复出现，如果使用普通的编程方式来实现将面临非常频繁的变化。     在这种情况下，将特定领域的问题表达为某种文法规则下的句子，然后构建一个解释器来解释这样的句子，从而达到解决问题的目的。 意图(Intent):     给定一个语言，定义它的文法的一种表示，并定义一个解释器，这个解释器使用...
net设计模式 （解释器模式）学习笔记
唐僧的专栏
11-17 263
运用设计模式只是为了解决一类问题的，当解决掉当前一类问题，通常会在解决这个问题时候 带来其他问题  合理应用扬长避短 行为型设计模式：                                net设计模式 （解释器模式）学习笔记 概要：主要用于语法解析，对于解析规则 可以灵活切换， 但是规则的过多 也会增加解释器 的子类。     /// &lt;summary&gt...
解释器模式---Interpreter
时光里的博客
08-16 394
解释器模式 定义: 构建语法树，定义终结符与非终结符。 在 GOF 的书中指出：如果一种特定类型的问题发生的频率足够高，那么可能就值得将该问题的各个实例表述为一个简单语言中的句子。这样就可以构建一个解释器，该解释器通过解释这些句子来解决该问题。 给定一个语言，定义它的文法表示，并定义一个解释器，这个解释器使用该标识来解释语言中的句子。 解释器模式（Interpreter Pattern）是指给定一门语言，定义它的文法的一种表示(如：加减乘除表达式和正则表达式等)，然后再定义一个解释器，该解释器用来解释
解释器模式（interpreter）
王梦杰_MengJie
05-29 2236
给定一个语言，定义它的文法的一种表示，并定义一个解释器，这个解释器使用该表示来解释语言中的句子。如果在一个系统中需要匹配字符的需求在软件的很多地方都会使用，而且行为之间都非常类似，过去的做法是针对特定的需求，编写特定的函数，比如判断Email、匹配电话号码等等，与其为每一个特定需求都写一个算法函数，不如使用一种通用的搜索算法来解释执行一个正则表达式，该正则表达式定义了待匹配字符串的集合。
Net设计模式实例之解释器模式（Interpreter Pattern）
weixin_34290390的博客
02-02 58
一、解释器模式简介（Brief Introduction） 解释器模式（Interpreter Pattern），给定一个语言，定义它的文法的一种表示，并定义一个解释器，这个解释器使用该表示来解释语言中的句子。使用了解释器模式，可以很容易地改变和扩展文法，因为该模式使用类来表示文法规则，可以使用继承来改变或扩展该文法。也比较容易实现文法，因为定义抽象语法树中各个节点的类的实现大体类似，这些类容易...
23种设计模式（14）：解释器模式
java开发指南博客 【转载】
06-15 434
定义：给定一种语言，定义他的文法的一种表示，并定义一个解释器，该解释器使用该表示来解释语言中句子。 类型：行为类模式 类图： 解释器模式是一个比较少用的模式，本人之前也没有用过这个模式。下面我们就来一起看一下解释器模式。 解释器模式的结构 抽象解释器：声明一个所有具体表达式都要实现的抽象接口（或者抽象类），接口中主要是一个interpret()方法，称为解释操作。具体解释任务...
大话设计模式——解释器模式
理想主义的花最终会盛开在浪漫主义的土壤里，我的热情永远不会熄灭在现实的平凡之中，我们终将上岸，阳光万里。
03-13 1922
一、定义 ①、什么是解释器模式 给定一个语言，定义它得到文法的一种表示，并定义一个解释器，这个解释器使用该表示来解释语言中的句子。 ②、主要解决什么问题 对于一些固定的文法构建一个解释句子的解释器 ③、如何解决 构建语法树，定义终极符与非终结符 ④、什么时候使用 如果一种特定类型的问题发生的频率足够高，那么可能就值得该问题的各个实例表述为一个简单语言的句子。这样就可以构建一个解释器，该解释器通过解释这些句子来解决该问题 ⑤、使用场景 可以将一个需要解释执行的语言中的句子表示为一个抽象的语法树 一些重复出现
Python设计模式编程中解释器模式的简单程序示例分享
09-21
### Python设计模式编程中解释器模式的简单程序示例 #### 概述 解释器模式是一种行为型设计模式，主要用于处理定义良好的语法或语言结构。它通过构建一系列类来解析和执行这些语言中的语句。在本文中，我们将探讨...
设计模式之解释器
09-22
本文将通过具体的例子——加减运算来详细阐述解释器模式的原理及其应用。 #### 二、解释器模式的构成要素 解释器模式主要包括以下几个角色： - **抽象表达式角色**（AbstractExpression）：声明一个抽象的解释...
设计模式之美——教你写出高质量代码
04-10
3. 行为型模式：如策略模式、模板方法模式、观察者模式、命令模式、迭代器模式、责任链模式、备忘录模式、状态模式、解释器模式和访问者模式。这些模式主要处理对象之间的通信和行为，让代码更易于理解和扩展。 在...
解释器模式
jialiang的博客
05-21 534
简介：解释器模式提供了评估语言的语法或表达式的方式，它属于行为型模式。这种模式实现了一个表达式接口，该接口解释一个特定的上下文。这种模式被用在 SQL 解析、符号处理引擎等。适用场景： 1、可以将一个需要解释执行的语言中的句子表示为一个抽象语法树。 2、一些重复出现的问题可以用一种简单的语言来进行表达。 3、一个简单语法需要解释的场景。解释器模式一般使用较少，在开发中碰到类似场景可以使用expre...
设计模式 5 原型模式
小小程序猿
08-23 521
原型模式允许一个对象通过复制自身来创建新的对象。这种模式提供了一种创建对象的快捷方式，尤其适用于创建代价较高的对象。
设计模式六大原则：迪米特法则详细说明和案例示范
weixin_39996520的博客
08-20 571
只与直接的朋友通信：一个对象应当只与那些与它关系密切的对象直接通信，而不应该依赖于太多的其他对象。避免过度依赖：对象之间的依赖关系应该尽量减少，避免形成复杂的依赖链。在实际开发中，这意味着我们应该设计简洁的接口，避免对象过度依赖于其他对象的内部细节，从而减少对象之间的耦合度。迪米特法则强调对象之间的交互应尽可能少，避免产生复杂的依赖关系。通过引入中介类或封装层，可以将依赖关系控制在合理的范围内，减少类之间的耦合度，提高系统的可维护性和可扩展性。
二十三设计模式速记
慢慢
08-23 317
Java设计模式通常被分为三大类：创建型模式（Creational Patterns）、结构型模式（Structural Patterns）和行为型模式（Behavioral Patterns）。每种类型包含若干种具体的设计模式。创建型模式（Creational Patterns）：结构型模式（Structural Patterns）：行为型模式（Behavioral Patterns）：
设计模式六大原则之一的接口隔离原则
jun778895的博客
08-20 1260
接口隔离原则的定义是：客户端不应该依赖它不需要的接口；一个类对另一个类的依赖应该建立在最小的接口上。换句话说，接口的设计应当尽量细化，每个接口只包含客户端需要的方法，而不是将所有可能的方法都放在一个接口中。接口隔离原则是面向对象设计中的一个重要原则，它强调了接口的设计应当尽量保持简洁和专一。通过细化接口、减少依赖和提高复用性等方式，接口隔离原则有助于降低系统的复杂性、提高系统的灵活性和可维护性。然而，在应用接口隔离原则时，也需要注意避免过度细化接口和增加系统的复杂性。
设计模式-结构型模式-代理模式
LB_bei的博客
08-22 1065
让你能够提供对象的代替品或占位符，代理控制着对于原对象的访问，并允许将请求提交给对象前后进行一些处理；
C++设计模式3:工厂模式
最新发布
LorraineWen的博客
08-23 413
C++实现工厂模式
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

guohuang

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值