Analyse de cas de PHP instanciant dynamiquement des objets et transmettant des paramètres au constructeur

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. D'après notre disposition imaginée des paramètres de 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, prenons. un aperçu de 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

Juste 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

Cliquez, cool.

接下来讨论一下不使用反射类的情况。例如PHP4中就没有反射，而一些老项目就是运行在PHP4上面的。或者是要保证项目对未知环境的兼容性，Whatever，来关心一下怎么动态传参吧。PHP中动态传参的函数只有一个：call_user_func_array(轻击此处查看手册)。这是一个动态调用函数的函数，作用是可以将函数的参数以数组的形式传递给要调用的函数。好吧，我自己也被自己绕晕了，直接来看实例：

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

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

如果改写成类里面的魔术方法，哼哼，威力嘛，你懂的！然后呢，我还是懒了，如果要写成魔术方法的话，相信这么easy的事情你很轻松就办到了。就当一个作业吧。另，本文的代码都是本人运行过的，但是，写文章的时候没有使用复制/粘贴功能，所以，你最好是也不要复制粘贴。如果从本文中的代码copy下来运行出错的话，还烦请各位自己debug一下，编程不就是要自己写么。

本来这个话题到这里就应该可以结束了，但是想到我在想到这个办法之前用的方法（好绕……），本着重在交流的态度，一起放出来。我例两个关键函数吧：extract和eval。只是我个人觉得用eval函数比较山寨，能不用最好不用。于是又想出了上面的办法，哈哈，编程最重要的是思想，不是吗？好，又是一道作业题了，大家可以试试用这两个函数（当然也会用到别的函数）来实现带不定数量的参数动态实例化对象的函数。

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!