Exemple de mode d'interprétation du mode de comportement

Passez en revue le modèle de conception aujourd'hui et voyez le modèle d'interprétation. En pensant à un problème que j'ai rencontré auparavant.

问题：前后端多条件的解析。
例：某字符串token开始于“a” 且包含“b” 或长度等于10

Auparavant, il était résolu grâce à des composants tripartites. Si vous souhaitez implémenter vous-même une solution extensible et facile à interagir. Je n'avais pas pensé à un bon moyen avant.

En fait, il peut être résolu en encapsulant deux couches en mode interpréteur.

Mais mon exemple d'interprétation utilise un autre exemple plus simple comme exemple. Ce qui précède n'est qu'une pensée.

问题：波兰表示法。运算符末尾添加操作数的方式
例：1 2 + 代表1+2的运算。 3 4 + 5 - 6 + 代表3+4-5+6的运算

L'interprète se compose généralement de plusieurs parties.

1. Contexte (environnement): encapsule les informations globales de l'interprète, tous les interprètes spécifiques doivent accéder au contexte.

2. AbstractExpression: une classe ou une interface abstraite. La méthode d'interprétation de l'exécution de l'instruction est implémentée par tous les interpréteurs spécifiques.

3. TerminalExpression (expression terminale). Une classe d'interpréteur qui implémente des opérations liées aux terminateurs de grammaire. L'expression terminale doit être implémentée ou instanciée, car elle signifie la fin de l'expression

4. NonTerminalExpression (expression non terminale): une classe qui implémente différentes règles ou symboles de grammaire. Chaque grammaire doit créer une classe.

Exemple de code d'implémentation:

1. Interface d'expression:

/**
 * 表达式接口
 */
public interface Expression {

    public float interpret();
}

2. Expression de terminateur. (Dans cet exemple, une valeur numérique)

/**
 * 数值表达式
 */
public class NumberExpression implements Expression{


    private float number;

    public NumberExpression(float number){
        this.number = number;
    }

    @Override
    public float interpret() {
        return number;
    }
}

3. Expressions de symboles non terminaux. Dans cet exemple, les deux règles d'addition et de soustraction sont prises comme exemples

/**
 * 操作符解释器:加法
 */
public class PlusExpression implements Expression{


    Expression left;
    Expression right;
    public PlusExpression(Expression left, Expression right){

        this.left = left;
        this.right = right;
    }
    @Override
    public float interpret() {
        return this.left.interpret() + this.right.interpret();
    }
}

/**
 * 操作符解释器：减法
 */
public class MinusExpression implements Expression{


    Expression left;
    Expression right;
    public MinusExpression(Expression left, Expression right){

        this.left = left;
        this.right = right;
    }
    @Override
    public float interpret() {
        return this.left.interpret() - this.right.interpret();
    }
}

4. Écrivez un morceau de code pour implémenter l'arbre de syntaxe en créant une bonne classe.

/**
 * 通过解释器类实现语法树
 */
public class Evaluator {

    public float evaluator(String expression){

        Stack<Expression> stack = new Stack<>();
        float result = 0;
        for (String token : expression.split(" ")){

            if(isOperator(token)){
                Expression exp = null;
                if(token.equals("+")){
                   exp = stack.push(new PlusExpression(stack.pop(), stack.pop()));
                }else if(token.equals("-")){
                   exp = stack.push(new MinusExpression(stack.pop(),stack.pop()));
                }

                if(exp != null){
                    result = exp.interpret();
                    stack.push(new NumberExpression(result));
                }
            }

            if(isNumber(token)){
                stack.push(new NumberExpression(Float.parseFloat(token)));
            }
        }
        return result;
    }

    private boolean isOperator(String token){
        if(token.equals("+") || token.equals("-"))
            return true;
        return false;
    }

    private boolean isNumber(String token){
        try {
            float v = Float.parseFloat(token);
            return true;
        }catch (Exception e){
            return false;
        }
    }

    public static void main(String[] args) {

        Evaluator evaluator = new Evaluator();
        System.out.println(evaluator.evaluator("2 3 +"));
        System.out.println(evaluator.evaluator("2 3 + 5 - 6 +"));
    }
}

Un code de mode interpréteur simple est complet.