go: Interpreter Pattern

项目结构：

Go 复制代码

/*
# 版权所有  2026 ©涂聚文有限公司™ ®
# 许可信息查看：言語成了邀功盡責的功臣，還需要行爲每日來值班嗎
# 描述： Interpreter Pattern 解释器模式
# Author    : geovindu,Geovin Du 涂聚文.
# IDE       : goLang 2024.3.6 go 26.2
# os        : windows 10
# database  : mysql 9.0 sql server 2019, postgreSQL 17.0  Oracle 21c Neo4j
# Datetime  : 2026/4/28 21:00
# User      :  geovindu
# Product   : GoLand
# Project   : godesginpattern
# File      : context.go
*/
package context
 
type JewelryContext map[string]float64
 
// NewJewelryContext 创建珠宝计价上下文
func NewJewelryContext() JewelryContext {
    return make(JewelryContext)
}
 
// Set 设置变量
func (c JewelryContext) Set(key string, value float64) {
    c[key] = value
}
 
// Get 获取变量
func (c JewelryContext) Get(key string) float64 {
    return c[key]
}

Go 复制代码

/*
# 版权所有  2026 ©涂聚文有限公司™ ®
# 许可信息查看：言語成了邀功盡責的功臣，還需要行爲每日來值班嗎
# 描述：Interpreter Pattern 解释器模式
# Author    : geovindu,Geovin Du 涂聚文.
# IDE       : goLang 2024.3.6 go 26.2
# os        : windows 10
# database  : mysql 9.0 sql server 2019, postgreSQL 17.0  Oracle 21c Neo4j
# Datetime  : 2026/4/28 21:01
# User      :  geovindu
# Product   : GoLand
# Project   : godesginpattern
# File      : expression.go
*/
package expression
 
import (
    "godesginpattern/interpreter/context"
)
 
// Expression 顶层表达式接口
// 所有解释器必须实现此接口
type Expression interface {
    Interpret(ctx context.JewelryContext) float64
}
 
// ------------------------------
// 终结符表达式（最小单元）
// ------------------------------
 
// Number 数字常量
type Number struct {
    value float64
}
 
func NewNumber(value float64) *Number {
    return &Number{value: value}
}
 
func (n *Number) Interpret(ctx context.JewelryContext) float64 {
    return n.value
}
 
// Variable 变量（金价、重量、克拉等）
type Variable struct {
    name string
}
 
func NewVariable(name string) *Variable {
    return &Variable{name: name}
}
 
func (v *Variable) Interpret(ctx context.JewelryContext) float64 {
    return ctx.Get(v.name)
}
 
// ------------------------------
// 非终结符表达式（运算）
// ------------------------------
 
// Add 加法
type Add struct {
    left  Expression
    right Expression
}
 
func NewAdd(left, right Expression) *Add {
    return &Add{left: left, right: right}
}
 
func (a *Add) Interpret(ctx context.JewelryContext) float64 {
    return a.left.Interpret(ctx) + a.right.Interpret(ctx)
}
 
// Sub 减法
type Sub struct {
    left  Expression
    right Expression
}
 
func NewSub(left, right Expression) *Sub {
    return &Sub{left: left, right: right}
}
 
func (s *Sub) Interpret(ctx context.JewelryContext) float64 {
    return s.left.Interpret(ctx) - s.right.Interpret(ctx)
}
 
// Mul 乘法
type Mul struct {
    left  Expression
    right Expression
}
 
func NewMul(left, right Expression) *Mul {
    return &Mul{left: left, right: right}
}
 
func (m *Mul) Interpret(ctx context.JewelryContext) float64 {
    return m.left.Interpret(ctx) * m.right.Interpret(ctx)
}

Go 复制代码

/*
# 版权所有  2026 ©涂聚文有限公司™ ®
# 许可信息查看：言語成了邀功盡責的功臣，還需要行爲每日來值班嗎
# 描述：Interpreter Pattern 解释器模式
# Author    : geovindu,Geovin Du 涂聚文.
# IDE       : goLang 2024.3.6 go 26.2
# os        : windows 10
# database  : mysql 9.0 sql server 2019, postgreSQL 17.0  Oracle 21c Neo4j
# Datetime  : 2026/4/28 21:01
# User      :  geovindu
# Product   : GoLand
# Project   : godesginpattern
# File      : parser.go
*/
package parser
 
import (
    "godesginpattern/interpreter/context"
    "godesginpattern/interpreter/expression"
    "strconv"
    "strings"
)
 
type Parser struct {
    root expression.Expression
}
 
func NewParser(rule string) *Parser {
    stack := []expression.Expression{}
    tokens := strings.Fields(rule)
 
    for _, tok := range tokens {
        switch tok {
        case "+":
            // 正确创建：弹出两个表达式，构造Add
            right := stack[len(stack)-1]
            stack = stack[:len(stack)-1]
            left := stack[len(stack)-1]
            stack = stack[:len(stack)-1]
            stack = append(stack, expression.NewAdd(left, right))
 
        case "-":
            right := stack[len(stack)-1]
            stack = stack[:len(stack)-1]
            left := stack[len(stack)-1]
            stack = stack[:len(stack)-1]
            stack = append(stack, expression.NewSub(left, right))
 
        case "*":
            right := stack[len(stack)-1]
            stack = stack[:len(stack)-1]
            left := stack[len(stack)-1]
            stack = stack[:len(stack)-1]
            stack = append(stack, expression.NewMul(left, right))
 
        default:
            // 数字或变量
            if num, err := strconv.ParseFloat(tok, 64); err == nil {
                stack = append(stack, expression.NewNumber(num))
            } else {
                stack = append(stack, expression.NewVariable(tok))
            }
        }
    }
 
    return &Parser{root: stack[0]}
}
 
func (p *Parser) Calculate(ctx context.JewelryContext) float64 {
    return p.root.Interpret(ctx)
}

Go 复制代码

/*
# 版权所有  2026 ©涂聚文有限公司™ ®
# 许可信息查看：言語成了邀功盡責的功臣，還需要行爲每日來值班嗎
# 描述：Interpreter Pattern 解释器模式
# Author    : geovindu,Geovin Du 涂聚文.
# IDE       : goLang 2024.3.6 go 26.2
# os        : windows 10
# database  : mysql 9.0 sql server 2019, postgreSQL 17.0  Oracle 21c Neo4j
# Datetime  : 2026/4/28 21:01
# User      :  geovindu
# Product   : GoLand
# Project   : godesginpattern
# File      : price_service.go
*/
package service
 
import (
    "godesginpattern/interpreter/context"
    "godesginpattern/interpreter/parser"
    "log"
)
 
type JewelryPriceService struct{}
 
func NewJewelryPriceService() *JewelryPriceService {
    return &JewelryPriceService{}
}
 
// 黄金价格 = 金价 × 重量 + 工费
func (j *JewelryPriceService) CalculateGoldPrice() {
    rule := "goldPrice weight * craftFee +"
    ctx := context.NewJewelryContext()
    ctx.Set("goldPrice", 600)
    ctx.Set("weight", 30)
    ctx.Set("craftFee", 500)
 
    price := parser.NewParser(rule).Calculate(ctx)
    log.Printf("黄金手镯：%.2f 元", price)
}
 
// 钻石价格 = 克拉价 × 克拉 + 金托价
func (j *JewelryPriceService) CalculateDiamondPrice() {
    rule := "diamondPrice carat * metalPrice +"
    ctx := context.NewJewelryContext()
    ctx.Set("diamondPrice", 50000)
    ctx.Set("carat", 0.8)
    ctx.Set("metalPrice", 2000)
 
    price := parser.NewParser(rule).Calculate(ctx)
    log.Printf("钻石戒指：%.2f 元", price)
}
 
// 会员折扣价 = (金价 × 重量 + 工费) × 折扣
func (j *JewelryPriceService) CalculateVIPPrice() {
    rule := "goldPrice weight * craftFee + vipDiscount *"
    ctx := context.NewJewelryContext()
    ctx.Set("goldPrice", 600)
    ctx.Set("weight", 30)
    ctx.Set("craftFee", 500)
    ctx.Set("vipDiscount", 0.9)
 
    price := parser.NewParser(rule).Calculate(ctx)
    log.Printf("会员折后价：%.2f 元", price)
}

调用：

Go 复制代码

/*
# 版权所有  2026 ©涂聚文有限公司™ ®
# 许可信息查看：言語成了邀功盡責的功臣，還需要行爲每日來值班嗎
# 描述：Interpreter Pattern 解释器模式
# Author    : geovindu,Geovin Du 涂聚文.
# IDE       : goLang 2024.3.6 go 26.2
# os        : windows 10
# database  : mysql 9.0 sql server 2019, postgreSQL 17.0  Oracle 21c Neo4j
# Datetime  : 2026/4/28 21:08
# User      :  geovindu
# Product   : GoLand
# Project   : godesginpattern
# File      : interpreter bll.go
 
Interpreter /
├── cmd/
│   └── main.go
├── internal/  # 内部业务包（外部不可引用）
│   ├── context/   # 上下文环境（变量容器）
│   │   └── context.go
│   ├── expression/ # 解释器表达式核心（终结符+非终结符）
│   │   └── expr.go
│   ├── parser/ # 语法解析器
│   │   └── parser.go
│   └── service/   # 业务服务层
│       └── price_service.go
└── go.mod
 
*/
 
package bll
 
import (
    "godesginpattern/interpreter/service"
    "log"
)
 
func InterpreterMain() {
    log.Println("=== 珠宝计价系统（企业级解释器模式）===")
 
    srv := service.NewJewelryPriceService()
    srv.CalculateGoldPrice()
    srv.CalculateDiamondPrice()
    srv.CalculateVIPPrice()
}

输出：