PHP passage de paramètres lors de la création de nouveaux objets, call_user_func_array pour les objets

Je voudrais créer dynamiquement un objet PHP, et des paramètres facultatifs.

Par exemple, au lieu de faire ceci:

$test = new Obj($param);

Je voudrais faire quelque chose comme ceci (créer de nouveaux ob est une fiction):

$test = create_new_obj('Obj', $param);

Est-il de cette fonction en php? Quelque chose de semblable à call_user_func_array, mais pour un objet.

  • pour préciser un peu plus, le nom de la classe est variable (ça change), et $param dépend de la classe qui en est chargé. Parfois il n'y a pas de param. Il s'agit essentiellement de les charger dynamiquement à partir d'une variété de classes en fonction de la situation.
  • Je pense que ma réponse ci-dessous correspond toujours à la facture de ce que vous décrivez (variable noms de classe, en option paramètres de construction). Il n'y a aucune raison que vous ne pouvez pas passer null $param à un constructeur pour une classe qui n'en a pas besoin. Si, d'autre part, vous dites que le type de l'objet qui est créé est en fait la personne à charge sur $param, alors vous aurez envie de regarder dans quelque chose comme le Modèle de Fabrique: en.wikipedia.org/wiki/Factory_method_pattern. PHP ne peut pas gérer vos décisions de construction pour vous dans ce cas... vous aurez besoin d'écrire logique pour décider de ce qui est construit.
InformationsquelleAutor Patrick | 2010-03-31
  1. 24

    De PHP 5.6, vous pouvez désormais le faire avec une seule ligne de code à l'aide de l'Argument nouveau Déballage de l'opérateur (...).

    Voici un exemple simple.

    $className='Foo';
$args=['arg1','arg2','arg3'];

$newClassInstance=new $className(...$args);

    Voir Variable PHP-longueur des listes d'arguments pour plus d'informations.

    • ne devriez pas avoir besoin de plus de 1 ligne en 5.5 - soit alors. $db = (new ReflectionClass ( 'Foo' ))->newInstanceArgs ( $args );
    InformationsquelleAutor TimChandler
  2. 16

    Puisque certains constructeurs peuvent prendre un nombre variable d'arguments, la méthode suivante doit être utilisée pour les accueillir.

    $r = new ReflectionClass($strClassName);
$myInstance = $r->newInstanceArgs($arrayOfConstructorArgs);

    Par exemple, si votre Car constructeur a pris 3 args 

    $carObj = new Car($color, $engine, $wheels);

    Puis 

    $strClassName = 'Car';
$arrayOfConstructorArgs = array($color, $engine, $wheels);
$r = new ReflectionClass($strClassName);
$carObj = $r->newInstanceArgs($arrayOfConstructorArgs);

    http://php.net/manual/en/class.reflectionclass.php

    http://php.net/manual/en/reflectionclass.newinstanceargs.php

    • La réflexion est cher. Vous feriez mieux d'utiliser func_get_args() pour cela.
    • Dans mes tests à l'aide de la réflexion en php n'est pas plus lent que func_get_args(). De Plus, vous n'avez pas à modifier le code de la classe.
    InformationsquelleAutor goat
  3. 7

    Dans de tels cas, j'utilise usine méthodes. ils peuvent être facilement définis dans les classes abstraites:

    class Foobar {

    public function __construct($foo, $bar) 
    {
        //do something
    }

    static public function factory($foo, $bar) 
    {
        return new self($foo, $bar);
    }
}

    avec cela, vous pouvez utiliser call_user_func_array():

    $my_foobar_obj = call_user_func_array('Foobar::factory', array($foo, $bar));
    InformationsquelleAutor smoe
  4. 6

    Vous pouvez créer dynamiquement un objet aussi longtemps que vous savez le nom de la classe:

    $objName = 'myClass';
$test = new $objName($param);

    Vous pouvez facilement définir une __construct() fonction de prendre les arguments par défaut ainsi si c'était une condition de la construction de la logique.

    [Modifier note]: C'est un concept connu sous le nom les variables, et il y a quelques exemples dans le manuel où l' nouveau commande est introduit.

    InformationsquelleAutor zombat
  5. 4

    Ici est une version épurée de ce que tu voulais:

    class ClassName {
    public static function init(){       
        return (new ReflectionClass(get_called_class()))->newInstanceArgs(func_get_args());        
    }

    public static function initArray($array=[]){       
        return (new ReflectionClass(get_called_class()))->newInstanceArgs($array);        
    }

    public function __construct($arg1, $arg2, $arg3){
        ///construction code
    } 
}

    Normal laid méthode de création d'une nouvelle instance de l'objet à l'aide de nouvelles

    $obj = new ClassName('arg1', 'arg2', 'arg3');
echo $obj->method1()->method2();

    Appel statique à l'aide d'init à la place de la nouvelle

    echo ClassName::init('arg1', 'arg2', 'arg3')->method1()->method2();

    Statique appel à l'aide de initArray à la place de la nouvelle

    echo ClassName::initArray(['arg1', 'arg2', 'arg3'])->method1()->method2();
    InformationsquelleAutor Dieter Gribnitz
  6. 0

    Basé sur @chris' réponse( https://stackoverflow.com/a/2550465/1806628 ), voici une utilisation de la réflexion classes:

    abstract class A{
    //the constructor writes out the given parameters
    public function __construct(){
        var_dump(func_get_args());
    }

    public function copy(){
        //find our current class' name, __CLASS__ would return A
        $thisClass = get_class($this);
        $tmp = new ReflectionClass($thisClass);
        //pass all the parameters recieved to the new object
        $copy = $tmp->newInstanceArgs(func_get_args());

        return $copy;
    }
}

class B extends A{}

//create a new B object, with no parameters
$b = new B();

//create another b, but with other parameters
$c = $b->copy('the parameter of the copied B');

    C'est utile, si vous voulez faire un objet de la fonction de copie dans une classe ancêtre et ne sais pas, si les enfants des classes de besoin de paramètres dans l'avenir, ou pas.

    InformationsquelleAutor Lajos Meszaros