Une analyse approfondie du modèle d'interpréteur des modèles de conception PHP

Cet article est une analyse détaillée et une introduction au Mode Interpréteur en PHPDesign Pattern Les amis qui en ont besoin peuvent se référer au modèle

Interpreter ), qui consiste en une représentation d'une grammaire avec une hiérarchie de classes composites. Les règles sont mappées aux classes. Les expressions qui suivent la grammaire peuvent être converties en un arbre syntaxique abstrait, à l'exception des instances du modèle composite. rien d'autre que le graphe d'objets.

Arbre est un nom abstrait, car en fait la plupart du temps c'est une représentation abstraite d'une expression, qui ignore qu'il peut y avoir une chaîne ou une structure de données Expressions concrètes, ( par exemple, en PHP, "A" et "x41" sont des représentations concrètes différentes de la même valeur littérale abstraite), découplez les résultats grâce à des règles logiques, simplifiant considérablement le processus d'interprétation.

L'interprète n'est pas un modèle très courant, mais pour les grammaires simples, il est aussi simple d'ajouter une règle que d'ajouter une classe, mais cela ne résout pas la conversion d'une représentation concrète en un arbre syntaxique abstrait, qui est terminé par autres services.

Le modèle d'interpréteur est conçu pour exploiter une structure hiérarchique composite pour une méthode AbstractExpression simple (opération d'interprétation). Les paramètres de l'opération d'interprétation sont généralement appelés collectivement le contexte. elles sont souvent remplacées par des valeurs calculées, ou peuvent ne pas exister pour certaines opérations.

De même, lorsqu'un interprète est inclus, les participants feuille et conteneur du modèle composite portent des noms différents, reflétant le rôle qu'ils jouent : expression terminale ou non terminale (non terminale).

Participant :
◆Client : Utilisez l'opération d'explication.
◆Expression abstraite : Résumé basé sur un arbre d'expression.
◆NonTerminalExpression : une expression qui contient récursivement d'autres expressions abstraites (instances AbstractExpression).
◆Expression terminale : une expression qui ne peut pas être davantage simplifiée.


Le livre "Design Patterns" fournit un exemple étendu de ce modèle. Je l'ai remodelé en remplaçant l'expression booléenne par une expression mathématique, donc cet exemple résout une expression mathématique, son. estimate() est séparé en une classe ConcreteExpression différente.

Le code est le suivant :

/**  
 * AbstractExpression. All implementations of this interface  
 * are ConcreteExpressions.  
 */ 
interface MathExpression  
{  
    /**  
     * Calculates the value assumed by the expression.  
     * Note that $values is passed to all expression but it  
     * is used by Variable only. This is required to abstract  
     * away the tree structure.  
     */ 
    public function evaluate(array $values);  
}  

/**  
 * A terminal expression which is a literal value.  
 */ 
class Literal implements MathExpression  
{  
    private $_value;  

    public function construct($value)  
    {  
        $this->_value = $value;  
    }  

    public function evaluate(array $values)  
    {  
        return $this->_value;  
    }  
}  

/**  
 * A terminal expression which represents a variable.  
 */ 
class Variable implements MathExpression  
{  
    private $_letter;  

    public function construct($letter)  
    {  
        $this->_letter = $letter;  
    }  

    public function evaluate(array $values)  
    {  
        return $values[$this->_letter];  
    }  
}  

/**  
 * Nonterminal expression.  
 */ 
class Sum implements MathExpression  
{  
    private $_a;  
    private $_b;  

    public function construct(MathExpression $a, MathExpression $b)  
    {  
        $this->_a = $a;  
        $this->_b = $b;  
    }  

    public function evaluate(array $values)  
    {  
        return $this->_a->evaluate($values) + $this->_b->evaluate($values);  
    }  
}  

/**  
 * Nonterminal expression.  
 */ 
class Product implements MathExpression  
{  
    private $_a;  
    private $_b;  

    public function construct(MathExpression $a, MathExpression $b)  
    {  
        $this->_a = $a;  
        $this->_b = $b;  
    }  

    public function evaluate(array $values)  
    {  
        return $this->_a->evaluate($values) * $this->_b->evaluate($values);  
    }  
}  

// 10(a + 3)  
$expression = new Product(new Literal(10), new Sum(new Variable('a'), new Literal(3)));  
echo $expression->evaluate(array('a' => 4)), "\n";  
// adding new rules to the grammar is easy:  
// e.g. Power, Subtraction...  
// thanks to the Composite, manipulation is even simpler:  
// we could add substitute($letter, MathExpression $expr)  
// to the interface...

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!