简介

解说器形式(Interpreter Pattern)是一种行为型规划形式。这种形式完成了一个表达式接口,该接口解说一个特定的上下文。这种形式常被用在 SQL 解析、符号处理引擎等。

解说器形式常用于对简略言语的编译或剖析实例中,为了把握好它的结构与完成,必须先了解编译原理中的“文法、句子、语法树”等相关概念。

作用

  1. 可扩展性比较好,灵敏,增加了新的解说表达式的方法,易于完成简略文法。
  2. 在语法树中的每个表达式节点类都是相似的,所以完成其文法较为简略。

完成过程

  1. 创立笼统表达式接口(Expression),各种表达式都要完成该接口。
  2. 别离创立终究表达式和非终究表达式。终究表达式(这儿是VarExpression)没有子级,直接解说表达式。非终究表达式(这儿是AddExpression和SubtractExpression)是维护子表达式的容器,并将解说请求转发给这些表达式。
  3. 创立上下文环境类(这儿是Context),用来表达式求值时构建履行环境。
  4. 客户端调用时先树立履行上下文环境,然后声明变量,再进行核算。

UML

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

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;

更多言语版别

不同言语完成规划形式,请重视:github.com/microwind/d…