罗湖网站建设设计,精仿36氪(36kr)wordpress主题,网站搜索要怎么做,wordpress学人的冬天Go和Java实现解释器模式
下面通过一个四则运算来说明解释器模式的使用。
1、解释器模式
解释器模式提供了评估语言的语法或表达式的方式#xff0c;它属于行为型模式。这种模式实现了一个表达式接口#xff0c;该接口
解释一个特定的上下文。这种模式被用在 SQL 解析、符…Go和Java实现解释器模式
下面通过一个四则运算来说明解释器模式的使用。
1、解释器模式
解释器模式提供了评估语言的语法或表达式的方式它属于行为型模式。这种模式实现了一个表达式接口该接口
解释一个特定的上下文。这种模式被用在 SQL 解析、符号处理引擎等。 意图给定一个语言定义它的文法表示并定义一个解释器这个解释器使用该标识来解释语言中的句子。 主要解决对于一些固定文法构建一个解释句子的解释器。 何时使用如果一种特定类型的问题发生的频率足够高那么可能就值得将该问题的各个实例表述为一个简单 语言中的句子。这样就可以构建一个解释器该解释器通过解释这些句子来解决该问题。 如何解决构建语法树定义终结符与非终结符。 关键代码构建环境类包含解释器之外的一些全局信息一般是 HashMap。 应用实例编译器、运算表达式计算。 优点1、可扩展性比较好灵活。 2、增加了新的解释表达式的方式。 3、易于实现简单文法。 缺点1、可利用场景比较少。 2、对于复杂的文法比较难维护。 3、解释器模式会引起类膨胀。 4、解释器模 式采用递归调用方法。 使用场景1、可以将一个需要解释执行的语言中的句子表示为一个抽象语法树。 2、一些重复出现的问题可 以用一种简单的语言来进行表达。 3、一个简单语法需要解释的场景。 注意事项可利用场景比较少JAVA 中如果碰到可以用 expression4J 代替。 适用性 当有一个语言需要解释执行并且你可将该语言中的句子表示为一个抽象语法树时可使用解释器模式而当 存在当下情况时该模式效果最好 该文法简单对于复杂的文法文法的层次变得庞大而无法管理。 效率不是一个关键问题最高效的解释器通常不是通过直接解释语法分析树实现的而是首先将它们转换成另 一种形式。
2、Go实现解释器模式
package interpreter// ArithmeticInterpreter
type ArithmeticInterpreter interface {Interpret() int
}package interpreter// NumInterpreter
type NumInterpreter struct {Value int
}func NewNumInterpreter(value int) *NumInterpreter {return NumInterpreter{Value: value}
}func (numInterpreter *NumInterpreter) Interpret() int {return numInterpreter.Value
}package interpreter// AddInterpreter
type AddInterpreter struct {left ArithmeticInterpreterright ArithmeticInterpreter
}func NewAddInterpreter(left, right ArithmeticInterpreter) *AddInterpreter {return AddInterpreter{left: left, right: right}
}func (addInterpreter *AddInterpreter) Interpret() int {return addInterpreter.left.Interpret() addInterpreter.right.Interpret()
}package interpreter// SubInterpreter
type SubInterpreter struct {left ArithmeticInterpreterright ArithmeticInterpreter
}func NewSubInterpreter(left, right ArithmeticInterpreter) *SubInterpreter {return SubInterpreter{left: left, right: right}
}func (subInterpreter *SubInterpreter) Interpret() int {return subInterpreter.left.Interpret() - subInterpreter.right.Interpret()
}package interpreter// MultiInterpreter
type MultiInterpreter struct {left ArithmeticInterpreterright ArithmeticInterpreter
}func NewMultiInterpreter(left, right ArithmeticInterpreter) *MultiInterpreter {return MultiInterpreter{left: left, right: right}
}func (multiInterpreter *MultiInterpreter) Interpret() int {return multiInterpreter.left.Interpret() * multiInterpreter.right.Interpret()
}package interpreter// DivInterpreter
type DivInterpreter struct {left ArithmeticInterpreterright ArithmeticInterpreter
}func NewDivInterpreter(left, right ArithmeticInterpreter) *DivInterpreter {return DivInterpreter{left: left, right: right}
}func (divInterpreter *DivInterpreter) Interpret() int {return divInterpreter.left.Interpret() / divInterpreter.right.Interpret()
}package interpreterconst (ADD SUB -MUL *DIV /
)// OperatorUtil
type OperatorUtil struct{}func (OperatorUtil *OperatorUtil) IsOperator(symbol string) bool {return ( symbol || - symbol || * symbol)
}func (operatorUtil *OperatorUtil) GetInterpreter(left, right ArithmeticInterpreter, symbol string) ArithmeticInterpreter {if ADD symbol {return NewAddInterpreter(left, right)} else if SUB symbol {return NewSubInterpreter(left, right)} else if MUL symbol {return NewMultiInterpreter(left, right)} else if DIV symbol {return NewDivInterpreter(left, right)}return nil
}package interpreterimport (fmtstrconvstrings
)type Calculator struct{}var (operatorUtil OperatorUtil{}stack make([]ArithmeticInterpreter, 0)
)func (calculator *Calculator) Parse(expression string) {elements : strings.Split(expression, )var leftExpr, rightExpr ArithmeticInterpreterfor i : 0; i len(elements); i {operator : elements[i]if operatorUtil.IsOperator(operator) {// 出栈leftExpr stack[len(stack)-1]stack stack[:len(stack)-1]iele, _ : strconv.Atoi(elements[i])rightExpr NewNumInterpreter(ele)fmt.Printf(出栈: %d 和 %d \n, leftExpr.Interpret(), rightExpr.Interpret())stack append(stack, operatorUtil.GetInterpreter(leftExpr, rightExpr, operator))fmt.Println(应用运算符: operator)} else {ele, _ : strconv.Atoi(elements[i])numInterpreter : NewNumInterpreter(ele)stack append(stack, numInterpreter)fmt.Printf(入栈: %d \n, numInterpreter.Interpret())}}}func (calculator *Calculator) Result() int {value : stack[len(stack)-1]stack stack[:len(stack)-1]return value.Interpret()
}package mainimport (fmt. proj/interpreter
)func main() {calculator : Calculator{}calculator.Parse(10 30)fmt.Println(result:, calculator.Result())calculator.Parse(10 30 - 20)fmt.Println(result: , calculator.Result())calculator.Parse(100 * 2 400 - 20 66)fmt.Println(result:, calculator.Result())
}# 程序输出
入栈: 10
出栈: 10 和 30
应用运算符:
result: 40
入栈: 10
出栈: 10 和 30
应用运算符:
出栈: 40 和 20
应用运算符: -
result: 20
入栈: 100
出栈: 100 和 2
应用运算符: *
出栈: 200 和 400
应用运算符:
出栈: 600 和 20
应用运算符: -
出栈: 580 和 66
应用运算符:
result: 40
入栈: 10
出栈: 10 和 30
应用运算符:
出栈: 40 和 20
应用运算符: -
result: 20
入栈: 100
出栈: 100 和 2
应用运算符: *
出栈: 200 和 400
应用运算符:
出栈: 600 和 20
应用运算符: -
出栈: 580 和 66
应用运算符:
result: 6463、Java实现解释器模式
package com.interpreter;// ArithmeticInterpreter
public interface ArithmeticInterpreter {int interpret();
}package com.interpreter;// ArithmeticInterpreter
public abstract class Interpreter implements ArithmeticInterpreter{protected ArithmeticInterpreter left;protected ArithmeticInterpreter right;public Interpreter(ArithmeticInterpreter left, ArithmeticInterpreter right) {this.left left;this.right right;}
}package com.interpreter;// NumInterpreter
public class NumInterpreter implements ArithmeticInterpreter {private int value;public NumInterpreter(int value) {this.value value;}Overridepublic int interpret() {return this.value;}}package com.interpreter;// AddInterpreter
public class AddInterpreter extends Interpreter {public AddInterpreter() {super(left, right);}Overridepublic int interpret() {return this.left.interpret() this.right.interpret();}
}package com.interpreter;// MultiInterpreter
public class MultiInterpreter extends Interpreter {public MultiInterpreter(ArithmeticInterpreter left, ArithmeticInterpreter right) {super(left, right);}Overridepublic int interpret() {return this.left.interpret() * this.right.interpret();}
}package com.interpreter;// SubInterpreter
public class SubInterpreter extends Interpreter {public SubInterpreter(ArithmeticInterpreter left, ArithmeticInterpreter right) {super(left, right);}Overridepublic int interpret() {return this.left.interpret() - this.right.interpret();}
}package com.interpreter;// DivInterpreter
public class DivInterpreter extends Interpreter {public DivInterpreter(ArithmeticInterpreter left, ArithmeticInterpreter right) {super(left, right);}Overridepublic int interpret() {return this.left.interpret() / this.right.interpret();}
}package com.interpreter;// OperatorUtil
public class OperatorUtil {private final static String ADD ;private final static String SUB -;private final static String MUL *;private final static String DIV /;public static boolean isOperator(String symbol) {return (.equals(symbol) || -.equals(symbol) || *.equals(symbol));}public static Interpreter getInterpreter(ArithmeticInterpreter left, ArithmeticInterpreter right, String symbol) {if (ADD.equals(symbol)) {return new AddInterpreter(left, right);} else if (SUB.equals(symbol)) {return new SubInterpreter(left, right);} else if (MUL.equals(symbol)) {return new MultiInterpreter(left, right);} else if (DIV.equals(symbol)) {return new DivInterpreter(left, right);}return null;}
}package com.interpreter;import java.util.Stack;// Calculator
public class Calculator {private final StackArithmeticInterpreter stack new Stack();public void parse(String expression) {String[] elements expression.split( );ArithmeticInterpreter leftExpr, rightExpr;for (int i 0; i elements.length; i) {String operator elements[i];if (OperatorUtil.isOperator(operator)) {leftExpr this.stack.pop();rightExpr new NumInterpreter(Integer.parseInt(elements[i]));System.out.println(出栈: leftExpr.interpret() 和 rightExpr.interpret());this.stack.push(OperatorUtil.getInterpreter(leftExpr, rightExpr, operator));System.out.println(应用运算符: operator);} else {NumInterpreter numInterpreter new NumInterpreter(Integer.parseInt(elements[i]));this.stack.push(numInterpreter);System.out.println(入栈: numInterpreter.interpret());}}}public int result() {return this.stack.pop().interpret();}}package com.interpreter;public class Test {public static void main(String[] args) {Calculator calculator new Calculator();calculator.parse(10 30);System.out.println(result: calculator.result());calculator.parse(10 30 - 20);System.out.println(result: calculator.result());calculator.parse(100 * 2 400 - 20 66);System.out.println(result: calculator.result());}
}# 程序输出
入栈: 10
出栈: 10 和 30
应用运算符:
result: 40
入栈: 10
出栈: 10 和 30
应用运算符:
出栈: 40 和 20
应用运算符: -
result: 20
入栈: 100
出栈: 100 和 2
应用运算符: *
出栈: 200 和 400
应用运算符:
出栈: 600 和 20
应用运算符: -
出栈: 580 和 66
应用运算符:
result: 646
