Ein Destruktor ist eine Funktion, die zum Löschen der Objektinstanz verwendet wird, die von einem Konstruktor für eine bestimmte Klasse als Teil ihrer Funktionsfunktion erstellt wurde. Wann immer ein Konstruktor in einem PHP-Programm verwendet wird, ist es nicht zwingend erforderlich, dass eine Destruktorfunktion zur Ergänzung seiner Funktionalität vorhanden ist. Es wird jedoch als bewährte Vorgehensweise angesehen, einen Destruktor im Programm zu haben, wo ein Konstruktor benötigt wird. Außerdem wird diese Methode nicht speziell zur Ausführung aufgerufen, sondern ausgeführt, wenn das Steuerelement keine funktionalen Verweise mehr auf die Konstruktormethode findet.
Grundlegende Syntax zum Aufrufen eines Destruktors: Die Funktion __destruct()
WERBUNG Beliebter Kurs in dieser Kategorie PHP-ENTWICKLER - Spezialisierung | 8-Kurs-Reihe | 3 ProbetestsStarten Sie Ihren kostenlosen Softwareentwicklungskurs
Webentwicklung, Programmiersprachen, Softwaretests und andere
Syntax:
__destruct ( void ) : void
Damit jeder Destruktor aufgerufen werden kann, muss davor ein Konstruktor stehen, wie unten gezeigt:
<?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 } } ?>
Der Destruktor wird grundsätzlich vom Garbage Collector verwaltet, der ein Objekt löscht, wenn es nicht mehr benötigt wird. Im Gegensatz zum Konstruktor kann er keine Argumente als Eingabe annehmen.
Diese Methode wird auch zum Bereinigen von Ressourcen und zum Freigeben des Speichers für mehr Speicherplatz verwendet. Mit Destruktoren kann kein Überladen durchgeführt werden und es kann nur ein einziger Destruktor in derselben Klasse vorhanden sein. Ein weiteres einzigartiges Merkmal besteht darin, dass der Destruktor auch dann aufgerufen wird, wenn die Ausführung des Skripts mithilfe eines Befehls „exit()“ gestoppt wurde. Dieser Exit() verhindert, dass die verbleibenden Shutdown-Methoden beendet werden.
Nehmen wir einige Beispiele, um den Destruktor besser zu verstehen:
Dies ist ein einfaches Beispiel, in dem wir eine grundlegende Konstruktorfunktion erstellen und diese dann zerstören, indem wir die Destruktorfunktion aufrufen.
Code:
<?php class DestructableExample { function __construct() { print "Inside constructor\n"; } function __destruct() { print "Destroying the class " . __CLASS__ . "\n"; } } $obj = new DestructableExample();
Ausgabe:
Für dieses Beispiel verwenden wir zwei Variablen im Konstruktor; Vorname und Nachname des Mitarbeiters und dann zerstören wir das Objekt „Mitarbeiter“, kurz bevor der PHP-Code endet, indem wir den Destruktor aufrufen.
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(); ?>
Ausgabe:
In diesem Beispiel werden wir sehen, wie mit einer Datei test_doc.txt umgegangen wird, bei der es sich um ein erforderliches Textdokument handelt, das im selben Arbeitsverzeichnis wie die Hauptdatei vorhanden sein muss. Stellen Sie sicher, dass Sie in test_doc.txt Text einfügen, der als Teil des Codes angezeigt werden muss.
fopen ist die integrierte Funktion zum Öffnen der Datei und fread ist die Funktion zum Lesen des Dateiinhalts. Hier wird der Destruktor aufgerufen, um das Dateihandle zu schließen/zu zerstören.
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; ?>
Ausgabe:
Wie im Code erwähnt, erhalten wir die folgende Ausgabe, wenn wir die Funktion gc_collect_cycles() in der Mitte des Skripts auskommentieren:
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(); ?>
Ausgabe:
Die folgende Warnung wird ausgegeben, wenn test_doc.txt nicht erstellt wurde.
Wie wir gesehen haben, werden Destruktoren, die das genaue Gegenteil von Konstruktoren sind, verwendet, um ein Objekt zu zerstören, nachdem seine Verwendung abgeschlossen ist und nicht weiter im Code benötigt wird. Dadurch wird sichergestellt, dass unerwünschte Ressourcen bereinigt werden und Platz für zukünftige Ressourcen geschaffen wird. Dies geschieht durch die Deklaration der Funktion __destruct(), die von PHP am Ende des Skripts automatisch aufgerufen wird.
Das obige ist der detaillierte Inhalt vonDestruktor in PHP. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!