Johdatus PHP: n tuhoajaan

PHP on ottanut käyttöön tuhoajamenetelmän, jota käytetään muilla OOP-kielillä, kuten C ++. Kuten nimestä ilmenee, tuhoajalla tarkoitetaan objektia, kun se tuhotaan tai kun skripti keskeytetään tai pysäytetään. Rakentajat ovat jäseniä erityistoiminnoille vastikään luotujen esineiden ilmentymiä varten. Destruktorit ovat täysin vastakkaisia ​​rakentajille ja niitä kutsutaan, kun luotu ilmentymä poistetaan muistista.

Rakentaja kutsutaan __construct () -toiminnolla, kun taas hävittäjää kutsutaan käyttämällä __destruct () -toimintoa, jota PHP kutsuu automaattisesti komentosarjan alaosassa. Kun objektiivista viitteestä ei periaatteessa ole jäljellä missä tahansa järjestyksessä, hävittäjä kutsutaan automaattisesti.

Perussyntaksi hävittäjän kutsumiseksi: __destruct () -toiminto,

Syntaksi:

__destruct ( void ) : void

Jokaisen hävittäjän kutsumiseksi ennen sitä on oltava rakentaja, kuten alla on esitetty:

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

Hävittäjän toiminta PHP: ssä

Hävittäjää hoitaa periaatteessa jätekeräin, joka puhdistaa esineen, kun sitä ei enää tarvita. Sitä vastoin rakentajaa ei voida ottaa mitään argumentteja.

Tätä menetelmää käytetään myös resurssien puhdistamiseen ja muistin vapauttamiseen lisää tilaa varten. Ylikuormitusta ei voida suorittaa destruktoreilla, ja samassa luokassa voi olla vain yksi tuhoaja. Toinen ainutlaatuinen piirre on, että vaikka komentosarja olisi lopettanut sen suorittamisen exit () -komennon avulla, hävittäjää kutsutaan silti. Tämä poistuminen () ei salli jäljellä olevia sammutusmenetelmiä lopettaa.

Esimerkkejä tuhoajasta PHP: ssä

Otetaanpa joitain esimerkkejä ymmärtääksesi hävittäjää paremmin:

Esimerkki # 1

Tämä on yksinkertainen esimerkki, jossa luomme perusrakentajatoiminnon ja tuhoamme sen sitten kutsumalla hävittäjätoimintoon.

Koodi:

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

lähtö:

Esimerkki 2

Tässä esimerkissä käytämme kahta muuttujaa konstruktorissa; työntekijän etunimi ja sukunimi ja tuhoamme sitten objektin Työntekijä juuri ennen PHP-koodin päättymistä soittamalla tuhoajalle.

Koodi:

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

lähtö:

Esimerkki 3

Tässä esimerkissä näemme kuinka käsitellä tiedostoa test_doc.txt, joka on ennakkoedellytys tekstiasiakirjalle, joka on läsnä samassa työhakemistossa kuin päätiedosto. Muista sisällyttää testi_doc.txt-tiedostoon teksti, joka on näytettävä osana koodia.

fopen on sisäinen toiminto, jota käytetään tiedoston avaamiseen, ja fread on toiminto, jota käytetään tiedoston sisällön lukemiseen. Tätä varten hävittäjää kutsutaan sulkemaan / tuhoamaan tiedostonkahva.

Koodi:

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

lähtö:

Kuten koodissa mainittiin, jos kommentoimme gc_collect_cycles () -funktiota komentosarjan keskellä, saamme tulosteen seuraavasti:

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

lähtö:

Seuraava varoitus heitetään, jos testi_doc.txt-tiedostoa ei luoda.

Tuhoajien edut

  • Destructors auttaa vapauttamaan muistin allokointia varmistaen siten, että rakentajan vastikään luomille objekteille on vaadittu tila tai vapauttamalla resursseja muihin tehtäviin.
  • Varmistaa, että kaikki tehtävät suoritetaan tehokkaasti, koska se huolehtii puhdistusprosessista.
  • Tapauksissa, joissa allokoidaan monia muuttujia ja rakenteita, destruktorien käyttö auttaa estämään muistin vuotoa vapauttamalla sisäisiä resursseja.
  • Se hoitaa sekä staattiset että paikalliset muuttujat.

Hävittäjien rajoitukset

  • Destruktorit eivät voi ottaa mitään parametrejä, eivätkä ne myöskään anna paluuarvoa (edes tyhjiä).
  • Perintö ei ole sallittua tuhoajien avulla
  • Tuhoaja ei ole pakollinen
  • Tuhoajan osoitteeseen viittaaminen ei ole mahdollista
  • Objektin, joka kuuluu luokkaan, joka sisältää tuhoajan, ei saa olla liiton jäsen.
  • Hävittäjätoiminnolla on oltava julkinen pääsy.

johtopäätös

Kuten näimme, rakentajien tarkkaa käänteistä käyttäviä rakentajia käytetään objektin tuhoamiseen sen käytön jälkeen, eikä niitä vaadita enää koodiin. Näin varmistetaan, että se puhdistaa ei-toivotut resurssit ja antaa tilaa tuleville resursseille. Tämä tehdään julistamalla __destruct () -toiminto, jota PHP kutsuu automaattisesti komentosarjan lopussa.

Suositellut artikkelit

Tämä on PHP: n Destructor-opas. Tässä keskustellaan PHP: n hävittäjän toiminnasta, eduista ja rajoituksista esimerkkeinä. Voit myös katsoa seuraavia artikkeleita saadaksesi lisätietoja -

  1. Yhdistävä taulukko PHP: ssä
  2. Neliöjuuri PHP: ssä
  3. Toiminnot PHP: ssä
  4. Hanki IP-osoite PHP: ssä

Luokka:

Ohjelmistokehitys