Golang - Design Pattern #21: 解譯器模式 (Interpreter)

🌐 解譯器模式：處理語言解釋 🌐

當我們需要給某個系統或應用程序添加一種新的語言或表達式時，解譯器模式就派上了用場。這種模式提供了一種將句子或表達式分解成多個令牌的方法，然後根據這些令牌進行解釋或解析。

解譯器模式 🔍

在解譯器模式中，我們會使用一個解譯器接口和多個具體的解譯器。這些具體的解譯器通常對應於語言的語法。例如，對於數學表達式，我們可能有一個解譯器專門用於處理加法，另一個用於處理減法等。

Go ~

➕ 簡單的數學解譯器

假設我們要實現一個能夠解析和計算簡單數學表達式的解譯器，例如 "3 + 5" 或 "6 - 2"。

package main

import "fmt"

// Expression Interface
type Expression interface {
	Interpret() int
}

// PlusExpression
type PlusExpression struct {
	leftOperand  Expression
	rightOperand Expression
}

func (e *PlusExpression) Interpret() int {
	return e.leftOperand.Interpret() + e.rightOperand.Interpret()
}

// MinusExpression
type MinusExpression struct {
	leftOperand  Expression
	rightOperand Expression
}

func (e *MinusExpression) Interpret() int {
	return e.leftOperand.Interpret() - e.rightOperand.Interpret()
}

// Number
type Number struct {
	value int
}

func (n *Number) Interpret() int {
	return n.value
}

func main() {
	// Client code
	expr := &PlusExpression{
		leftOperand:  &Number{value: 3},
		rightOperand: &Number{value: 5},
	}
	fmt.Println(expr.Interpret()) // Outputs: 8

}

🚫 簡單的布爾解譯器

假設我們還要解析布爾表達式，例如 "True AND False" 或 "True OR False"。

package main

import "fmt"

// BoolExpression Interface
type BoolExpression interface {
	InterpretBool() bool
}

// AndExpression
type AndExpression struct {
	left  BoolExpression
	right BoolExpression
}

func (e *AndExpression) InterpretBool() bool {
	return e.left.InterpretBool() && e.right.InterpretBool()
}

// OrExpression
type OrExpression struct {
	left  BoolExpression
	right BoolExpression
}

func (e *OrExpression) InterpretBool() bool {
	return e.left.InterpretBool() || e.right.InterpretBool()
}

// BoolValue
type BoolValue struct {
	value bool
}

func (b *BoolValue) InterpretBool() bool {
	return b.value
}

func main() {
	// Client code
	exprBool := &AndExpression{
		left:  &BoolValue{value: true},
		right: &BoolValue{value: false},
	}
	fmt.Println(exprBool.InterpretBool()) // Outputs: false
}

小結 🎓

解譯器模式為那些需要對特定語言或表達式進行解析的系統提供了一個統一的解決方案。這種模式的靈活性使我們可以輕鬆地添加更多的語法和規則，從而擴展我們的語言或解譯器的功能。