Objectif des constructeurs PHP

Question

Je travaille avec des classes et une structure de classes d'objets, mais pas à un niveau complexe - juste des classes et des fonctions, puis, en un seul endroit, instanciation.

Quant à __construct et __destruct, s'il vous plaît me dire très simplement: quel est le but des constructeurs et destructeurs? Je connais l'explication théorique au niveau de l'école, mais j'attends quelque chose comme dans le monde réel, comme dans les situations où nous devons les utiliser.

Fournissez également un exemple, s'il vous plaît.

Cordialement

Answer 1

Le constructeur d'une classe définit ce qui se passe lorsque vous instancier un objet de cette classe. Le destructeur d'une classe définit ce qui se passe lorsque vous détruisez l'instance d'objet.

Voir la PHP Manual on Constructors and Destructors:

PHP 5 permet aux développeurs de déclarer des constructeurs pour les classes. Les classes qui ont une méthode constructeur appellent cette méthode sur chaque objet nouvellement créé, elle convient donc à toute initialisation dont l'objet peut avoir besoin avant d'être utilisé.

et

PHP 5 introduit un concept destructor similaire à celle d'autres langages orientés objet, tels que C++. La méthode destructeur sera appelée dès que toutes les références à un objet particulier sont supprimées ou lorsque l'objet est explicitement détruit ou dans un ordre quelconque dans la séquence d'arrêt.

En pratique, vous utilisez le constructeur pour placer l'objet dans un état valide minimum. Cela signifie que vous affectez les arguments passés au constructeur aux propriétés de l'objet. Si votre objet utilise une sorte de types de données qui ne peuvent pas être affectés directement en tant que propriété, vous les créez ici, par ex.

class Example 
{ 
    private $database; 
    private $storage; 

    public function __construct($database) 
    { 
     $this->database = $database; 
     $this->storage = new SplObjectStorage; 
    } 
} 

Notez que pour garder vos objets testable, a constructor should not do any real work:

travail dans le constructeur, tels que: création/initialisation collaborateurs, communiquer avec d'autres services, et la logique de mettre en place son propre état supprime les coutures nécessaires au test, forçant les sous-classes/fausses à hériter d'un comportement indésirable. Trop de travail dans le constructeur empêche l'instanciation ou la modification des collaborateurs dans le test.

Dans Example ci-dessus, le $database est un collaborateur. Il a un cycle de vie et le but de son propre et peut être une instance partagée. Vous ne créeriez pas cela à l'intérieur du constructeur. D'autre part, le SplObjectStorage fait partie intégrante de Example. Il a le même cycle de vie et n'est pas partagé avec d'autres objets. Ainsi, il est correct de new dans le ctor.

De même, vous utilisez le destructeur pour nettoyer après votre objet. Dans la plupart des cas, cela n'est pas nécessaire car il est géré automatiquement par PHP. C'est pourquoi vous verrez beaucoup plus de ctors que de dtors dans la nature.

Answer 2

Un constructeur est une fonction qui est exécutée après l'initialisation de l'objet (sa mémoire allouée, ses propriétés d'instance copiées, etc.). Son but est de mettre l'objet dans un état valide.

Souvent, un objet, pour être dans un état utilisable, nécessite certaines données. Le but du constructeur est de forcer ces données à être données à l'objet au moment de l'instanciation et d'interdire toutes les instances sans ces données. Considérons une classe simple qui encapsule une chaîne et possède une méthode qui renvoie la longueur de cette chaîne. Une possible serait:

class StringWrapper { 
    private $str; 

    public function setInnerString($str) { 
     $this->str = (string) $str; 
    } 

    public function getLength() { 
     if ($this->str === null) 
      throw new RuntimeException("Invalid state."); 
     return strlen($this->str); 
    } 
} 

Afin d'être dans un état valide, cette fonction nécessite setInnerString être appelée avant getLength. En utilisant un constructeur, vous pouvez forcer tous les cas être en bon état quand getLength est appelé:

class StringWrapper { 
    private $str; 

    public function __construct($str) { 
     $this->str = (string) $str; 
    } 

    public function getLength() { 
     return strlen($this->str); 
    } 
} 

Vous pouvez également garder le setInnerString pour permettre à la chaîne à changer après instanciation.

Un destructeur est appelé lorsqu'un objet est sur le point d'être libéré de la mémoire. Généralement, il contient du code de nettoyage (par exemple, fermeture des descripteurs de fichiers que l'objet contient). Ils sont rares en PHP car PHP nettoie toutes les ressources contenues dans le script lorsque l'exécution du script se termine.

Answer 3

En savoir par exemple:

class Person { 
    public $name; 
    public $surname; 
    public function __construct($name,$surname){ 
    $this->name=$name; 
    $this->surname=$surname; 
    } 
} 

Pourquoi est-ce utile? Parce qu'au lieu de:

$person = new Person(); 
$person->name='Christian'; 
$person->surname='Sciberras'; 

vous pouvez utiliser:

$person = new Person('Christian','Sciberras'); 

qui est moins code et semble plus propre! Remarque: Comme les réponses ci-dessous le signalent correctement, les constructeurs/destructeurs sont utilisés pour une grande variété de choses, y compris: de/initialisation des variables (surtout quand la valeur est variable), mémoire de/allocation, invariants être surpassé) et un code plus propre. Je voudrais aussi noter que "code nettoyeur" n'est pas seulement "sucre" mais améliore la lisibilité, la maintenabilité, etc.

Answer 4

Le constructeur est exécuté au moment où vous instanciez une instance de votre classe. Donc, si vous avez une classe Person:

class Person { 

    public $name = 'Bob'; // this is initialization 
    public $age; 

    public function __construct($name = '') { 
     if (!empty($name)) { 
      $this->name = $name; 
     } 
    } 

    public function introduce() { 
     echo "I'm {$this->name} and I'm {$this->age} years old\n"; 
    } 

    public function __destruct() { 
     echo "Bye for now\n"; 
    } 
} 

Pour démontrer:

$person = new Person; 
$person->age = 20; 
$person->introduce(); 

// I'm Bob and I'm 20 years old 
// Bye for now 

Nous pouvons remplacer la valeur par défaut définie avec l'initialisation via l'argument du constructeur:

$person = new Person('Fred'); 
$person->age = 20; 
$person->introduce(); 

// if there are no other references to $person and 
// unset($person) is called, the script ends 
// or exit() is called __destruct() runs 
unset($person); 

// I'm Fred and I'm 20 years old 
// Bye for now 

Espérons qui aide à démontrer où le constructeur et le destructeur sont appelés, à quoi servent-ils?

1. __construct() peut être membre de classe par défaut avec des ressources ou des structures de données plus complexes.
2. __destruct() peut libérer des ressources comme les handles de fichiers et de bases de données. Le constructeur est souvent utilisé pour class composition ou constructor injection of required dependencies.

Answer 5

Je l'ai trouvé qu'il était plus facile à saisir quand je pensais sur le mot-clé new avant que le constructeur: il dit simplement ma variable un nouvel objet de son type de données serait donner à lui, sur la base duquel le constructeur j'appelle et ce que je passe dedans, je peux définir à l'état de l'objet à l'arrivée.

Sans le nouvel objet, nous vivrions dans la terre de null, et les accidents! Le destructeur est le plus évident à partir d'un point de vue C++, où si vous n'avez pas une méthode destructeur supprimer toute la mémoire pointée, il restera utilisé après la sortie du programme provoquant des fuites et retard sur le système d'exploitation client jusqu'à son prochain redémarrage.

Je suis sûr qu'il y a plus qu'assez de bonnes informations ici, mais un autre angle est toujours utile de ce que j'ai remarqué!