Introduktion till Destructor i PHP

PHP har infört en destruktormetod samma som den som finns på andra OOP-språk som C ++. Som namnet säger är en förstörare betydelsen av ett objekt när det förstörs eller när skriptet avbryts eller stoppas. Konstruktörer är medlemmar i specialfunktioner för de objekt som nyligen skapats. Destruktorer är exakt motsatsen till konstruktörer och de kallas när den skapade instansen raderas från minnet.

En konstruktör kallas av funktionen __construct () medan en destruktor kallas med funktionen __destruct () som PHP anropar automatiskt längst ner i skriptet. När det i princip inte finns några av referenserna till ett objekt i någon ordning, kallas en förstörare automatiskt.

Grundläggande syntax för att kalla en destruktor: funktionen __destruct (),

Syntax:

__destruct ( void ) : void

För att varje förstörare ska kallas måste det finnas en konstruktör innan den, som visas nedan:

<_?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 hanteras i princip av Garbage Collector som rensar ett objekt när det inte behövs längre. Det kan inte ta några argument som inmatning i motsats till konstruktören.

Denna metod används också för att rensa upp resurser och för att frigöra minnet för att rymma mer. Överbelastning kan inte utföras med förstörare och bara en enda förstörare kan existera i samma klass. En annan unik egenskap med det är att även om skriptet har stoppat dess körning med hjälp av ett exit-kommando kommer destruktorn fortfarande att kallas. Denna utgång () tillåter inte avstängningsmetoderna för kvarvarande att sluta.

Exempel på Destructor i PHP

Låt oss ta några exempel för att förstå destruktorn bättre:

Exempel 1

Detta är ett enkelt exempel där vi skapar en grundläggande konstruktorfunktion och sedan förstör samma genom att kalla destruktorfunktionen.

Koda:

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

Produktion:

Exempel 2

För detta exempel använder vi två variabler i konstruktorn; anställdas förnamn och efternamn och sedan förstör vi objektet Anställd precis innan PHP-koden slutar med att ringa förstöraren.

Koda:

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

Exempel 3

I det här exemplet ska vi se hur man hanterar en fil test_doc.txt som är ett förutsatt textdokument som ska finnas i samma arbetskatalog som huvudfilen. Se till att ta med lite text i test_doc.txt som måste visas som en del av koden.

fopen är den inbyggda funktionen som används för att öppna filen och fread är den funktion som används för att läsa innehållet i filen. Här kommer förstöraren att kallas för att stänga / förstöra filhandtaget.

Koda:

<_?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ämnts i koden, om vi avkoderar funktionen gc_collect_cycles () i mitten av skriptet får vi utdata enligt nedan:

Exempel 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öljande varning kastas om test_doc.txt inte skapas.

Fördelarna med Destruktorer

  • Destruktorer hjälper till att frigöra minnesallokering och ser till att det erforderliga utrymmet finns för nyskapade objekt av konstruktören eller frigör resurser för någon annan uppgift.
  • Se till att alla uppgifter körs effektivt eftersom det tar hand om saneringsprocessen.
  • I de fall där många variabler och strukturer tilldelas kommer användningen av förstörare att hjälpa till att förhindra minnesläckage genom att frigöra interna resurser.
  • Den tar hand om både statiska och lokala variabler.

Begränsningar av destruktörer

  • Destruktorer kan inte ta några parametrar och de ger inte heller något returvärde (inte ens ogiltigt).
  • Arv är inte tillåtet genom destruktorer
  • Det är inte obligatoriskt att en förstörare blir statisk
  • Det går inte att hänvisa till en destruktors adress
  • Ett objekt som tillhör klassen som innehåller förstöraren får inte vara fackmedlem.
  • Det är obligatoriskt att en destruktorfunktion ska ha allmänhetstillträde.

Slutsats

Som vi såg, används destruktorer som är de omvända konstruktörerna för att förstöra ett objekt efter att dess användning har gjorts och inte krävs ytterligare i koden. På så sätt säkerställs att det rensar upp oönskade resurser som ger utrymme för framtida resurser. Detta görs genom att deklarera funktionen __destruct () som automatiskt kommer att anropas av PHP vid skriptets slut.

Rekommenderade artiklar

Detta är en guide till Destructor i PHP. Här diskuterar vi funktionen, fördelarna och begränsningarna av destruktorn i PHP tillsammans med exempel. Du kan också titta på följande artiklar för att lära dig mer -

  1. Associative Array i PHP
  2. Square Root i PHP
  3. Funktioner i PHP
  4. Skaffa IP-adress i PHP

Kategori:

Mjukvaruutveckling