Explication détaillée des objets d'instanciation dynamique dans le framework PHP

Dans le développement de framework, le développement modulaire, etc., nous pouvons avoir besoin d'instancier dynamiquement des objets pendant que PHP est en cours d'exécution.

Qu'est-ce qu'un objet d'instanciation dynamique ? Jetons d'abord un coup d'œil au concept de fonction variable (Fonction variable) en PHP. Par exemple, le code suivant :

function foo() {
    echo 'This is the foo function';
}
$bar = 'foo';
$bar();

L'exécution du code ci-dessus affichera "Ceci est". la fonction foo" . Pour plus de détails, veuillez vous référer au manuel PHP : Fonctions variables. Bien sûr, si vous devez appeler dynamiquement, utilisez la fonction call_user_func ou call_user_func_array. L'utilisation de ces deux fonctions n'est pas le sujet de cet article. Si vous ne comprenez pas, veuillez vérifier les autres informations. Retour au sujet de cet article : Qu'est-ce qu'un objet instancié dynamiquement ? Je crois que l'instanciation dynamique des objets signifie que les objets qui doivent être instanciés sont déterminés dynamiquement (déterminés par des variables) pendant l'exécution du programme (déterminés par des variables), plutôt que d'être directement codés en dur dans le code.

Grâce aux exemples ci-dessus, nous savons déjà comment appeler dynamiquement une fonction au moment de l'exécution. Aujourd'hui, alors que l'orientation objet est si populaire, dans certains codes, nous devons instancier dynamiquement une classe. Ce qu'il faut faire?

Situation 1 : Le constructeur de la classe n'a pas de paramètres ou le nombre de paramètres est déterminé

Si le constructeur de la classe n'a pas de paramètres ou la classe que l'on veut pour instancier n'a aucun paramètre Sans constructeur, cela semble un peu plus simple Vous pouvez le changer selon l'exemple ci-dessus. Eh bien, suivez le même exemple, qui ne peut pas :

Exemple de code : (le constructeur n'a pas de paramètres)

class FOO {
    private $a, $b;
    public function construct() {
        $this->a = 1;
        $this->b = 2;
    }
    public function test() {
        echo &#39;This is the method test of class FOO<br />&#39;;
        echo &#39;$this->a=&#39;, $this->a, &#39;, $this->b=&#39;, $this->b;
    }
}
$bar = &#39;FOO&#39;;
$foo = new $bar();
$foo->test();

Exécutez-le et vous verrez le résultat suivant :

This is the method test of class FOO
$this->a=1, $this->b=2

Eh bien, si nous voulons passer des paramètres, alors faisons ceci :

class FOO {
    private $a, $b;
    public function construct($a, $b) {
        $this->a = $a;
        $this->b = $b;
    }
    public function test() {
        echo &#39;This is the method test of class FOO<br />&#39;;
        echo &#39;$this->a=&#39;, $this->a, &#39;, $this->b=&#39;, $this->b;
    }
}
$bar = &#39;FOO&#39;;
$foo = new $bar(&#39;test&#39;, 5);
$foo->test();

Vous pouvez obtenir des résultats similaires :

This is the method test of class FOO
$this->a=test, $this->b=5

Idéal.

Cas 2 : Construction de classeLe nombre de paramètres de fonction est incertain

Cette situation sera beaucoup plus gênante, mais si vous voulez l'écrire de manière plus universelle, il suffit Cette situation doit être prise en compte. Par exemple, nous avons les deux classes suivantes

class FOO {
    public function test() {
        echo 'This is the method test of class FOO';
    }
}
class BAR {
    private $a, $b;
    public function construct($a, $b) {
        $this->a = $a;
        $this->b = $b;
    }
    public function test() {
        echo &#39;This is the method test of class BAR<br />&#39;;
        echo &#39;$this->a=&#39;, $this->a, &#39;, $this->b=&#39;, $this->b;
    }
}

et nous voulons une manière commune d'instancier ces deux classes. Nous avons remarqué que la classe FOO n'a pas de constructeur, ou on peut considérer que le nombre de paramètres du constructeur de la classe FOO est nul alors que le constructeur de la classe BAR a des paramètres ; Heureusement, PHP5 est assez puissant et introduit le concept de réflexion. Pour plus de détails, veuillez vous référer au manuel PHP : Réflexion, bien qu'il n'y ait rien à référencer dans le manuel :). Heureusement, le nom est bien écrit. Vous pouvez déjà avoir une idée générale à partir du nom de la classe et du nom de la méthode, vous n’avez donc pas besoin de trop de mots.

Eh bien, utilisons la réflexion PHP5 pour commencer cette affaire :

(Étudiants qui utilisent encore PHP4, ne partez pas. Si vous avez une version PHP sans réflexion ou est-ce parce que de compatibilité ou parce que vous ne souhaitez pas mettre à niveau ? De toute façon, vous ne souhaitez pas utiliser la réflexion. Il y a une solution ci-dessous)

$class = new ReflectionClass('FOO');
$foo = $class->newInstance(); //或者是$foo = $class->newInstanceArgs();
$foo->test();

Avez-vous vu quelque chose ? Suivant :

$class = new ReflectionClass('BAR');
$bar = $class->newInstanceArgs(array(55, 65));
$bar->test();

OK, cela semble OK, alors faisons le tri et créons une fonction générale. Nous voulons la concevoir comme ceci. La première fonction de cette fonction est le nom de la classe. instancié. From Le deuxième paramètre commence par les paramètres du constructeur de la classe à instancier. S'il y en a plusieurs, notez-les. Sinon, ne les notez pas. Pour implémenter une fonction avec un nombre variable de paramètres, nous avons deux méthodes :

La première est similaire à :

function foo($arg1, $arg2 = 123, $arg3 = 'test', $arg4 = null, ....... ) {
    //some code;
}

Cette méthode présente deux inconvénients, Le premier est si vous. devez transmettre 100 paramètres, devriez-vous simplement écrire 100 paramètres ? La seconde est que vous devez déterminer quel paramètre du programme est nul ou une autre valeur par défaut. (Digression : La valeur par défaut du paramètre dans cette façon d'écrire doit être placée à la fin. Vous ne pouvez pas insérer un paramètre sans valeur par défaut au milieu ou devant un paramètre avec une valeur par défaut. Sinon, vous devez aussi explicitement écrivez le paramètre avec une valeur par défaut lorsque vous l'appelez. value)

Une autre façon d'implémenter un nombre variable de paramètres est d'utiliser la fonction intégrée de PHP func_get_args (cliquez ici pour lire le manuel) pour obtenir les paramètres passés à la fonction dans la fonction. Les fonctions similaires incluent func_get_num et func_get_arg. Oubliez ça, je suis paresseux. Vous pouvez trouver le manuel et le lire vous-même.

Ensuite, il semble beaucoup plus pratique d'utiliser cette fonction. Sur la base de la disposition imaginaire des paramètres de la fonction , le code devrait ressembler à ceci :

function newInstance() {
    $arguments = func_get_args();
    $className = array_shift($arguments);
    $class = new ReflectionClass($className);
    return $class->newInstanceArgs($arguments);
}

<.>OK, regardons l'effet :

$foo = newInstance('FOO');
$foo->test();
//输出结果：
//This is the method test of class FOO
$bar = newInstance('BAR', 3, 5);
$bar->test();
//输出结果：
//This is the method test of class BAR
//$this->a=3, $this->b=5

Avec seulement quatre lignes de code, l'effet est tout à fait parfait. Ensuite, si elle est appliquée à une classe, nous pouvons utiliser cette idée et l'écrire directement comme

Méthode magique, ce qui peut rendre notre classe plus cool !

class INSTANCE {
    function call($className, $arguments) {
        $class = new ReflectionClass($className);
        return $class->newInstanceArgs($arguments);
    }
}
$inst = new INSTANCE();
$foo = $inst->foo();
$foo->test();
//输出结果：
//This is the method test of class FOO
$bar = $inst->bar('arg1', 'arg2');
$bar->test();
//输出结果：
//This is the method test of class BAR
//$this->a=3, $this->b=5

Kaka, profite-en.

Ensuite, discutons de la situation sans utiliser les cours de réflexion. Par exemple, il n'y a aucune réflexion dans PHP4, et certains anciens projets fonctionnent sur PHP4. Ou si vous souhaitez garantir la compatibilité du projet avec des environnements inconnus, peu importe, occupons-nous de la manière de transférer dynamiquement les paramètres. Il n'existe qu'une seule fonction de transfert dynamique de paramètres en PHP : call_user_func_array (cliquez ici pour voir le manuel). Il s'agit d'une fonction qui appelle dynamiquement une fonction. Sa fonction est de transmettre les paramètres de la fonction à la fonction à appeler sous la forme d'un tableau. Eh bien, j'étais moi-même confus, alors regardons directement l'exemple :

function foo($a, $b) {
    echo &#39;$a=&#39;, $a, &#39;<br />&#39;;
    echo &#39;$b=&#39;, $b;
}
call_user_func_array(&#39;foo&#39;, array(1, &#39;string&#39;));
//本例输出结果：
//$a=1
//$b=string

那么，要实现用这种方法来动态实例化对象并传参，呃……，只有曲线救国了，我们得先写一个函数，让这个函数来实例化对象，而这个函数的参数就原原本本地传给要实例化对象的类的构造函数就好了。打住！那这个函数得有几个参数啊？怎么实现传递不同个数的参数呢？嘿嘿，我一声冷笑，你忘了PHP里提供一个创建匿名函数的函数吗？（又开始绕起来了……）create_function（手册在此），照着手册里面的例子直接画就可以了，我也懒得打字了，直接看下面的代码，注释我写清楚点大家都明白了：

function newInst() {
    //取得所有参数
    $arguments = func_get_args();
    //弹出第一个参数，这是类名，剩下的都是要传给实例化类的构造函数的参数了
    $className = array_shift($arguments);
    //给所有的参数键值加个前缀
    $keys = array_keys($arguments);
    array_walk($keys, create_function('&$value, $key, $prefix', '$value = $prefix . $value;'), '$arg_');
    //动态构造实例化类的函数，主要是动态构造参数的个数
    $paramStr = implode(', ',$keys);
    $newClass=create_function($paramStr, "return new {$className}({$paramStr});");
    //实例化对象并返回
    return call_user_func_array($newClass, $arguments);
}

好了，至于效果是什么，就麻烦各位看官自己动动手，运行一下看看，是不是自己期望的结果。

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!