关于设计模式:设计模式解析器Interpreter模式

模式定义

给定一个语言,定义它的文法的一种示意,并定义一种解释器,这个解释器应用该示意来解释语言中的句子

类图

要点总结

  • Interpreter模式的利用场合是Interpreter模式利用中的难点,只有满足“业务规定频繁变动,且相似的构造一直反复呈现,并且容易形象为语法规定的问题”才适宜应用Interpreter模式
  • 应用interpreter模式来示意文法规定,从而能够应用面向对象技巧来不便地“扩大”文法
  • Interpreter模式比拟适宜简略的文法示意,对于简单的文法示意,Interpreter模式会产生比拟大的类层次结构,须要求助于语法分析生成器这样的规范工具

Go语言代码实现

工程目录

Interpretor.go

package Interpreter

import "strings"

type Expression interface {
   Interpret(variables map[string]Expression)int
}

type Interger struct {
   integer int
}

func (n *Interger) Interpret(variables map[string]Expression) int {
   return n.integer
}

type Plus struct {
   leftOperand Expression
   rightOperand Expression
}

func (p *Plus) Interpret(variables map[string]Expression) int {
   return p.leftOperand.Interpret(variables) + p.rightOperand.Interpret(variables)
}

func (e Evaluator) Interpret(variable map[string]Expression)int{
   return e.syntaxTree.Interpret(variable)
}

type Variable struct {
   name string
}

type Node struct {
   value interface{}
   next *Node
}

type Stack struct {
   top *Node
   size int
}

func (s *Stack) Push (value interface{}){
   s.top= &Node{
      value: value,
      next:  s.top,
   }
}

func (v *Variable) Interpret(variable map[string]Expression)int {
   value, found := variable[v.name]
   if !found {
      return 0
   }
   return value.Interpret(variable)
}

func (s *Stack) Pop() interface{} {
   if s.size == 0{
      return nil
   }
   value := s.top.value
   s.top = s.top.next
   s.size--
   return value
}

type Evaluator struct {
   syntaxTree Expression
}
func NewEvaluator(expression string) *Evaluator{
   expressionStack := new(Stack)
   for _, token := range strings.Split(expression, " ") {
      switch token {
      case "+":
         right := expressionStack.Pop().(Expression)
         left := expressionStack.Pop().(Expression)
         subExpression := &Plus{left, right}
         expressionStack.Push(subExpression)
      default:
         expressionStack.Push(&Variable{token})
      }
   }
   syntaxTree := expressionStack.Pop().(Expression)
   return &Evaluator{syntaxTree: syntaxTree}
}

Interpretor_test.go

package Interpreter

import (
   "fmt"
   "testing"
)

func TestInterger(t *testing.T) {
   expression := "w x z +"
   sentence := NewEvaluator(expression)
   variables := make(map[string]Expression)
   variables["w"] = &Interger{6}
   variables["x"] = &Interger{10}
   variables["z"] = &Interger{41}
   result := sentence.Interpret(variables)
   fmt.Println(result)
}

【腾讯云】云产品限时秒杀,爆款1核2G云服务器,首年99元

阿里云限时活动-1核2G-1M带宽-40-100G ,特惠价87.12元/年(原价1234.2元/年,可以直接买3年),速抢

本文由乐趣区整理发布,转载请注明出处,谢谢。

You may also like...

发表评论

邮箱地址不会被公开。 必填项已用*标注

此站点使用Akismet来减少垃圾评论。了解我们如何处理您的评论数据