Introduzione a Destructor in PHP

PHP ha introdotto un metodo distruttore uguale a quello presente in altri linguaggi OOP come C ++. Come dice il nome, un distruttore è il significato di un oggetto quando viene distrutto o quando lo script viene interrotto o fermato. I costruttori sono membri di funzioni speciali per le istanze di oggetti appena create. I distruttori sono l'esatto opposto dei costruttori e vengono chiamati quando l'istanza creata viene eliminata dalla memoria.

Un costruttore viene chiamato dalla funzione __construct () mentre un distruttore viene chiamato usando la funzione __destruct () che il PHP chiama automaticamente nella parte inferiore dello script. Quando praticamente non ci sono riferimenti a un oggetto in alcun ordine, viene automaticamente chiamato un distruttore.

Sintassi di base per chiamare un distruttore: la funzione __destruct (),

Sintassi:

__destruct ( void ) : void

Per ogni distruttore da chiamare, ci deve essere un costruttore prima di esso come mostrato di seguito:

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

Funzionamento di Destructor in PHP

Il distruttore è sostanzialmente gestito dal Garbage Collector che cancella un oggetto quando non è più necessario. Non può accettare alcun argomento come input in contrasto con il costruttore.

Questo metodo viene utilizzato anche per ripulire le risorse e liberare la memoria per ospitare di più. Il sovraccarico non può essere eseguito con i distruttori e nella stessa classe può esistere un solo distruttore. Un'altra caratteristica unica è che anche se lo script ha interrotto la sua esecuzione con l'aiuto di un comando exit (), il distruttore verrà comunque chiamato. Questa uscita () non consentirà la chiusura dei metodi di spegnimento rimanenti.

Esempi di distruttore in PHP

Facciamo alcuni esempi per capire meglio il distruttore:

Esempio 1

Questo è un semplice esempio in cui stiamo creando una funzione di costruzione di base e quindi distruggendo la stessa chiamando la funzione di distruttore.

Codice:

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

Produzione:

Esempio n. 2

Per questo esempio stiamo usando due variabili nel costruttore; nome e cognome dell'impiegato e quindi stiamo distruggendo l'oggetto Impiegato appena prima che il codice PHP termini chiamando il distruttore.

Codice:

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

Produzione:

Esempio n. 3

In questo esempio, vedremo come gestire un file test_doc.txt che è un documento di testo prerequisito per essere presente nella stessa directory di lavoro del file principale. Assicurati di includere del testo in test_doc.txt che deve essere visualizzato come parte del codice.

fopen è la funzione integrata utilizzata per aprire il file e fread è la funzione utilizzata per leggere il contenuto del file. Qui il distruttore verrà chiamato per chiudere / distruggere il filehandle.

Codice:

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

Produzione:

Come menzionato nel codice, se decommentiamo la funzione gc_collect_cycles () al centro dello script otteniamo l'output come di seguito:

Esempio n. 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();
?>

Produzione:

Il seguente avviso viene generato se test_doc.txt non viene creato.

Vantaggi dei distruttori

  • I distruttori aiutano a liberare l'allocazione di memoria assicurandosi così che lo spazio necessario sia disponibile per gli oggetti appena creati dal costruttore o liberando risorse per qualsiasi altra attività.
  • Garantisce che tutte le attività vengano eseguite in modo efficiente poiché si occupa del processo di pulizia.
  • Nei casi in cui sono allocate molte variabili e strutture, l'uso di distruttori aiuterà a prevenire la perdita di memoria rilasciando risorse interne.
  • Si occupa delle variabili statiche e locali.

Limitazioni dei distruttori

  • I distruttori non possono accettare alcun parametro e inoltre non danno alcun valore di ritorno (nemmeno nullo).
  • L'ereditarietà non è consentita tramite i distruttori
  • Non è obbligatorio che un distruttore sia statico
  • Non è possibile fare riferimento a un indirizzo di un distruttore
  • Un oggetto che appartiene alla classe contenente il distruttore non può essere membro dell'Unione.
  • È obbligatorio che una funzione di distruttore abbia accesso al pubblico.

Conclusione

Come abbiamo visto, i distruttori che sono l'esatto inverso dei costruttori vengono utilizzati per distruggere un oggetto dopo che è stato utilizzato e non richiesto ulteriormente nel codice. In questo modo si assicura che ripulisca le risorse indesiderate lasciando spazio a risorse future. Questo viene fatto dichiarando la funzione __destruct () che verrà chiamata automaticamente da PHP alla fine dello script.

Articoli consigliati

Questa è una guida a Destructor in PHP. Qui discutiamo del funzionamento, dei vantaggi e dei limiti del distruttore in PHP insieme ad esempi. Puoi anche consultare i seguenti articoli per saperne di più -

  1. Matrice associativa in PHP
  2. Radice quadrata in PHP
  3. Funzioni in PHP
  4. Ottieni l'indirizzo IP in PHP

Categoria:

Sviluppo software