Interpreter

动机(Motivation)

• 如果某一特定领域的问题比较复杂，类似的结构不断重复出现，如果使用普通的编程方式来实现将面临非常频繁的变化。
• 在这种情况下，将特定领域的问题表达为某种语法规则下的句子，然后构建一个解释器来解释这样的句子，从而达到解决问题的目的。

模式定义

给定一个语言，定义它的文法的一种表示，并定义一种解释器，这个解释器使用该表示来解释语言中的句子。
——《设计模式》GoF

要点总结

• Interpreter模式的应用场合是Interpreter模式应用中的难点，只有满足“业务规则频繁变化，且类似的结构不断重复出现，
  并且容易抽象为语法规则的问题”才适合使用Interpreter模式。
• 使用Interpreter模式来表示文法规则，从而可以使用面向对象技巧来方便地“扩展”文法。
• Interpreter模式适合简单的文法表示，对于复杂的文法表示需要求助语法分析器标准工具。

例子

# -*- coding:utf-8 -*-


class Expression(object):

    def interpreter(self, key, value):
        pass


class VarExpression(Expression):
    def __init__(self, key):
        self.key = key

    def interpreter(self, var_map):
        return var_map.get(self.key)

class SymbolExpression(Expression):
    def __init__(self, left, right):
        self.left, self.right = left, right


# 加法运算
class AddExpression(SymbolExpression):
    def interpreter(self, var_map):
        result = self.left.interpreter(var_map) + self.right.interpreter(var_map)
        return result


# 加法运算
class SubExpression(SymbolExpression):
    def interpreter(self, var_map):
        result = self.left.interpreter(var_map) - self.right.interpreter(var_map)
        return result

def analyse(exp_str):
    exp_stack = []
    #for i in range(len(exp_str)):
    i = 0
    while i < len(exp_str):
        if exp_str[i] == '+':
            left = exp_stack[-1]
            i += 1
            right = VarExpression(exp_str[i])
            exp_stack.append(AddExpression(left, right))
        elif exp_str[i] == '-':
            left = exp_stack[-1]
            i += 1
            right = VarExpression(exp_str[i])
            exp_stack.append(SubExpression(left, right))
        else:
            # 变量表达式
            exp_stack.append(VarExpression(exp_str[i]))

        print('exp_str[i]:', exp_str[i])
        i += 1
    return exp_stack[-1]


if __name__ == '__main__':

    expStr = "a+b-c+d-e"
    var_map = {'a': 5, 'b': 2, 'c': 1, 'd': 6, 'e': 10}

    expression = analyse(expStr)

    result = expression.interpreter(var_map)
    print('result:', result)

例子中将简单的四则运算作为了一个解释器，当该运算频繁出现的时候，直接调用解释器即可获得结果。