设计模式-24-解释器模式

Design Patterns Comments

解释器模式定义一套语言文法，并设计该语言解释器，使用户能使用特定文法控制解释器行为。解释器模式的意义在于，它分离多种复杂功能的实现，每个功能只需关注自身的解释。对于调用者不用关心内部的解释器的工作，只需要用简单的方式组合命令就可以

逻辑结构

Expression

代码实现

代码路径：https://github.com/XBoom/DesignPatterns/tree/main/23_Expression

  1. 首先，定义了解释器接口

    1
    2
    3
    4
    // Expression 表达式接口
    type Expression interface {
    	Interpret() bool
    }

  2. 接着，实现终结符表达式

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    // TerminalExpression 终结符表达式
    type TerminalExpression struct {
    	data string
    }

    func NewTerminalExpression(data string) *TerminalExpression {
    	return &TerminalExpression{
    		data: data,
    	}
    }

    func (t *TerminalExpression) Interpret() bool {
    	// 在实际应用中，此处可以进行语言文法解释的具体逻辑判断
    	// 这里简化，当 data 为 "true" 时返回 true，否则返回 false
    	return t.data == "true"
    }

  3. 然后，实现非终结符表达式

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    // NonTerminalExpression 非终结符表达式
    type NonTerminalExpression struct {
    	exp1     Expression
    	exp2     Expression
    	operator string
    }

    func NewNonTerminalExpression(exp1, exp2 Expression, operator string) *NonTerminalExpression {
    	return &NonTerminalExpression{
    		exp1:     exp1,
    		exp2:     exp2,
    		operator: operator,
    	}
    }

    func (n *NonTerminalExpression) Interpret() bool {
    	// 在实际应用中，此处可以进行语言文法解释的具体逻辑判断
    	// 这里简化，只实现简单的逻辑运算，支持 "and" 和 "or" 操作符
    	switch n.operator {
    	case "and":
    		return n.exp1.Interpret() && n.exp2.Interpret()
    	case "or":
    		return n.exp1.Interpret() || n.exp2.Interpret()
    	default:
    		return false
    	}
    }

运行

1
2
3
4
5
6
7
8
9
10
11
12
13
14
// 构建解释器规则：(true and false) or (true or true)
exp1 := NewTerminalExpression("true")
exp2 := NewTerminalExpression("false")
andExpr := NewNonTerminalExpression(exp1, exp2, "and")

exp3 := NewTerminalExpression("true")
exp4 := NewTerminalExpression("true")
orExpr := NewNonTerminalExpression(exp3, exp4, "or")

rootExpr := NewNonTerminalExpression(andExpr, orExpr, "or")

// 解释并计算表达式结果
result := rootExpr.Interpret()
fmt.Println("表达式计算结果：", result) // Output: 表达式计算结果： true

结果

1
表达式计算结果： true

应用场景

  1. 自定义实现一个自定义接口告警规则功能
  2. 适用于需要解释和执行某种语言文法的场景，例如编程语言的解释器、正则表达式引擎等。它可以灵活地处理复杂的文法规则，并将其转化为具体的操作和结果

参考链接

  1. https://lailin.xyz/post/interpreter.html