Introduktion til Destructor i PHP

PHP har introduceret en destruktormetode den samme som den, der findes på andre OOP-sprog som C ++. Som navnet hedder, er en destructor betydningen af ​​et objekt, når det ødelægges, eller når scriptet afbrydes eller stoppes. Konstruktører er medlemmer af specielle funktioner til de objektforekomster, der er oprettet nyligt. Destruktorer er det modsatte af konstruktører, og de kaldes, når den oprettede instans slettes fra hukommelsen.

En konstruktør kaldes af funktionen __construct (), mens en destruktor kaldes ved hjælp af funktionen __destruct (), som PHP kalder automatisk i bunden af ​​scriptet. Når der stort set ikke er nogen af ​​referencerne til et objekt i nogen rækkefølge, kaldes en destruktor automatisk.

Grundlæggende syntaks for at kalde en destruktor: Funktionen __destruct (),

Syntaks:

__destruct ( void ) : void

For hver destruktor, der skal kaldes, skal der 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
)
)
?>

Arbejde med Destructor i PHP

Destructor administreres dybest set af Garbage Collector, som rydder et objekt, når det ikke er nødvendigt mere. Den kan ikke tage nogen argumenter som dens input i modsætning til konstruktøren.

Denne metode bruges også til oprydning af ressourcer og til at frigøre hukommelsen til at rumme mere. Overbelastning kan ikke udføres med destruktører, og kun en enkelt destruktor kan eksistere i samme klasse. Et andet unikt træk ved det er, at selv hvis scriptet har stoppet udførelsen ved hjælp af en exit () -kommando, vil destruktoren stadig kaldes. Denne exit () tillader ikke, at resterende metoder til nedlukning kan afslutte.

Eksempler på Destructor i PHP

Lad os tage nogle eksempler for at forstå destruktoren bedre:

Eksempel 1

Dette er et simpelt eksempel, hvor vi opretter en grundlæggende konstruktorfunktion og derefter ødelægger den ved at kalde destruktorfunktionen.

Kode:

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

Produktion:

Eksempel 2

I dette eksempel bruger vi to variabler i konstruktøren; medarbejderens fornavn og efternavn, og så ødelægger vi objektet Medarbejder lige inden PHP-koden slutter med at kalde 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();
?>

Produktion:

Eksempel 3

I dette eksempel skal vi se, hvordan man håndterer en fil test_doc.txt, som er et forudsat tekstdokument, der skal være til stede i det samme arbejdsmappe som hovedfilen. Sørg for at medtage noget tekst i test_doc.txt, der skal vises som en del af koden.

fopen er den indbyggede funktion, der bruges til at åbne filen, og fread er den funktion, der bruges til at læse indholdet af filen. Her kaldes destruktoren for at lukke / ødelægge filhåndtaget.

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

Produktion:

Som nævnt i koden, får vi output som nedenunder, hvis vi fjerner komponenten gc_collect_cycles () i midten af ​​scriptet:

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

Produktion:

Følgende advarsel kastes, hvis test_doc.txt ikke oprettes.

Fordelene ved Destruktorer

  • Destruktorer hjælper med at frigøre hukommelsesallokering og sørger således for, at den krævede plads er til stede for nyoprettede objekter af konstruktøren eller frigør ressourcer til enhver anden opgave.
  • Sikrer, at alle opgaver kører effektivt, da det tager sig af oprydningsprocessen.
  • I tilfælde, hvor mange variabler og strukturer er tildelt, vil brugen af ​​destruktorer hjælpe med at forhindre hukommelseslækage ved at frigive interne ressourcer.
  • Det tager sig af både statiske og lokale variabler.

Begrænsninger af destruktører

  • Destruktorer kan ikke tage nogen parametre, og de giver heller ingen returneringsværdi (ikke engang ugyldig).
  • Arv er ikke tilladt gennem destruktører
  • Det er ikke obligatorisk, at en destruktor er statisk
  • Det er ikke muligt at henvise til en destruktors adresse
  • Et objekt, der hører til klassen, der indeholder destruktoren, må ikke være et fagforeningsmedlem.
  • Det er obligatorisk, at en destruktorfunktion skal have offentlig adgang.

Konklusion

Som vi så, bruges destruktører, der er den nøjagtige inverse af konstruktører, til at ødelægge en genstand, efter at dens brug er udført og ikke krævet yderligere i koden. Dermed sikres det, at det renser uønskede ressourcer, der giver plads til fremtidige ressourcer. Dette gøres ved at erklære funktionen __destruct (), som automatisk kaldes af PHP ved scriptets slutning.

Anbefalede artikler

Dette er en guide til Destructor i PHP. Her diskuterer vi arbejder, fordele og begrænsninger af destruktor i PHP sammen med eksempler. Du kan også se på de følgende artikler for at lære mere -

  1. Associative Array i PHP
  2. Firkantet rod i PHP
  3. Funktioner i PHP
  4. Hent IP-adresse i PHP

Kategori:

Softwareudvikling