Explication détaillée de l'utilisation du mode interpréteur PHP

L'éditeur ci-dessous vous présentera un cliché sur le mode interpréteur orienté objet de PHP. L'éditeur le trouve plutôt bon, je vais donc le partager avec vous maintenant et le donner comme référence pour tout le monde. Venez jeter un oeil avec l'éditeur.

Récemment, je lisais "Modèle et pratique approfondis de 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 saisis :

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

dans la zone de saisie de la page Web frontale et que je soumets ensuite, le système répondra avec un résultat similaire à " La condition est vraie" ou "La condition n'est pas vraie" (un peu similaire à l'écriture de code directement au premier plan et à son exécution, 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 saisie frontale. à 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 les deux lignes ci-dessus (le processus des mots-clés dans le code)

Bien que les deux lignes de code ci-dessus soient un langage inventé 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 porte un jugement (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 conteneur est principalement utilisée 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 est enregistré 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 (il n'y a pas d'héritage ou de combinaison avec d'autres classes) ou de relation d'agrégation).

2. Expression Il s'agit d'une classe abstraite d'expression, qui définit la méthode abstraite perform() 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 décrites ci-dessous hériteront toutes de cette classe, et elle a une relation combinée avec OperatorExpression (classe abstraite d'expression d'opérateur). C'est-à-dire que 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. Je ne sais pas ce que je dis. C'est vrai, 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 sauvegarder une chaîne dans le petit conteneur d'InterpreterContext, enregistrez-le en tant que tableau d'index, par exemple, enregistrez 4 ou quatre dans les deux premières phrases du code auto-créé

. >

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. La clé dans le tableau associatif est le nom de la variable et la valeur. est la valeur de la variable. , par exemple, la variable "input" et la valeur "4" dans les deux premières phrases,

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);
  }
}

le code est le suivant :

5. Classe de base abstraite d'expression d'opérateur OperatorExpression Cette classe hérite et combine la classe de base abstraite Expression. de l'expression

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;
  }
}

Le code est le suivant :

6. , BooleanAndExpression, respectivement, sont des expressions d'égalité qui héritent de la classe de base abstraite OperatorExpression, ou expression, et il n'existe qu'une seule méthode, doInterpret() appelle en interne la méthode replace() de la classe InterpreterContext pour enregistrer le résultat du calcul de l'expression dans une instance. de la classe InterpreterContext

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);

}

Code Comme suit :

Ceci termine l'introduction des classes liées à ce mode. Les codes ci-dessus ont été testés. Vous pouvez directement copier-coller et exécuter pour voir les résultats. Jetons maintenant un coup d'œil au code client :

Code client un :

//相等表达式
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 deux

 :

$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 trois :

$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 '条件不成立';
}

La différence entre ceci est l'exemple de code client original et le code client ci-dessus est l'utilisation de l'expression variable VariableExpression

$context = new InterpreterContext();　　　　
$input = new VariableExpression('input');　　//这里定义了一个变量input 但并未赋值

$statement = new BooleanOrExpression(
new EqualsExpression($input,new LiteralExpression('four')),　　//这里变量表达式和文字表达式的值将进行一个是否相等的比较
new EqualsExpression($input,new LiteralExpression('4'))
);

foreach (array("four","4","52") as $val){
$input->setValue($val);　　　　　　　　//对input这个变量赋值
print "变量input的值为：$val:<br/>";
$statement->interpret($context);　　//进行比较并将比较结果存入InterpreterContext对象实例
if($context->lookup($statement)){　　//获取比较的结果
print "条件成立 <br/>";
} else {
print "条件不成立 <br/>";
}
}

上述代码经过测试都可以正常运行，有需要的朋友可以复制下来，运行一下看看结果。

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!