解释器模式
目录
- 解释器模式
-
-
- 解释器模式
- 分析
-
- 应用场景
- 代码实现
-
- 输出
- 实例
-
- 代码
- 测试
- 总结
解释器模式可以描述如何构建一个简单的“语言”解释器。这个模式只在一些特定的领域才有可能用到，如编译器、规则引擎、正则表达式等。好在解释器模式比较简单，大家可以了解一下。
解释器模式
解释器模式：给定一个语言，定义它的文法的一种表示，并定义一个解释器，这个解释器使用该表示来解释语言中的句子。
UML：
分析
通过定义可以看出，“语言”必然存在规则，而且规则可能相对复杂。对于每一条规则，可以设置对应的类来翻译。
模式定义与UML完全对应，解释器Expression用于翻译Context，由于Context包含内容类型不同，对这些不同类型的内容创建不同解释器进行解释。
举个例子，假设定义一个新的加减乘除语言，对于 8 + 2 - 5这种情况，新的语言为 8 2 5 + -。在这个例子中，Context就是8 2 5 + -，新语言包含数字和运算符，我们就可以创建数字解释器和运算符解释器，对数字和运算符进行解释。
为什么要用解释器模式呢？
主要是为了将语法解析的工作拆分到各个小类中，以此来避免大而全的解析类。
如果打算用解释器模式，一般的做法是，将语法规则拆分成一些小的独立的单元，然后对每个单元进行解析，最终合并为对整个语法规则的解析。
应用场景
解释器模式一般用于编译器、规则引擎、正则表达式，这些功能实现起来都比较麻烦，就不实现它们了。
在实际生活中，我对于中文、英文、编程语言都有一些了解，所以能够解释、理解它们。但对于音乐、舞蹈，根本不知道怎么欣赏。
所以看歌舞表演的时候，特别想有一款翻译器，能对音乐、舞蹈进行翻译，让我了解创作者想表达什么。而且查看解释器源码我也能知道音乐、舞蹈的一般规则，更便于今后的学习。
代码实现
现在让我们开始翻译歌舞剧！
package main
import "fmt"
/**
* @Description: 内容信息
*/
type Context struct {
action string
content string
}
/**
* @Description: 翻译接口
*/
type Interpreter interface {
Interpret(c Context)
}
/**
* @Description: 翻译音乐
*/
type MusicInterpreter struct {
}
/**
* @Description: 翻译音乐内容
* @receiver m
* @param c
*/
func (m MusicInterpreter) Interpret(c Context) {
fmt.Println(c.action + " 中 " + c.content + " 的意思是感情高昂")
}
/**
* @Description: 翻译舞蹈
*/
type DanceInterpreter struct {
}
/**
* @Description: 翻译舞蹈内容
* @receiver d
* @param c
*/
func (d DanceInterpreter) Interpret(c Context) {
fmt.Println(c.action + " 中 " + c.content + " 的意思是悲凉")
}
func main() {
cList := []Context{
{
action: "music", content: "高音"},
{
action: "music", content: "低音"},
{
action: "dance", content: "跳跃"},
{
action: "dance", content: "挥手"},
}
//对歌舞剧内容进行翻译
for _, c := range cList {
if c.action == "music" {
MusicInterpreter{
}.Interpret(c)
} else if c.action == "dance" {
DanceInterpreter{
}.Interpret(c)
}
}
}
输出
*myproject go run main.go
music 中 高音 的意思是感情高昂
music 中 低音 的意思是感情高昂
dance 中 跳跃 的意思是悲凉
dance 中 挥手 的意思是悲凉
实例
代码
// Package interpreter 解释器模式
// 采用原课程的示例, 并且做了一下简化
// 假设我们现在有一个监控系统
// 现在需要实现一个告警模块，可以根据输入的告警规则来决定是否触发告警
// 告警规则支持 &&、>、< 3种运算符
// 其中 >、< 优先级比 && 更高
package interpreter
import (
"fmt"
"regexp"
"strconv"
"strings"
)
// AlertRule 告警规则
type AlertRule struct {
expression IExpression
}
// NewAlertRule NewAlertRule
func NewAlertRule(rule string) (*AlertRule, error) {
exp, err := NewAndExpression(rule)
return &AlertRule{
expression: exp}, err
}
// Interpret 判断告警是否触发
func (r AlertRule) Interpret(stats map[string]float64) bool {
return r.expression.Interpret(stats)
}
// IExpression 表达式接口
type IExpression interface {
Interpret(stats map[string]float64) bool
}
// GreaterExpression >
type GreaterExpression struct {
key string
value float64
}
// Interpret Interpret
func (g GreaterExpression) Interpret(stats map[string]float64) bool {
v, ok := stats[g.key]
if !ok {
return false
}
return v > g.value
}
// NewGreaterExpression NewGreaterExpression
func NewGreaterExpression(exp string) (*GreaterExpression, error) {
data := regexp.MustCompile(\s+).Split(strings.TrimSpace(exp), -1)
if len(data) != 3 || data[1] != ">" {
return nil, fmt.Errorf("exp is invalid: %s", exp)
}
val, err := strconv.ParseFloat(data[2], 10)
if err != nil {
return nil, fmt.Errorf("exp is invalid: %s", exp)
}
return &GreaterExpression{
key: data[0],
value: val,
}, nil
}
// LessExpression <
type LessExpression struct {
key string
value float64
}
// Interpret Interpret
func (g LessExpression) Interpret(stats map[string]float64) bool {
v, ok := stats[g.key]
if !ok {
return false
}
return v < g.value
}
// NewLessExpression NewLessExpression
func NewLessExpression(exp string) (*LessExpression, error) {
data := regexp.MustCompile(\s+).Split(strings.TrimSpace(exp), -1)
if len(data) != 3 || data[1] != "<" {
return nil, fmt.Errorf("exp is invalid: %s", exp)
}
val, err := strconv.ParseFloat(data[2], 10)
if err != nil {
return nil, fmt.Errorf("exp is invalid: %s", exp)
}
return &LessExpression{
key: data[0],
value: val,
}, nil
}
// AndExpression &&
type AndExpression struct {
expressions []IExpression
}
// Interpret Interpret
func (e AndExpression) Interpret(stats map[string]float64) bool {
for _, expression := range e.expressions {
if !expression.Interpret(stats) {
return false
}
}
return true
}
// NewAndExpression NewAndExpression
func NewAndExpression(exp string) (*AndExpression, error) {
exps := strings.Split(exp, "&&")
expressions := make([]IExpression, len(exps))
for i, e := range exps {
var expression IExpression
var err error
switch {
case strings.Contains(e, ">"):
expression, err = NewGreaterExpression(e)
case strings.Contains(e, "<"):
expression, err = NewLessExpression(e)
default:
err = fmt.Errorf("exp is invalid: %s", exp)
}
if err != nil {
return nil, err
}
expressions[i] = expression
}
return &AndExpression{
expressions: expressions}, nil
}
测试
package interpreter
import (
"testing"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
)
func TestAlertRule_Interpret(t *testing.T) {
stats := map[string]float64{
"a": 1,
"b": 2,
"c": 3,
}
tests := []struct {
name string
stats map[string]float64
rule string
want bool
}{
{
name: "case1",
stats: stats,
rule: "a > 1 && b > 10 && c < 5",
want: false,
},
{
name: "case2",
stats: stats,
rule: "a < 2 && b > 10 && c < 5",
want: false,
},
{
name: "case3",
stats: stats,
rule: "a < 5 && b > 1 && c < 10",
want: false,
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
r, err := NewAlertRule(tt.rule)
require.NoError(t, err)
assert.Equal(t, tt.want, r.Interpret(tt.stats))
})
}
}
总结
解释器模式主要是分而治之，将翻译功能分开管理，方便维护。翻译器模式理解难度和使用难度不大，主要是使用场景比较受限。
版权声明：本文不是「本站」原创文章，版权归原作者所有 | 原文地址: