Introducere în distrugător în PHP

PHP a introdus o metodă distrugătoare la fel ca cea prezentă în alte limbi OOP precum C ++. După cum spune numele, un distrugător este sensul unui obiect atunci când este distrus sau când scriptul este întrerupt sau oprit. Constructorii sunt membri ai funcțiilor speciale pentru instanțele obiect nou create. Distrugătorii sunt exact opusul constructorilor și sunt numiți când instanța creată este ștersă din memorie.

Un constructor este numit prin funcția __construct (), în timp ce un distrugător este apelat folosind funcția __destruct () pe care PHP o apelează automat în partea de jos a scriptului. Când practic nu există nici una din referințele lăsate la un obiect în vreo ordine, se numește automat un distrugător.

Sintaxa de bază pentru a apela un distrugător: funcția __destruct (),

Sintaxă:

__destruct ( void ) : void

Pentru ca fiecare distrugător să fie apelat, trebuie să existe un constructor înaintea acestuia, așa cum se arată mai jos:

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

Funcționarea distrugătorului în PHP

Distrugătorul este gestionat practic de Colectorul de gunoi care șterge un obiect atunci când nu mai este nevoie. Nu poate lua niciun argument ca element de intrare în contrast cu constructorul.

Această metodă este de asemenea folosită pentru curățarea resurselor și pentru eliberarea memoriei pentru acomodarea mai multor. Supraîncărcarea nu poate fi efectuată cu distrugători și poate exista un singur distrugător în aceeași clasă. O altă caracteristică unică a acesteia este că, chiar dacă scriptul și-a oprit execuția cu ajutorul unei comenzi exit (), distrugătorul va fi apelat în continuare. Această ieșire () nu va permite renunțarea la metodele de închidere rămase.

Exemple de distrugător în PHP

Să luăm câteva exemple pentru a înțelege mai bine distrugătorul:

Exemplul # 1

Acesta este un exemplu simplu în care creăm o funcție de constructor de bază și apoi distrugem aceeași prin apelarea funcției distrugătoare.

Cod:

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

ieşire:

Exemplul # 2

Pentru acest exemplu folosim două variabile în constructor; prenumele și prenumele angajatului și apoi distrugem obiectul Angajat chiar înainte de încheierea codului PHP prin apelarea distrugătorului.

Cod:

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

ieşire:

Exemplul # 3

În acest exemplu, vom vedea cum să gestionați un fișier test_doc.txt care este un document text prealabil pentru a fi prezent în același director de lucru ca fișierul principal. Asigurați-vă că includeți un text în test_doc.txt care trebuie afișat ca parte a codului.

fopen este funcția încorporată folosită pentru deschiderea fișierului, iar fread este funcția folosită pentru citirea conținutului fișierului. Aici distrugătorul va fi chemat să închidă / să distrugă filehandle.

Cod:

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

ieşire:

Așa cum am menționat în cod, dacă dezacordăm funcția gc_collect_cycles () în centrul scriptului, obținem ieșirea ca mai jos:

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

ieşire:

Următorul avertisment este aruncat dacă test_doc.txt nu este creat.

Avantajele distrugătorilor

  • Distrugătorii ajută la eliberarea alocării de memorie asigurându-se astfel spațiul necesar pentru obiectele nou create de constructor sau eliberarea resurselor pentru orice altă sarcină.
  • Se asigură că toate sarcinile rulează eficient, deoarece are grijă de procesul de curățare.
  • În cazurile în care sunt alocate multe variabile și structuri, utilizarea distrugătorilor va ajuta la prevenirea scurgerii de memorie prin eliberarea de resurse interne.
  • Acesta are grijă atât de variabilele statice, cât și de cele locale.

Limitările distrugătorilor

  • Distrugătorii nu pot lua niciun parametru și, de asemenea, nu dau nicio valoare de retur (nici măcar nulă).
  • Moștenirea nu este permisă prin intermediul distrugătorilor
  • Nu este obligatoriu ca un distrugător să fie static
  • Referirea la o adresă a unui distrugător nu este posibilă
  • Un obiect care aparține clasei care conține distrugătorul nu este permis să fie membru al sindicatului.
  • Este obligatoriu ca o funcție de distrugere să aibă acces public.

Concluzie

După cum am văzut, distrugătorii fiind inversul exact al constructorilor sunt folosiți pentru a distruge un obiect după ce utilizarea sa este terminată și nu este necesară în continuare în cod. Astfel, asigurarea curățării resurselor nedorite, permițând spațiu pentru resursele viitoare. Acest lucru se realizează prin declararea funcției __destruct () care va fi apelată automat de PHP la sfârșitul scriptului.

Articole recomandate

Acesta este un ghid pentru Destructor în PHP. Aici vom discuta despre funcționarea, avantajele și limitările distrugătorului în PHP împreună cu exemple. De asemenea, puteți consulta următoarele articole pentru a afla mai multe -

  1. Array asociativ în PHP
  2. Rădăcina pătrată în PHP
  3. Funcții în PHP
  4. Obțineți adresa IP în PHP

Categorie:

Dezvoltare de software