Explication détaillée du mode interpréteur orienté objet PHP

L'éditeur ci-dessous vous présentera un cliché sur le mode interpréteur orienté objet de PHP. L'éditeur pense que c'est plutôt bien, alors je vais le partager avec vous maintenant et le donner comme référence. Venez jeter un oeil avec l'éditeur.

Récemment, je lisais "Modèle et pratique approfondis PHP orientés objet". Après avoir étudié le contenu du livre, j'ai immédiatement senti que j'étais un peu avancé, Ha! En fait, c'est toujours une mauvaise idée. Je pense qu'il y aura des amis novices qui liront ce livre (je suis également novice). J'aimerais partager et échanger mon expérience d'apprentissage sur le contenu du livre que je trouve personnellement difficile 1. J'espère que cela pourra consolider les connaissances. J'ai appris et le rôle de l'approfondissement de la compréhension 2. J'espère que cela sera utile aux amis novices qui lisent cet article et sont intéressés.

J'ai lu cette partie plusieurs fois et tapé le code plusieurs fois. On estime que la fonction que cet article souhaite réaliser est que l'utilisateur saisit du contenu sur la page Web, puis l'analyse via le. programme en arrière-plan pour répondre (on dirait que c'est un non-sens). Par exemple, si je tape dans la zone de saisie de la page Web frontale :

$input = "4";
$input equals "4" or $input equals "four";

et que je soumets ensuite, le système répondra quelque chose comme " La condition est vraie" ou "La condition n'est pas vraie" Résultat (un peu similaire à l'écriture de code directement au premier plan et à son exécution, et un résultat sera renvoyé après l'analyse en arrière-plan. Bien que le livre original n'explique pas l'ensemble du processus de front-end entrée dans l'analyse en arrière-plan, je suppose que cette analyse en arrière-plan devrait également utiliser des expressions régulières pour extraire quelque chose de similaire. Le processus de mots-clés dans les deux lignes de code ci-dessus)

Bien que les deux lignes de code ci-dessus soient des langages inventés par l'auteur, ce n'est pas difficile à comprendre sur la base du sens littéral. La première ligne définit une variable et attribue une valeur, et la deuxième ligne Il s'agit de porter un jugement sur la variable (la variable est égale à 4 ou égale à quatre). ).

Sans plus tarder, jetons un coup d'œil aux classes définies par ce modèle (veuillez lire vous-même le texte original des diagrammes de classes) :

1.interpreterContext This la classe est comme un Le conteneur est principalement utilisé pour stocker et obtenir les valeurs et les résultats de comparaison qui doivent être comparés, par exemple 4, quatre et le résultat de la comparaison « vrai » ou « faux ». dans le code ci-dessus sont enregistrés sous la forme d'un tableau, c'est-à-dire l'attribut $expressionstore de la classe, le code est le suivant :

class InterpreterContext{
  private $expressionstore = array(); //存放比较的值和结果
  
  function replace(Expression $exp,$value){　　　　// 设置值
    $this->expressionstore[$exp->getKey()] = $value;
  }
  
  function lookup(Expression $exp){　　　　　　　　//获取值
    return $this->expressionstore[$exp->getKey()];
  }
}

Cette classe est comme un outil que d'autres classes peuvent utiliser (elle n'existe pas avec d'autres classes de relations d'héritage, de composition ou d'agrégation).

2. Expression Il s'agit d'une classe abstraite d'expression, qui définit la méthode abstraite interprétative() et la méthode getKey()

Le le code est le suivant :

abstract class Expression {
  private static $keycount = 0;　　//计数用的
  private $key;　　　　　　　　　　//存放一个唯一值


  //主要实现将前台获取到的数据存放到上述InterpreterContext类中的功能，看到下面的内容就会发现继承他的类调用了InterpreterContext类的replace()方法
  abstract function interpret (InterpreterContext $context);　

　//获取一个唯一值  
  function getKey(){　　　　　　　
    if(!isset($this->key)){
      self::$keycount++;
      $this->key= self::$keycount;
    }
    return $this->key;
  }
}

Les classes mentionnées ci-dessous hériteront de cette classe, et c'est une combinaison avec OperatorExpression (classe abstraite d'expression d'opérateur) relation, c'est-à-dire qu'OperatorExpression peut inclure toutes les sous-classes qui héritent de l'expression lors de l'initialisation (c'est aussi ce que ce livre a mis l'accent sur la programmation orientée interface. Cette expression est une interface. Le polymorphisme peut être obtenu en utilisant cette interface. Vous ne le faites pas. Je ne sais pas comment l'installer vous-même. Est-ce que B a raison ? Ha ! Vous pouvez consulter le diagramme de classe dans le livre original pour plus de détails)

3. LiteralExpression Classe d'expression littérale, sa fonction est de enregistrez une chaîne dans InterpreterContext Dans le conteneur, enregistrez-la en tant que tableau d'index, par exemple, enregistrez 4 ou quatre dans les deux codes auto-créés au début

Le code est. comme suit :

class LiteralExpression extends Expression{
  private $value;  
  function __construct ($value){　　　　　　//初始化时传入要保存的值
    $this->value= $value;
  }
  function interpret(InterpreterContext $context){　　　　//调用InterpreterContext类的replace(）将$value保存到InterpreterContext这个小容器里
    $context->replace($this,$this->value);
  }
}

4. Classe d'expression de variable VariableExpression, qui a la même fonction que la classe ci-dessus, sauf que les données seront enregistrées sous forme de tableau associatif. le tableau associatif est le nom de la variable. La valeur est la valeur de la variable Par exemple, la variable "input" et la valeur "4" dans les deux premières phrases,

Le. le code est le suivant :

class VariableExpression extends Expression{
  private $name;　　　　//变量名
  private $val;　　　　　　//变量值
  
  function __construct ($name,$val=null){
    $this->name = $name;
    $this->val = $val;
  }
  
  function interpret(InterpreterContext $context){
    if(!is_null($this->val)){
      $context->replace($this,$this->val);
      $this->val = null;
    }
  }
  
  function setValue($value){　　//用于设置变量的值
    $this->val = $value;
  }
  
  function getKey(){　　　　//这个复写了父类的getKey()方法，在小容器InterpreterContext的lookup()方法调用这个类的实例的getKey()方法时 它将返回一个字符串(即变量名)而不是数字索引
    return $this->name;
  }
}

5. Classe de base abstraite d'expression d'opérateur OperatorExpression Cette classe hérite et combine la base abstraite d'expression. classe. La méthode perform() implémentée enregistre principalement les résultats de calcul de l'expression

Le code est le suivant :

.

abstract class OperatorExpression extends Expression{
protected $l_op;　　//表达式左边的值
protected $r_op;　　//表达式右边的值

function __construct (Expression $l_op,Expression $r_op){　　　　//初始化时可组合继承了Expression类的子类实例
$this->l_op = $l_op;
$this->r_op = $r_op;
}

function interpret(InterpreterContext $context){  //主要用于保存表达试的结果（保存到InterpreterContext 类的实例中）
$this->l_op->interpret($context);　　　　　　　　//将Expression子类实例的值或计算结果保存到InterpreterContext 类的实例中
$this->r_op->interpret($context);
$result_l = $context->lookup($this->l_op);　　　　//获取上一步的值或计算结果
$result_r = $context->lookup($this->r_op);
$this->doInterpret($context,$result_l,$result_r);　　//具体的比较运算由继承的子类来实现
}

protected abstract function doInterpret(InterpreterContext $context,$result_l,$result_r);

}

6. EqualsExpression, BooleanOrExpression, BooleanAndExpression, Il n'existe qu'une seule méthode pour l'expression d'égalité, ou l'expression, et l'expression qui hérite de la classe de base abstraite OperatorExpression DoInterpret() appelle en interne le replace(. ) méthode de la classe InterpreterContext pour enregistrer le résultat du calcul de l'expression dans une instance de la classe InterpreterContext

Le code est le suivant :

Jusqu'à présent, les classes liées à ce mode ont été introduites. Les codes ci-dessus ont tous été testés. Vous pouvez directement copier-coller et exécuter pour voir les résultats. jetez un oeil au code client :

//相等表达式
class EqualsExpression extends OperatorExpression {
protected function doInterpret(InterpreterContext $context,$result_l,$result_r){
$context->replace($this,$result_l == $result_r);
}
}

//或表达式
class BooleanOrExpression extends OperatorExpression{
protected function doInterpret(InterpreterContext $context,$result_l,$result_r){
$context->replace($this,$result_l || $result_r);
}
}


//与表达式
class BooleanAndExpression extends OperatorExpression{
protected function doInterpret(InterpreterContext $context,$result_l,$result_r){
$context->replace($this,$result_l && $result_r);
}
}

Code client un :

$context = new InterpreterContext();

$statement = new BooleanOrExpression (　　//可尝试将此操作符表达式换成BooleanAndExpression 运行一下 看看执行结果

//可尝试将LiteralExpression中实例化的参数改成其他值看看运算结果，或者直接将EqualsExpression对象换成BooleanOrExpression 或BooleanAndExpression 
new EqualsExpression(new LiteralExpression('four'),new LiteralExpression('four')),　

new EqualsExpression(new LiteralExpression('b'),new LiteralExpression('4'))
);

$statement->interpret($context);
if($context->lookup($statement)){
echo '条件成立';
} else {
echo '条件不成立';
}

Code client deux

 :

$context = new InterpreterContext();

$statement = new BooleanOrExpression(
new BooleanAndExpression(
new EqualsExpression(new LiteralExpression('4'),new LiteralExpression('4')),
new EqualsExpression(new LiteralExpression('4'),new LiteralExpression('4'))
),
new EqualsExpression(new LiteralExpression('b'),new LiteralExpression('4'))
);

$statement->interpret($context);
if($context->lookup($statement)){
echo '条件成立';
} else {
echo '条件不成立';
}

Code client trois :

La différence entre ceci est l'exemple de code client d'origine et le code client ci-dessus est l'utilisation d'expressions variables Formula VariableExpression

Le code ci-dessus peut s'exécuter normalement après le test. Les amis dans le besoin peuvent le copier et l'exécuter pour voir les résultats.

Recommandations associées :

PHPMode interprèteUtilisation détaillée

Modèle de conception php Analyse approfondie et explication détaillée du modèle d'interprète

Modèle de conception orienté objet PHP avancé : Modèle d'interprèteExemples d'utilisation

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!