Introduction à Destructor en PHP

PHP a introduit une méthode destructrice identique à celle présente dans d'autres langages OOP comme C ++. Comme son nom l'indique, un destructeur est la signification d'un objet lorsqu'il est détruit ou lorsque le script est interrompu ou arrêté. Les constructeurs sont membres de fonctions spéciales pour les instances d'objet nouvellement créées. Les destructeurs sont exactement l'opposé des constructeurs et ils sont appelés lorsque l'instance créée est supprimée de la mémoire.

Un constructeur est appelé par la fonction __construct () tandis qu'un destructeur est appelé à l'aide de la fonction __destruct () que le PHP appelle automatiquement en bas du script. Lorsqu'il ne reste pratiquement aucune référence à un objet dans un ordre quelconque, un destructeur est automatiquement appelé.

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

Syntaxe:

__destruct ( void ) : void

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

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

Fonctionnement de Destructor 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 pas prendre d'arguments comme entrée contrairement au constructeur.

Cette méthode est également utilisée pour nettoyer les ressources et libérer de 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 1

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

Code:

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

Production:

Exemple # 2

Pour cet exemple, nous utilisons deux variables dans le constructeur; nom et prénom de l'employé, puis nous détruisons l'objet Employé 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…
";
$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 . "
";
)
)
// Class object declaration
$harry = new Employee("Harry", "Potter");
$harry->showName();
?>

Production:

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 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;
?>

Production:

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

Exemple # 4

<_?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();
?>

Production:

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, s'assurant 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 car 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 à éviter 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 ils ne donnent aucune valeur de retour (pas même nul).
  • L'héritage n'est pas autorisé via les destructeurs
  • Il n'est pas obligatoire qu'un destructeur soit statique
  • Il n'est pas possible de se référer à l'adresse d'un destructeur
  • Un objet qui appartient à la classe contenant le destructeur n'est pas autorisé à être membre d'union.
  • Il est obligatoire qu'une fonction destructrice ait un accès public.

Conclusion

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

Articles recommandés

Ceci est un guide pour Destructor en PHP. Nous discutons ici du fonctionnement, des avantages et des limites du destructeur en PHP avec des exemples. Vous pouvez également consulter les articles suivants pour en savoir plus -

  1. Tableau associatif en PHP
  2. Racine carrée en PHP
  3. Fonctions en PHP
  4. Obtenir une adresse IP en PHP

Catégorie:

Développement de logiciels