Meilleure façon d'utiliser des constructeurs multiples en PHP

Question

Vous ne pouvez pas mettre deux fonctions __construct avec des signatures d'arguments uniques dans une classe PHP. J'aimerais faire ceci :

class Student 
{
   protected $id;
   protected $name;
   // etc.

   public function __construct($id){
       $this->id = $id;
      // other members are still uninitialized
   }

   public function __construct($row_from_database){
       $this->id = $row_from_database->id;
       $this->name = $row_from_database->name;
       // etc.
   }
}

Quelle est la meilleure façon de faire cela en PHP ?

Answer 1

Je ferais probablement quelque chose comme ça :

<?php

class Student
{
    public function __construct() {
        // allocate your stuff
    }

    public static function withID( $id ) {
        $instance = new self();
        $instance->loadByID( $id );
        return $instance;
    }

    public static function withRow( array $row ) {
        $instance = new self();
        $instance->fill( $row );
        return $instance;
    }

    protected function loadByID( $id ) {
        // do query
        $row = my_awesome_db_access_stuff( $id );
        $this->fill( $row );
    }

    protected function fill( array $row ) {
        // fill all properties from array
    }
}

?>

Ensuite, si je veux un étudiant dont je connais l'identité :

$student = Student::withID( $id );

Ou si j'ai un tableau de la ligne de la base de données :

$student = Student::withRow( $row );

Techniquement, vous ne construisez pas de constructeurs multiples, juste des méthodes d'aide statiques, mais vous évitez ainsi beaucoup de code spaghetti dans le constructeur.

Answer 2

La solution de Kris est vraiment sympa, mais je préfère un mélange de style factory et fluent :

<?php

class Student
{

    protected $firstName;
    protected $lastName;
    // etc.

    /**
     * Constructor
     */
    public function __construct() {
        // allocate your stuff
    }

    /**
     * Static constructor / factory
     */
    public static function create() {
        return new self();
    }

    /**
     * FirstName setter - fluent style
     */
    public function setFirstName($firstName) {
        $this->firstName = $firstName;
        return $this;
    }

    /**
     * LastName setter - fluent style
     */
    public function setLastName($lastName) {
        $this->lastName = $lastName;
        return $this;
    }

}

// create instance
$student= Student::create()->setFirstName("John")->setLastName("Doe");

// see result
var_dump($student);
?>

Answer 3

PHP est un langage dynamique, vous ne pouvez donc pas surcharger les méthodes. Vous devez vérifier les types de vos arguments comme ceci :

class Student 
{
   protected $id;
   protected $name;
   // etc.

   public function __construct($idOrRow){
    if(is_int($idOrRow))
    {
        $this->id = $idOrRow;
        // other members are still uninitialized
    }
    else if(is_array($idOrRow))
    {
       $this->id = $idOrRow->id;
       $this->name = $idOrRow->name;
       // etc.  
    }
}

Answer 4

public function __construct() {
    $parameters = func_get_args();
    ...
}

$o = new MyClass('One', 'Two', 3);

Maintenant, $paramters sera un tableau avec les valeurs 'One', 'Two', 3.

Edit,

Je peux ajouter que

func_num_args()

vous donnera le nombre de paramètres de la fonction.

Answer 5

Vous pourriez faire quelque chose comme ça :

public function __construct($param)
{
    if(is_int($param)) {
         $this->id = $param;
    } elseif(is_object($param)) {
     // do something else
    }
 }