Introduksjon til Destructor i PHP

PHP har introdusert en destruktormetode på samme måte som den som finnes på andre OOP-språk som C ++. Som navnet sier, er en ødelegger betydningen av et objekt når det blir ødelagt eller når manuset blir avbrutt eller stoppet. Konstruktører er medlemmer av spesielle funksjoner for gjenstander som er nyopprettet. Destruktorer er det motsatte av konstruktører, og de kalles når den opprettede forekomsten blir slettet fra minnet.

En konstruktør kalles av funksjonen __construct (), mens en destruktor kalles ved å bruke funksjonen __destruct () som PHP automatisk kaller nederst i skriptet. Når det i utgangspunktet ikke er noen av referansene til et objekt i en hvilken som helst rekkefølge, blir det automatisk kalt en destruktør.

Grunnleggende syntaks for å kalle en destruktor: funksjonen __destruct (),

syntaks:

__destruct ( void ) : void

For at enhver destruktør skal kalles, må det være en konstruktør før den som vist nedenfor:

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

Working of Destructor in PHP

Destructor administreres i utgangspunktet av Garbage Collector som tømmer et objekt når det ikke er behov for det lenger. Det kan ikke ta noen argumenter som innspill i kontrast til konstruktøren.

Denne metoden brukes også til å rydde opp i ressurser og for å frigjøre minnet for å få plass til mer. Overbelastning kan ikke utføres med destruktører, og bare en eneste ødelegger kan eksistere i samme klasse. Et annet unikt trekk ved det er at selv om skriptet har stoppet utførelsen ved hjelp av en exit () -kommando, vil destruktoren fortsatt bli kalt. Denne avkjørselen () tillater ikke at resterende metodene for avslutning kan slutte.

Eksempler på Destructor i PHP

La oss ta noen eksempler for å forstå destructor bedre:

Eksempel 1

Dette er et enkelt eksempel der vi lager en grunnleggende konstruksjonsfunksjon og deretter ødelegger den ved å kalle destruktorfunksjonen.

Kode:

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

Produksjon:

Eksempel 2

For dette eksempelet bruker vi to variabler i konstruktøren; ansattes fornavn og etternavn og så ødelegger vi objektet Ansatt rett før PHP-koden slutter med å ringe destruktoren.

Kode:

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

Produksjon:

Eksempel 3

I dette eksemplet skal vi se hvordan du håndterer en fil test_doc.txt som er et forutsatt tekstdokument for å være til stede i samme arbeidskatalog som hovedfilen. Sørg for å ta med litt tekst i test_doc.txt som må vises som en del av koden.

fopen er den innebygde funksjonen som brukes til å åpne filen, og fread er funksjonen som brukes til å lese innholdet i filen. Her vil destruktoren bli kalt for å lukke / ødelegge filhåndtaket.

Kode:

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

Produksjon:

Som nevnt i koden, hvis vi koder for funksjonen gc_collect_cycles () i midten av skriptet, får vi utdata som nedenfor:

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

Produksjon:

Følgende advarsel blir kastet hvis test_doc.txt ikke er opprettet.

Fordeler med destruktører

  • Destruktører hjelper til med å frigjøre minnetildeling og sørger dermed for at den nødvendige plassen er til stede for nyopprettede objekter av konstruktøren eller frigjør ressurser til andre oppgaver.
  • Sikrer at alle oppgavene kjøres effektivt siden den tar seg av opprydningsprosessen.
  • I tilfeller hvor mange variabler og strukturer er tildelt, vil bruken av destruktører bidra til å forhindre minnelekkasje ved å frigjøre interne ressurser.
  • Den tar vare på både statiske og lokale variabler.

Begrensninger av destruktører

  • Destruktører kan ikke ta noen parametere, og de gir heller ingen returverdi (ikke engang ugyldig).
  • Arv er ikke tillatt gjennom destruktører
  • Det er ikke obligatorisk at en ødelegger skal være statisk
  • Det er ikke mulig å henvise til en adresse til en ødelegger
  • Et objekt som tilhører klassen som inneholder ødeleggeren, har ikke lov til å være fagforeningsmedlem.
  • Det er obligatorisk at en destruktorfunksjon skal ha offentlig tilgang.

Konklusjon

Som vi så, blir destruktører som er den nøyaktige omvendt av konstruktører brukt til å ødelegge et objekt etter at bruken er gjort og ikke nødvendig ytterligere i koden. Dermed sikrer du at det rydder opp i uønskede ressurser og gir plass til fremtidige ressurser. Dette gjøres ved å erklære __destruct () -funksjonen som automatisk vil bli kalt av PHP ved skriptets slutt.

Anbefalte artikler

Dette er en guide til Destructor i PHP. Her diskuterer vi funksjonen, fordelene og begrensningene til destruktor i PHP sammen med eksempler. Du kan også se på følgende artikler for å lære mer -

  1. Associative Array i PHP
  2. Square Root i PHP
  3. Funksjoner i PHP
  4. Få IP-adresse i PHP

Kategori:

Programvare utvikling