一文搞懂解释器模式

最新推荐文章于 2021-10-09 15:36:07 发布
最新推荐文章于 2021-10-09 15:36:07 发布
阅读量90 收藏
点赞数
分类专栏： 基础知识 go 文章标签： go 设计模式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_36059306/article/details/120013543
版权

原理

为新的"语言"定义语法规则，定义一个解释器用来解释语法

实现核心

将不同操作符的操作拆分到单独的操作符表达式类里面，避免大而全的解析类

最佳实践1

需求背景

假设我们定义了一个新的加减乘除计算“语言”，语法规则如下：
运算符只包含加、减、乘、除，并且没有优先级的概念；
表达式（也就是前面提到的“句子”）中，先书写数字，后书写运算符，空格隔开；
按照先后顺序，取出两个数字和一个运算符计算结果，结果重新放入数字的最头部位置，循环上述过程，直到只剩下一个数字，这个数字就是表达式最终的计算结果。

比如“ 8 3 2 4 - + * ”这样一个表达式，我们按照上面的语法规则来处理，取出数字“8 3”和“-”运算符，计算得到 5，于是表达式就变成了“ 5 2 4 + * ”。然后，我们再取出“ 5 2 ”和“ + ”运算符，计算得到 7，表达式就变成了“ 7 4 * ”。最后，我们取出“ 7 4”和“ * ”运算符，最终得到的结果就是 28。

实现版本1

type ExpressionInterpreter struct{}

func (i *ExpressionInterpreter) Interpreter(s string) int64 {
	strList := strings.Split(s, " ")
	numberQueue := queue.New()
	for i := 0; i < (len(strList)+1)/2; i++ {
		num, _ := strconv.ParseInt(strList[i], 10, 64)
		numberQueue.PushBack(num)
	}
	for i := (len(strList) + 1) / 2; i < len(strList); i++ {
		var result int64
		num1 := numberQueue.PopFront().(int64)
		num2 := numberQueue.PopFront().(int64)
		sign := strList[i]
		if sign == "+" {
			result = num1 + num2
		} else if sign == "-" {
			result = num1 - num2
		} else if sign == "*" {
			result = num1 * num2
		} else if sign == "/" {
			result = num1 / num2
		} else {
			panic("illegal sign")
		}
		numberQueue.PushFront(result)
	}
	if numberQueue.Len() != 1 {
		panic("expression illegal")
	}
	return numberQueue.PopFront().(int64)
}

这里每个运算符的逻辑比较简单，所以放在一个类中没有问题，但是如果每个运算符的逻辑都很复杂，就会导致这个类很大，可读性下降，所以我们可以将每个运算符的逻辑拆成单独的类

实现版本2

type Expression interface {
	Interpreter() int64
}

type NumExpression struct {
	num int64
}

func NewNumExpression(num int64) *NumExpression {
	return &NumExpression{
		num: num,
	}
}

func (e *NumExpression) Interpreter() int64 {
	return e.num
}

type AddExpression struct {
	leftExp  Expression
	rightExp Expression
}

func NewAddExpression(leftExp Expression, rightExp Expression) *AddExpression {
	return &AddExpression{
		leftExp:  leftExp,
		rightExp: rightExp,
	}
}

func (e *AddExpression) Interpreter() int64 {
	return e.leftExp.Interpreter() + e.rightExp.Interpreter()
}

type SubtractExpression struct {
	leftExp  Expression
	rightExp Expression
}

func NewSubtractExpression(leftExp Expression, rightExp Expression) *SubtractExpression {
	return &SubtractExpression{
		leftExp:  leftExp,
		rightExp: rightExp,
	}
}

func (e *SubtractExpression) Interpreter() int64 {
	return e.leftExp.Interpreter() - e.rightExp.Interpreter()
}

type MulExpression struct {
	leftExp  Expression
	rightExp Expression
}

func NewMulExpression(leftExp Expression, rightExp Expression) *MulExpression {
	return &MulExpression{
		leftExp:  leftExp,
		rightExp: rightExp,
	}
}

func (e *MulExpression) Interpreter() int64 {
	return e.leftExp.Interpreter() * e.rightExp.Interpreter()
}

type DivisionExpression struct {
	leftExp  Expression
	rightExp Expression
}

func NewDivisionExpression(leftExp Expression, rightExp Expression) *DivisionExpression {
	return &DivisionExpression{
		leftExp:  leftExp,
		rightExp: rightExp,
	}
}

func (e *DivisionExpression) Interpreter() int64 {
	return e.leftExp.Interpreter() / e.rightExp.Interpreter()
}

func (i *ExpressionInterpreter) InterpreterV2(s string) int64 {
	strList := strings.Split(s, " ")
	numberQueue := queue.New()
	for i := 0; i < (len(strList)+1)/2; i++ {
		num, _ := strconv.ParseInt(strList[i], 10, 64)
		numberQueue.PushBack(num)
	}
	for i := (len(strList) + 1) / 2; i < len(strList); i++ {
		var result int64
		num1 := NewNumExpression(numberQueue.PopFront().(int64))
		num2 := NewNumExpression(numberQueue.PopFront().(int64))
		sign := strList[i]
		var expression Expression
		if sign == "+" {
			expression = NewAddExpression(num1, num2)
		} else if sign == "-" {
			expression = NewSubtractExpression(num1, num2)
		} else if sign == "*" {
			expression = NewMulExpression(num1, num2)
		} else if sign == "/" {
			expression = NewDivisionExpression(num1, num2)
		} else {
			panic("illegal sign")
		}
		result = expression.Interpreter()
		numberQueue.PushFront(result)
	}
	if numberQueue.Len() != 1 {
		panic("expression illegal")
	}
	return numberQueue.PopFront().(int64)
}

最佳实践2

需求背景

在我们平时的项目开发中，监控系统非常重要，它可以时刻监控业务系统的运行情况，及时将异常报告给开发者。比如，如果每分钟接口出错数超过 100，监控系统就通过短信、微信、邮件等方式发送告警给开发者。
一般来讲，监控系统支持开发者自定义告警规则，比如我们可以用下面这样一个表达式，来表示一个告警规则，它表达的意思是：
每分钟 API 总出错数超过 100 或者每分钟 API 总调用数超过 10000 就触发告警。
api_error_per_minute > 100 || api_count_per_minute > 10000

我们假设自定义的告警规则只包含“||、&&、>、<、”这五个运算符，其中，“>、<、”运算符的优先级高于“||、&&”运算符，“&&”运算符优先级高于“||”。在表达式中，任意元素之间需要通过空格来分隔。除此之外，用户可以自定义要监控的 key，比如前面的 api_error_per_minute、api_count_per_minute。

代码实现

type AlterExpression interface {
	Interpreter(stats map[string]int) bool
}

type GreaterExpression struct {
	key   string
	value int
}

func NewGreaterExpression(key string, value int) *GreaterExpression {
	return &GreaterExpression{
		key:   key,
		value: value,
	}
}

func (e *GreaterExpression) Interpreter(stats map[string]int) bool {
	v, ok := stats[e.key]
	if ok == false {
		return false
	}
	return v > e.value
}

type LessExpression struct {
	key   string
	value int
}

func NewLessExpression(key string, value int) *LessExpression {
	return &LessExpression{
		key:   key,
		value: value,
	}
}

func (e *LessExpression) Interpreter(stats map[string]int) bool {
	v, ok := stats[e.key]
	if ok == false {
		return false
	}
	return v < e.value
}

type EqualExpression struct {
	key   string
	value int
}

func NewEqualExpression(key string, value int) *EqualExpression {
	return &EqualExpression{
		key:   key,
		value: value,
	}
}

func (e *EqualExpression) Interpreter(stats map[string]int) bool {
	v, ok := stats[e.key]
	if ok == false {
		return false
	}
	return e.value == v
}

type AndExpression struct {
	expressionList []AlterExpression
}

func NewAndExpression(rule string) *AndExpression {
	strList := strings.Split(rule, `&&`)
	expList := make([]AlterExpression, 0, len(strList))
	for i := range strList {
		str := strings.Trim(strList[i], " ")
		opStrList := strings.Split(str, " ")
		sign := opStrList[1]
		key := opStrList[0]
		valueStr := opStrList[2]
		value, _ := strconv.ParseInt(valueStr, 10, 64)
		if sign == ">" {
			expList = append(expList, NewGreaterExpression(key, int(value)))
		} else if sign == "<" {
			expList = append(expList, NewLessExpression(key, int(value)))
		} else if sign == "" {
			expList = append(expList, NewEqualExpression(key, int(value)))
		} else {
			panic("illegal op")
		}
	}
	return &AndExpression{
		expressionList: expList,
	}
}

func (e *AndExpression) Interpreter(stats map[string]int) bool {
	for i := range e.expressionList {
		expression := e.expressionList[i]
		if expression.Interpreter(stats) == false {
			return false
		}
	}
	return true
}

type OrExpression struct {
	expressionList []AlterExpression
}

func NewOrExpression(rule string) *OrExpression {
	strList := strings.Split(rule, `||`)
	expList := make([]AlterExpression, 0, len(strList))
	for i := range strList {
		str := strings.Trim(strList[i], " ")
		expList = append(expList, NewAndExpression(str))
	}
	return &OrExpression{
		expressionList: expList,
	}
}

func (e *OrExpression) Interpreter(stats map[string]int) bool {
	for i := range e.expressionList {
		expression := e.expressionList[i]
		if expression.Interpreter(stats) {
			return true
		}
	}
	return false
}

type AlterRuleInterpreter struct {
	expression AlterExpression
}

func NewAlterRuleInterpreter(ruleExpression string) *AlterRuleInterpreter {
	return &AlterRuleInterpreter{
		expression: NewOrExpression(ruleExpression),
	}
}

func (i *AlterRuleInterpreter) Interpreter(stats map[string]int) bool {
	return i.expression.Interpreter(stats)
}

func ApplicationTest() {
	rule := "key1 > 100 && key2 < 30 || key3 < 100 || key4 == 88"
	alterRuleInterpreter := NewAlterRuleInterpreter(rule)
	stats := map[string]int{
		"key1": 101,
		"key2": 18,
		"key3": 121,
		"key4": 88,
	}
	alter := alterRuleInterpreter.Interpreter(stats)
	if alter {
		println("报警!!!")
	}
}
So_Powerful
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
一文搞懂C语言回调函数
01-27
我们先来看看百度百科是如何定义回调函数的：回调函数就是一个通过函数指针调用的函数。如果你把函数的指针（地址）作为参数传递给另一个函数，当这个指针被用来调用其所指向的函数时，我们就说这是回调函数。...
一文搞懂设计模式—单例模式
BookSea的博客
02-04 997
在软件开发中，有些对象我们只需要一个实例，通过单例模式可以确保一个类只有一个实例
一文彻底搞懂单例设计模式
qq_34800986的博客
03-12 156
所谓类的单例设计模式，就是采取一定的方法保证在整个的软件系统中，对某个类只能存在一个对象实例， 并且该类只提供一个取得其对象实例的方法(静态方法)。 比如 Hibernate 的 SessionFactory，它充当数据存储源的代理，并负责创建 Session 对象。SessionFactory 并不是轻量级的，一般情况下，一个项目通常只需要一个 SessionFactory 就够，这是就会使用到单例模式。
一文搞懂JVM内存结构
热门推荐
真正的大师，永远怀着一颗学徒的❤
04-11 8万+
1. 前言 Java 虚拟机是中、高级开发人员必须修炼的知识，有着较高的学习门槛，很多人都不情愿去接触它。可能是觉得学习成本较高又或者是感觉没什么实用性，所以干脆懒得“搭理”它了。其实这种想法是错误的。举个最简单的例子，JVM 基本上是每家招聘公司都会问到的问题，它们会这么无聊问这些不切实际的问题吗？很显然不是。由 JVM 引发的故障问题，无论在我们开发过程中还是生产环境下都是非常常见的。比如 ...
python解释器和python_一文搞懂Python解释器，终端，编辑器区别和联系
weixin_36080939的博客
12-29 486
前言对于刚刚接触或者对Python有一些了解的初学者，很难区分Python解释器，编辑器以及终端这些概念。以致于在学习教程的时候遇到一些困难以及犯一些错误。这篇文章，我带领大家深入了解这些概念的区别和联系，从此再也不会因为概念问题而犯晕。看这篇文章的时候，大家最好亲自动手，这样可以更有收获。概要了解终端概念，学会在终端运行命令。了解Python解释器，学会调试Python程序。了解编辑器概念，认识...
一文搞懂高速转换器原理、作用
01-20
作为"现实世界"模拟域与 1 和 0 构成的数字世界之间的关口，数据转换器是现代信号处理中的关键要素之一。过去 30 年，数据转换领域涌现出了大量创新技术，这些技术不但助推了从医疗成像到蜂窝通信、再到消费音视频，...
一文弄懂采集器是什么
01-20
关于采集器，通常会用两种解释：工业数据采集器采集器还有盘点机器这一名字想必大家都清楚，其拥有一体性、机动性、体积小、重量轻等特点，而且还具备着超高的性能，并且适于手持等特点。市场上也有一种
一文搞懂Raft算法
01-27
raft是工程上使用较为广泛的强一致性、去中心化、高可用的分布式协议。在这里强调了是在工程上，因为在学术理论界，最耀眼的还是大名鼎鼎的Paxos。但Paxos是：少数真正理解的人觉得简单，尚未理解的人觉得很难，...
一文搞懂混合动力汽车
01-14
经过4S店销售的一顿狂轰乱炸，你还是搞不懂混合动力汽车有插电式与非插电式之分，还有串联式、并联式、混联式的区别。 无妨，接着看下文也许你就懂了！ 混合动力汽车透视图 传统汽车由内燃机燃烧...
设计原则实战—电商平台积分系统
qq_36059306的博客
09-13 1437
需求背景 设计一个简单的电商平台积分系统 需求分析 借鉴竞品 先去借鉴一下其他电商平台的积分系统是怎么设计的，可以去使用一下淘宝的积分系统或者百度搜一下"淘宝积分兑换规则"，就能摸清积分系统大致的功能。 积分系统的功能简单分成两类：积分的赚取渠道和兑换规则，赚取渠道比如有下单、签到、答题等，兑换规则比如有签到送10积分，答题全对送10积分，下单后返送某个下单金额比例的积分等；积分的消费渠道和兑换规则，消费渠道比如有下单抵钱、换优惠券等，兑换规则比如下单时按照某个比例抵扣用户拥有的积分、10积分换一张特定的优
编程规范实战—ID生成器
qq_36059306的博客
09-18 1042
需求背景 假设你正在参与一个后端业务系统的开发，为了方便在请求出错时排查问题，我们在编写代码的时候会在关键路径上打印日志。某个请求出错之后，我们希望能搜索出这个请求对应的所有日志，以此来查找问题的原因。而实际情况是，在日志文件中，不同请求的日志会交织在一起。如果没有东西来标识哪些日志属于同一个请求，我们就无法关联同一个请求的所有日志。 我们可以给每个请求分配一个唯一 ID，并且保存在请求的上下文（Context）中。每次打印日志的时候，我们从请求上下文中取出请求 ID，跟日志一块输出。这样，同一个请求的所有
grpool协程池—控制goroutine数量利器
qq_36059306的博客
10-09 709
目的 grpool的目的就是控制执行任务的goroutine数量，避免创建过多的goroutine导致内存占用飙升 简单使用 func UseWorkerPool() { pool := grpool.NewPool(100, 50) defer pool.Release() for i := 0; i < 10; i++ { count := i pool.JobQueue <- func() { fmt.Prin
一文搞懂DRY原则
qq_36059306的博客
09-10 683
定义 不要重复自己 注意：重复的代码不一定违反DRY原则，不重复的代码也有可能违反DRY原则 三种典型场景 代码逻辑重复 功能语义重复 代码重复执行 代码逻辑重复 比如UserService有两个方法，一个IsValidUserName校验用户名，一个IsValidPassword校验密码 type UserService2 struct{} func (s *UserService2) IsValidUserName(username string) bool { if username == ""
ErrGroup: 处理一组子任务
qq_36059306的博客
06-26 618
针对场景 有时候将一个大任务拆成多个没有依赖关系的小任务并行执行，可以提升并发度，这时候就可以采用ErrGroup ErrGroup和WaitGroup有些类似，但是它提供的功能更加丰富： 可以和Context集成 error向上传播，会将子任务的error传播到调用者 简单使用 WithContext func WithContext(ctx context.Context) (*Group, context.Context) 创建一个ErrGroup，返回一个可以cancel的Context，一旦
一文搞懂依赖反转原则
qq_36059306的博客
09-08 546
定义 依赖反转包括两部分：控制反转、依赖注入 控制反转 先看下面这段代码 type UserServiceTest struct{} func (t *UserServiceTest) DoTest() bool { println("test logic") return true } func ApplicationMain() { u := new(UserServiceTest) if u.DoTest() { println("test success") } else {
Mutex：互斥锁源码解读
qq_36059306的博客
06-30 471
Mutex count++操作问题 count++是非原子操作，所以有并发问题 什么是原子操作 所谓原子操作是指不会被线程调度机制打断的操作；这种操作一旦开始，就一直运行到结束，中间不会有任何 context switch（操作系统保证）。所以原子操作在单处理器中是没有并发问题的。 但是光靠系统，无法保证多处理器下原子操作的并发安全 例子： 以decl （递减指令）为例，这是一个典型的"读－改－写"过程，涉及两次内存访问。设想在不同CPU运行的两个进程都在递减某个计数值，可能发生的情况是： ⒈ CPU A(
一文搞懂接口隔离原则
qq_36059306的博客
09-07 468
定义 客户端不应该被强迫依赖它不需要的接口，这里的客户端指接口的调用者 接口可以理解为下面三种东西： 一组API接口集合 单个API接口或者函数 OOP中的接口概念 一组API接口集合 一组API接口集合指的就是微服务或者类库 比如开发一个用户系统微服务，提供了一组和用户相关的接口给外部系统使用 type UserService interface { Register(username string, password string) Login(username string, password s
Pool：对象池源码解读
qq_36059306的博客
06-30 433
Pool 针对场景 如果你创建的对象过多，那么触发GC的频率会变高、GC的执行时间会变长，所以如果想开发一个高性能应用的话，就需要将经常使用的对象池化减少对象的创建 注意： 垃圾回收时会回收Pool里面的对象 syncPool本身就是线程安全的，多个goroutine可以并发存取对象 syncPool不可复制使用 源码解析 数据结构 Pool的数据结构如下： Pool对象 local：[P]poolLocal，P大小的poolLocal数组 victim：上一个周期的local数组 poolLocal
一文搞懂yolov9训练
最新发布
04-19
6. 训练过程：通过反向传播算法和优化器对模型进行训练。训练过程中，模型会根据损失函数的反馈进行参数更新，逐渐提高模型的准确性。 7. 模型评估：训练完成后，需要对模型进行评估，通常使用验证集或测试集来评估...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值