Destructeur en PHP

Un destructeur est une fonction utilisée pour supprimer l'instance d'objet créée par un constructeur pour une classe donnée, dans le cadre de sa fonctionnalité. Chaque fois qu'un constructeur est utilisé dans un programme PHP, il n'est pas obligatoire d'avoir une fonction destructeur pour compléter ses fonctionnalités. Mais il est considéré comme une bonne pratique d'avoir un destructeur dans le programme lorsqu'un constructeur est requis. De plus, cette méthode n'est pas spécifiquement appelée pour l'exécution, mais elle est exécutée lorsque le contrôle ne trouve plus de références fonctionnelles à la méthode constructeur.

Syntaxe de base pour appeler un destructeur : La fonction __destruct(),

PUBLICITÉ Cours populaire dans cette catégorie DEVELOPPEUR PHP - Spécialisation | Série de 8 cours | 3 tests simulés

Commencez votre cours de développement de logiciels libres

Développement Web, langages de programmation, tests de logiciels et autres

Syntaxe :

__destruct ( void ) : void

Pour que chaque destructeur soit appelé, il doit y avoir un constructeur avant lui, comme indiqué ci-dessous :

<?php
class <ANY_CLASS_NAME> {
// Declaring a constructor
function __construct() {
// To initialize required properties
}
// Declaring a destructor
function __destruct() {
// To remove reference of an object
}
}
?>

Fonctionnement du Destructeur en PHP

Destructor est essentiellement géré par le Garbage Collector qui efface un objet lorsqu'il n'est plus nécessaire. Il ne peut prendre aucun argument en entrée contrairement au constructeur.

Cette méthode est également utilisée pour nettoyer les ressources et libérer la mémoire pour en accueillir davantage. La surcharge ne peut pas être effectuée avec des destructeurs et un seul destructeur peut exister dans la même classe. Une autre caractéristique unique est que même si le script a arrêté son exécution à l'aide d'une commande exit(), le destructeur sera toujours appelé. Cette exit() ne permettra pas aux méthodes d'arrêt restantes de se fermer.

Exemples de Destructeur en PHP

Prenons quelques exemples pour mieux comprendre le destructeur :

Exemple n°1

Il s'agit d'un exemple simple dans lequel nous créons une fonction constructeur de base, puis la détruisons en appelant la fonction destructeur.

Code :

<?php
class DestructableExample
{
function __construct() {
print "Inside constructor\n";
}
function __destruct() {
print "Destroying the class " . __CLASS__ . "\n";
}
}
$obj = new DestructableExample();

Sortie :

Exemple n°2

Pour cet exemple, nous utilisons deux variables dans le constructeur ; prénom et nom de l'employé, puis nous détruisons l'objet Employee juste avant la fin du code PHP en appelant le destructeur.

Code :

<?php
class Employee {
// Employee's first name
private $emp_fname;
// Employee's last name
private $emp_lname;
// Declaration of constructor
public function __construct($emp_fname, $emp_lname) {
echo "Initialisation of object as follows...<br/>";
$this->emp_fname = $emp_fname;
$this->emp_lname = $emp_lname;
}
// Declaration of destructor
public function __destruct(){
// Here we can clean the resources
echo "Removing the Object...";
}
// This method is being used to display full name
public function showName() {
echo "Employee full name is: " . $this->emp_fname . " " . $this->emp_lname . "<br/>";
}
}
// Class object declaration
$harry = new Employee("Harry", "Potter");
$harry->showName();
?>

Sortie :

Exemple #3

Dans cet exemple, nous verrons comment gérer un fichier test_doc.txt qui est un document texte pré-requis pour être présent dans le même répertoire de travail que le fichier principal. Assurez-vous d'inclure du texte dans le test_doc.txt qui doit être affiché dans le cadre du code.

fopen est la fonction intégrée utilisée pour ouvrir le fichier et fread est la fonction utilisée pour lire le contenu du fichier. Ici, le destructeur sera appelé pour fermer/détruire le descripteur de fichier.

Code :

<?php
header("Content-type: text/plain");
class Example {
/**
* Declaring an identifier
* variable- string
*/
private $first_name;
/**
* A reference to another Foo object
* variable Foo
*/
private $setlink;
public function __construct($first_name) {
$this->first_name = $first_name;
}
public function setLink(Example $setlink){
$this->setlink = $setlink;
}
public function __destruct() {
echo 'Destroying: ', $this->first_name, PHP_EOL;
}
}
// We are creating 2 objects here
$obj1 = new Example('Example 1');
$obj2 = new Example('Example 2');
// Objects are made to point to themselves
$obj1->setLink($obj1);
$obj2->setLink($obj2);
// Destroying their global references
$obj1 = null;
$obj2 = null;
// Since both objects are declared null we cannot access them now and hence they must be destroyed
// but since they are not yet destroyed a memory leak may occur as they are still present.
//
// Garbage collector can be called as shown in below line. Uncomment to check its functionality
// gc_collect_cycles();
// Now we create 2 more objects but will not set their references
// only the obj1 and obj2 are pointing to them right now
$obj1 = new Example('Example 3');
$obj2 = new Example('Example 4');
// Removing their global references
$obj1 = null;
$obj2 = null;
// Now the Example 3 and example 4 cannot be accessed due to no references
// for them. Hence the destructor is called automatically
// previous to the execution of next line
echo 'Script has ended', PHP_EOL;
?>

Sortie :

Comme mentionné dans le code, si nous décommentons la fonction gc_collect_cycles() au centre du script, nous obtenons le résultat comme ci-dessous :

Exemple n°4

Code :

<?php
class FileHandle{
private $file_handle;
private $name;
/**
* We declare file handle with parameters file name and mode
* Using parameter string $name as file name
* Using parameter string $fmode as file mode for read, write
*/
public function __construct($name,$fmode){
$this->name = $name;
$this->file_handle = fopen($name, $fmode);
}
/**
* We are closing the file handle
*/
public function __destruct(){
if($this->file_handle){
fclose($this->file_handle);
}
}
/**
* Reading and printing file's content
*/
public function display(){
echo fread($this->file_handle, filesize($this->name));
}
}
$fu = new FileHandle('./test_doc.txt', 'r');
$fu->display();
?>

Sortie :

L'avertissement suivant est émis si test_doc.txt n'est pas créé.

Avantages des Destructeurs

• Les destructeurs aident à libérer l'allocation de mémoire, garantissant ainsi que l'espace requis est présent pour les objets nouvellement créés par le constructeur ou libérant des ressources pour toute autre tâche.
• Garantit que toutes les tâches s'exécutent efficacement puisqu'il prend en charge le processus de nettoyage.
• Dans les cas où de nombreuses variables et structures sont allouées, l'utilisation de destructeurs aidera à prévenir les fuites de mémoire en libérant des ressources internes.
• Il prend en charge les variables statiques et locales.

Limitations des destructeurs

• Les destructeurs ne peuvent prendre aucun paramètre et ne donnent également aucune valeur de retour (pas même nulle).
• L'héritage n'est pas autorisé via les destructeurs
• Il n'est pas obligatoire qu'un destructeur soit statique
• Faire référence à une adresse d'un destructeur n'est pas possible
• Un objet qui appartient à la classe contenant le destructeur n'est pas autorisé à être membre du syndicat.
• Il est obligatoire qu'une fonction destructeur ait un accès public.

Conclusion

Comme nous l'avons vu, les destructeurs étant l'exact inverse des constructeurs, sont utilisés pour détruire un objet une fois son utilisation terminée et ne sont pas requis plus loin dans le code. Garantissant ainsi qu’il nettoie les ressources indésirables, laissant ainsi de la place aux ressources futures. Cela se fait en déclarant la fonction __destruct() qui sera appelée automatiquement par PHP à la fin du script.

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!