技术教程 编程代码 【解释器设计模式详解】C/Java/Go/JS/TS/Python不同语言实现 正文

【解释器设计模式详解】C/Java/Go/JS/TS/Python不同语言实现

2023-07-10,,

简介

解释器模式（Interpreter Pattern）是一种行为型设计模式。这种模式实现了一个表达式接口，该接口解释一个特定的上下文。这种模式常被用在 SQL 解析、符号处理引擎等。

解释器模式常用于对简单语言的编译或分析实例中，为了掌握好它的结构与实现，必须先了解编译原理中的“文法、句子、语法树”等相关概念。

作用

    可扩展性比较好，灵活，增加了新的解释表达式的方式，易于实现简单文法。
    在语法树中的每个表达式节点类都是相似的，所以实现其文法较为容易。

实现步骤

    创建抽象表达式接口（Expression），各种表达式都要实现该接口。
    分别创建最终表达式和非最终表达式。最终表达式（这里是VarExpression）没有子级，直接解释表达式。非最终表达式（这里是AddExpression和SubtractExpression）是维护子表达式的容器，并将解释请求转发给这些表达式。
    创建上下文环境类（这里是Context），用来表达式求值时构建执行环境。
    客户端调用时先建立执行上下文环境，然后声明变量，再进行计算。

UML

Java代码

抽象表达式接口

// Expression.java 抽象表达式接口，根据业务场景规范表达式

public interface Expression {

  public int interpret(Context context);

}

具体表达式实现

// AddExpression.java 具体表达式，实现了抽象表达式接口

public class AddExpression implements Expression {

    private Expression exprOne = null;

    private Expression exprTwo = null;

    public AddExpression(Expression exprOne, Expression exprTwo) {

        this.exprOne = exprOne;

        this.exprTwo = exprTwo;

    }

    // 覆盖表达式，执行context对象

    @Override

    public int interpret(Context context) {

        System.out.println(this.getClass().getName() + "::interpret() [context = " + context.getClass().getName() + "]");

        return exprOne.interpret(context) + exprTwo.interpret(context);

    }

}

// SubtractExpression.java 具体表达式，实现了抽象表达式接口

public class SubtractExpression implements Expression {

  private Expression exprOne = null;

  private Expression exprTwo = null;

  public SubtractExpression(Expression exprOne, Expression exprTwo) {

    this.exprOne = exprOne;

    this.exprTwo = exprTwo;

  }

  // 覆盖表达式，执行context对象

  @Override

  public int interpret(Context context) {

    System.out.println(this.getClass().getName() + "::interpret() [context = " + context.getClass().getName() + "]");

    return exprOne.interpret(context) - exprTwo.interpret(context);

  }

}

// VarExpression.java 变量表达式，或者叫终端表达式，其他表达式求值时通过层层追溯最后指向这里

// 变量与执行环境的Key对应，最终会通过key获取传入的值

public class VarExpression implements Expression {

  private String key;

  public VarExpression(String key) {

    this.key = key;

  }

  @Override

  // 覆盖表达式，根据key获取变量

  public int interpret(Context context) {

    return context.get(key);

  }

}

执行环境类

// Context.java 构建可执行环境上下文

public class Context {

   private Map<String, Integer> map = new HashMap<>();

   public Context(String key, int value) {

      this.add(key, value);

   }

   public Context() {

   }

   public void add(String key, int value) {

      map.put(key, value);

   }

   public int get(String key) {

      return map.get(key);

   }

}

// Application.java 调用程序，组织各种解释器

    /*

     * 解释器模式先构建执行上下文Context，然后构建一个最终的获取值的表达式VarExpression，这就构成了含上下文和变量-值的基本环境。

     * 再将基本环境放到工具表达式里AddExpression或SubtractExpreesion进行计算，最终得到结果。

     */

   // 构建两个数相加的例子

   public static int addTwo(int one, int two) {

      // 构建执行上下文环境

      Context context = new Context();

      context.add("one", one);

      context.add("two", two);

      // 构建表达式

      VarExpression varOne = new VarExpression("one");

      VarExpression varTwo = new VarExpression("two");

      // 再构建变量来进行计算，看起来啰嗦，但这样构建多种不同表达式计算就变得简单

      Expression result = new AddExpression(varOne, varTwo);

      return result.interpret(context);

   }

   // 构建连加计算的例子

   public static int addMore(int... numbers) {

      if (numbers.length <= 1) {

         return numbers[0];

      }

      Context context = new Context();

      // 构建执行环境

      for (int num : numbers) {

         context.add("num" + num, num);

      }

      // 先取出前两个作为计算基础

      VarExpression varOne = new VarExpression("num" + numbers[0]);

      VarExpression varTwo = new VarExpression("num" + numbers[1]);

      // 再构建表达式，先赋值前两个

      Expression expression = new AddExpression(varOne, varTwo);

      // 如果只有两个数则直接返回计算结果

      if (numbers.length == 2) {

         return expression.interpret(context);

      }

      // 如果数量超过两个则累加表达式再求值

      for (int i = 2; i < numbers.length; i++) {

         Expression nextExpression = new VarExpression("num" + numbers[i]);

         // 表达式不断累加

         expression = new AddExpression(expression, nextExpression);

      }

      return expression.interpret(context);

   }

   // 计算前两个数相加，再减去后一个数的计算例子

   public static int addAndSubtract(int one, int two, int three) {

      // 构建执行上下文环境，有3个可操作的域

      Context context = new Context();

      context.add("one", one);

      context.add("two", two);

      context.add("three", three);

      // 构建表达式，有3个变量

      VarExpression varOne = new VarExpression("one");

      VarExpression varTwo = new VarExpression("two");

      VarExpression varThree = new VarExpression("three");

      // 再构建计算步骤，前两个用加法

      Expression result = new AddExpression(varOne, varTwo);

      result = new SubtractExpression(result, varThree);

      // 第3个用减法

      return result.interpret(context);

   }

测试调用

    /**

     * 解释器模式实现了一个表达式接口，该接口可以解释一个特定的上下文的变量和语句。

     * 也就是先定义上下文，然后定义变量，再使用表达式进行求值。相当可以构造一个简单的语法解析器。

     */

    int result1 = Application.addTwo(1, 2);

    System.out.println("result1: " + result1);

    int result2 = Application.addMore(1, 2, 3, 4, 5);

    System.out.println("result2: " + result2);

    int result3 = Application.addAndSubtract(3, 4, 5);

    System.out.println("result3: " + result3);

Go代码

抽象表达式接口

// Expression.go 抽象表达式接口，根据业务场景规范表达式

type Expression interface {

  Interpret(context Context) int

}

具体表达式实现

// AddExpression.go 具体表达式，实现了抽象表达式接口

type AddExpression struct {

  exprOne Expression

  exprTwo Expression

}

func (a *AddExpression) Init(exprOne Expression, exprTwo Expression) {

  a.exprOne = exprOne

  a.exprTwo = exprTwo

}

// 覆盖表达式，执行context对象

func (a *AddExpression) Interpret(context Context) int {

  fmt.Println("AddExpression::interpret() [context = Context]")

  return a.exprOne.Interpret(context) + a.exprTwo.Interpret(context)

}

// SubtractExpression.go 具体表达式，实现了抽象表达式接口

type SubtractExpression struct {

  exprOne Expression

  exprTwo Expression

}

func (s *SubtractExpression) Init(exprOne Expression, exprTwo Expression) {

  s.exprOne = exprOne

  s.exprTwo = exprTwo

}

// 覆盖表达式，执行context对象

func (s *SubtractExpression) Interpret(context Context) int {

  fmt.Println("SubtractExpression::Interpret() [context = Context]")

  return s.exprOne.Interpret(context) - s.exprTwo.Interpret(context)

}

// VarExpression.go 变量表达式，或者叫终端表达式，其他表达式求值时通过层层追溯最后指向这里

// 变量与执行环境的Key对应，最终会通过key获取传入的值

type VarExpression struct {

  key string

}

// 覆盖表达式，根据key获取变量

func (v VarExpression) Interpret(context Context) int {

  return context.Get(v.key)

}

执行环境类

// Context.go 构建可执行环境上下文

type Context struct {

  Map map[string]int

}

func (c *Context) Init(key string, value int) {

  c.Map = make(map[string]int)

  c.Add(key, value)

}

func (c *Context) Add(key string, value int) {

  if c.Map == nil {

    c.Map = make(map[string]int)

  }

  c.Map[key] = value

}

func (c *Context) Get(key string) int {

  return c.Map[key]

}

// Application.go 调用程序，组织各种解释器

    /*

     * 解释器模式先构建执行上下文Context，然后构建一个最终的获取值的表达式VarExpression，这就构成了含上下文和变量-值的基本环境。

     * 再将基本环境放到工具表达式里AddExpression或SubtractExpreesion进行计算，最终得到结果。

     */

type Application struct {

}

// 构建两个数相加的例子

func (a *Application) AddTwo(one int, two int) int {

  // 构建执行上下文环境

  var context = new(Context)

  context.Add("one", one)

  context.Add("two", two)

  // 构建表达式

  var varOne = &VarExpression{key: "one"}

  var varTwo = &VarExpression{key: "two"}

  // 再构建变量来进行计算，看起来啰嗦，但这样构建多种不同表达式计算就变得简单

  var result = &AddExpression{

    exprOne: varOne,

    exprTwo: varTwo,

  }

  return result.Interpret(*context)

}

// 构建连加计算的例子

func (a *Application) AddMore(numbers ...int) int {

  if len(numbers) <= 1 {

    return numbers[0]

  }

  var context = new(Context)

  // 构建执行环境

  for _, num := range numbers {

    context.Add(""+strconv.Itoa(num), num)

  }

  // 先取出前两个作为计算基础

  var varOne = &VarExpression{key: "" + strconv.Itoa(numbers[0])}

  var varTwo = &VarExpression{key: "" + strconv.Itoa(numbers[1])}

  // 再构建表达式，先赋值前两个

  var expression = &AddExpression{

    exprOne: varOne,

    exprTwo: varTwo,

  }

  // 如果只有两个数则直接返回计算结果

  if len(numbers) == 2 {

    return expression.Interpret(*context)

  }

  // 如果数量超过两个则累加表达式再求值

  for i := 2; i < len(numbers); i++ {

    var nextExpression = &VarExpression{

      key: "" + strconv.Itoa(numbers[i]),

    }

    // 表达式不断累加

    expression = &AddExpression{

      exprOne: expression,

      exprTwo: nextExpression,

    }

  }

  return expression.Interpret(*context)

}

// 计算前两个数相加，再减去后一个数的计算例子

func (a *Application) AddAndSubtract(one int, two int, three int) int {

  // 构建执行上下文环境，有3个可操作的域

  var context = &Context{}

  context.Add("one", one)

  context.Add("two", two)

  context.Add("three", three)

  // 构建表达式，有3个变量

  var varOne = &VarExpression{key: "one"}

  var varTwo = &VarExpression{key: "two"}

  var varThree = &VarExpression{key: "three"}

  // 再构建计算步骤，前两个用加法

  var result Expression

  result = &AddExpression{

    exprOne: varOne,

    exprTwo: varTwo,

  }

  result = &SubtractExpression{

    exprOne: result,

    exprTwo: varThree,

  }

  // 第3个用减法

  return result.Interpret(*context)

}

测试调用

    /*

     * 解释器模式先构建执行上下文Context，然后构建一个最终的获取值的表达式VarExpression，这就构成了含上下文和变量-值的基本环境。

     * 再将基本环境放到工具表达式里AddExpression或SubtractExpreesion进行计算，最终得到结果。

     */

  /**

   * 解释器模式实现了一个表达式接口，该接口可以解释一个特定的上下文的变量和语句。

   * 也就是先定义上下文，然后定义变量，再使用表达式进行求值。相当可以构造一个简单的语法解析器。

   */

  var application = &src.Application{}

  var result1 = application.AddTwo(1, 2)

  fmt.Println("result1: ", result1)

  var result2 = application.AddMore(1, 2, 3, 4, 5)

  fmt.Println("result2: ", result2)

  var result3 = application.AddAndSubtract(3, 4, 5)

  fmt.Println("result3: ", result3)

C代码

func.h head文件

// 构建可执行环境上下文

typedef struct Context

{

    char **keys;

    int *values;

    int length;

    void (*add)(struct Context *, char *key, int value);

    int (*get)(struct Context *, char *key);

} Context;

Context *context_constructor();

// 抽象表达式接口，根据业务场景规范表达式

typedef struct Expression

{

    char name[50];

    char key[50];

    struct Expression *exp_one;

    struct Expression *exp_two;

    void (*set_key)(struct Expression *, char *);

    int (*interpret)(struct Expression *, Context *);

} Expression;

// 具体表达式，实现了抽象表达式接口

typedef struct AddExpression

{

    char name[50];

    char key[50];

    struct Expression *exp_one;

    struct Expression *exp_two;

    void (*set_key)(struct AddExpression *, char *);

    int (*interpret)(struct AddExpression *, Context *);

} AddExpression;

AddExpression *add_expression_constructor(Expression *exp_one, Expression *exp_two);

// 具体表达式，实现了抽象表达式接口

typedef struct SubtractExpression

{

    char name[50];

    char key[50];

    struct Expression *exp_one;

    struct Expression *exp_two;

    void (*set_key)(struct SubtractExpression *, char *);

    int (*interpret)(struct SubtractExpression *, Context *);

} SubtractExpression;

SubtractExpression *subtract_expression_constructor(Expression *exp_one, Expression *exp_two);

// 具体表达式，实现了抽象表达式接口

typedef struct VarExpression

{

    char name[50];

    char key[50];

    struct Expression *exp_one;

    struct Expression *exp_two;

    void (*set_key)(struct VarExpression *, char *);

    int (*interpret)(struct VarExpression *, Context *);

} VarExpression;

VarExpression *var_expression_constructor(char *key);

// application function list

// 将两个数值相加

int add_two(int one, int two);

// 将多个数字相加，第1个为数量，后面可以传入多个数字

int add_more(int count, ...);

// 计算前两个数相加，再减去后一个数的计算例子

int add_and_subtract(int one, int two, int three);

抽象表达式接口

// expression.c 抽象表达式接口，根据业务场景规范表达式

// 抽象表达式接口，根据业务场景规范表达式，定义在head

具体表达式实现

// add_expression.c 具体表达式，实现了抽象表达式接口

int add_expression_interpret(Expression *exp, Context *context)

{

  printf("\r\n AddExpression::interpret() [exp_one=%s, exp_two=%s]", exp->exp_one->key, exp->exp_two->key);

  int one_result = exp->exp_one->interpret(exp->exp_one, context);

  int two_result = exp->exp_two->interpret(exp->exp_two, context);

  return one_result + two_result;

}

AddExpression *add_expression_constructor(Expression *exp_one, Expression *exp_two)

{

  printf("\r\n add_expression_constructor() [exp_one=%s, exp_two=%s]", exp_one->key, exp_two->key);

  Expression *exp = (Expression *)malloc(sizeof(Expression));

  exp->interpret = &add_expression_interpret;

  exp->exp_one = exp_one;

  exp->exp_two = exp_two;

  AddExpression *add_expression = (AddExpression *)exp;

  return add_expression;

}

// subtract_expression.c 具体表达式，实现了抽象表达式接口

int subtract_expression_interpret(Expression *exp, Context *context)

{

  printf("\r\n SubExpression::interpret() [exp_one=%s, exp_two=%s]", exp->exp_one->key, exp->exp_two->key);

  int one_result = exp->exp_one->interpret(exp->exp_one, context);

  int two_result = exp->exp_two->interpret(exp->exp_two, context);

  return one_result - two_result;

}

SubtractExpression *subtract_expression_constructor(Expression *exp_one, Expression *exp_two)

{

  printf("\r\n sub_expression_constructor() [exp_one=%s, exp_two=%s]", exp_one->key, exp_two->key);

  Expression *exp = (Expression *)malloc(sizeof(Expression));

  exp->interpret = &subtract_expression_interpret;

  exp->exp_one = exp_one;

  exp->exp_two = exp_two;

  SubtractExpression *sub_expression = (SubtractExpression *)exp;

  return sub_expression;

}

// var_expression.c 变量表达式，或者叫终端表达式，其他表达式求值时通过层层追溯最后指向这里

// 变量与执行环境的Key对应，最终会通过key获取传入的值

int var_expression_interpret(Expression *exp, Context *context)

{

  int value = context->get(context, exp->key);

  printf("\r\n VarExpression::interpret() [key=%s, value=%d]", exp->key, value);

  return value;

}

void set_key(Expression *exp, char *key)

{

  strncpy(exp->key, key, 50);

}

VarExpression *var_expression_constructor(char *key)

{

  printf("\r\n var_expression_constructor() [key=%s]", key);

  Expression *exp = (Expression *)malloc(sizeof(Expression));

  strncpy(exp->key, key, 50);

  exp->interpret = &var_expression_interpret;

  exp->set_key = &set_key;

  VarExpression *var_expression = (VarExpression *)exp;

  return var_expression;

}

执行环境类

// context.c 构建可执行环境上下文

void add(Context *context, char *key, int value)

{

  printf("\r\n Context::add() [key=%s, value=%d]", key, value);

  // 申请新的数组

  int new_len = context->length + 1;

  char **new_keys = (char **)calloc(new_len * 50, sizeof(char));

  int *new_values = (int *)malloc(new_len * sizeof(int));

  // 复制原来的数组内容

  for (int i = 0; i < context->length; i++)

  {

    new_keys[i] = context->keys[i];

    new_values[i] = context->values[i];

  }

  // 追加新的内容

  new_keys[context->length] = key;

  new_values[context->length] = value;

  // 指向新数组

  context->keys = new_keys;

  context->values = new_values;

  // 重设新的长度

  context->length = new_len;

}

int get(Context *context, char *key)

{

  int idx;

  for (int i = 0; i < context->length; i++)

  {

    if (strcmp(context->keys[i], key) == 0)

    {

      idx = i;

      break;

    }

  }

  return context->values[idx];

}

// 构建可执行环境上下文

Context *context_constructor()

{

  printf("\r\n context_constructor() 构建执行上下文");

  Context *context = (Context *)malloc(sizeof(Context));

  context->keys = NULL;

  context->values = NULL;

  context->length = 0;

  context->add = &add;

  context->get = &get;

  return context;

}

// application.c 调用程序，组织各种解释器

/*

 * 解释器模式先构建执行上下文Context，然后构建一个最终的获取值的表达式VarExpression，这就构成了含上下文和变量-值的基本环境。

 * 再将基本环境放到工具表达式里AddExpression或SubtractExpreesion进行计算，最终得到结果。

 */

// 将int转str的简单实现，未处理越界等情况

char *itoa(int num)

{

  char *str = (char *)malloc(50 * sizeof(char));

  int sign = num;

  if (num < 0)

  {

    num = -num;

  }

  int i = 0;

  do

  { // 生成数字

    str[i++] = num % 10 + '0';

  } while ((num /= 10) > 0);

  // 处理负数

  if (sign < 0)

  {

    str[i++] = '-';

  }

  str[i] = '\0';

  // 翻转字符串

  for (int j = 0, k = i - 1; j < k; j++, k--)

  {

    char temp = str[j];

    str[j] = str[k];

    str[k] = temp;

  }

  return str;

}

// 构建两个数相加的例子

int add_two(int one, int two)

{

  // 构建执行上下文环境

  Context *context = context_constructor();

  context->add(context, "one", one);

  context->add(context, "two", two);

  // 构建表达式

  VarExpression *var_one = var_expression_constructor("one");

  Expression *var_two = (Expression *)var_expression_constructor("two");

  // 构建变量和多种不同表达式进行计算，使得计算就变得简单

  AddExpression *result = add_expression_constructor((Expression *)var_one, var_two);

  return result->interpret(result, context);

}

// 构建连加计算的例子，不定参数调用，第1参数是数量，后面是数字

int add_more(int count, ...)

{

  // 构建执行上下文环境

  Context *context = context_constructor();

  va_list args;

  va_start(args, count);

  for (int i = 0; i < count; i++)

  {

    int value = va_arg(args, int);

    // 构建执行环境，value直接作为key

    char *key_str = (char *)malloc(50 * sizeof(char));

    strcat(key_str, "key_");

    strcat(key_str, itoa(value));

    context->add(context, key_str, value);

  }

  va_end(args);

  // 先取出前两个作为计算基础

  // 构建执行环境，num直接作为key

  char key1_str[50] = "key_";

  strcat(key1_str, itoa(context->values[0]));

  VarExpression *var_one = var_expression_constructor(key1_str);

  char key2_str[50] = "key_";

  strcat(key2_str, itoa(context->values[1]));

  VarExpression *var_two = var_expression_constructor(key2_str);

  // 再构建表达式，先赋值前两个

  AddExpression *expression = add_expression_constructor((Expression *)var_one, (Expression *)var_two);

  // 如果只有两个数则直接返回计算结果

  if (count == 2)

  {

    return expression->interpret(expression, context);

  }

  // 如果数量超过两个则累加表达式再求值

  for (int i = 2; i < count; i++)

  {

    VarExpression *next_expression = var_expression_constructor(context->keys[i]);

    expression = add_expression_constructor((Expression *)expression, (Expression *)next_expression);

  }

  return expression->interpret(expression, context);

}

// 计算前两个数相加，再减去后一个数的计算例子

int add_and_subtract(int one, int two, int three)

{

  // 构建执行上下文环境，有3个可操作的域

  Context *context = context_constructor();

  context->add(context, "one", one);

  context->add(context, "two", two);

  context->add(context, "three", three);

  // 构建表达式，有3个变量

  VarExpression *var_one = var_expression_constructor("one");

  VarExpression *var_two = var_expression_constructor("two");

  VarExpression *var_three = var_expression_constructor("three");

  // 前两个用加法

  Expression *result = (Expression *)add_expression_constructor((Expression *)var_one, (Expression *)var_two);

  // 第3个用减法

  result = (Expression *)subtract_expression_constructor(result, (Expression *)var_three);

  return result->interpret(result, context);

}

测试调用

   /**

   * 解释器模式实现了一个表达式接口，该接口可以解释一个特定的上下文的变量和语句。

   * 也就是先定义上下文，然后定义变量，再使用表达式进行求值。相当可以构造一个简单的语法解析器。

   */

  int result1 = add_two(1, 2);

  printf("\r\n result1:[1 + 2 = %d]", result1);

  // 计算多个数字，第1个为数量，后面是待计算的数字

  int result2 = add_more(5, 1, 2, 3, 4, 5);

  printf("\r\n result2: [1 + 2 + 3 + 4 + 5 = %d]", result2);

  int result3 = add_and_subtract(3, 4, 5);

  printf("\r\n result3: [3 + 4 - 5 = %d]", result3);

  return 0;

更多语言版本

不同语言实现设计模式，请关注：https://github.com/microwind/design-pattern

【解释器设计模式详解】C/Java/Go/JS/TS/Python不同语言实现的相关教程结束。

《【解释器设计模式详解】C/Java/Go/JS/TS/Python不同语言实现.doc》

下载本文的Word格式文档，以方便收藏与打印。

Copyright 2023. 昆居客 - IT编程,互联网信息技术文档大全!