Sissejuhatus hävitajasse PHP-s

PHP on võtnud kasutusele hävitusmeetodi, mis on sama mis teistes OOP keeltes, näiteks C ++. Nagu nimigi ütleb, on hävitaja objekti tähendus, kui see hävitatakse või skript katkestatakse või peatatakse. Ehitajad on spetsiaalselt loodud objektide esinemisfunktsioonide liikmed. Destruktorid on täpselt konstruktorite vastandid ja neid kutsutakse siis, kui loodud eksemplari mälust kustutatakse.

Ehitajat kutsutakse funktsiooni __construct () abil, hävitajat kutsutakse aga funktsiooni __destruct () abil, mida PHP kutsub skripti allosas automaatselt. Kui põhimõtteliselt pole ühtegi viidet mingisse järjekorda objektile jäetud, kutsutakse hävitaja automaatselt.

Põhiline süntaks hävitaja kutsumiseks: funktsioon __destruct (),

Süntaks:

__destruct ( void ) : void

Iga hävitaja kutsumiseks peab selle ees olema konstruktor, nagu allpool näidatud:

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

Hävitaja töö PHP-s

Hävitajat juhib põhimõtteliselt prügikoguja, kes puhastab objekti, kui seda enam pole vaja. Vastupidiselt ehitajale ei saa ta kasutada ühtegi argumenti.

Seda meetodit kasutatakse ka ressursside puhastamiseks ja mälu vabastamiseks, et rohkem ruumi mahutada. Ülekoormamist ei saa destruktoritega teha ja samas klassis võib olla ainult üks destruktor. Veel üks ainulaadne omadus on see, et isegi kui skript on käsu exit () abil selle täitmise peatanud, kutsutakse hävitaja ikkagi. See väljumine () ei võimalda järelejäänud sulgemismeetodeid sulgeda.

Hävitaja näited PHP-s

Võtame mõned näited, kuidas hävitajat paremini mõista:

Näide nr 1

See on lihtne näide, kus loome põhilise konstruktori funktsiooni ja hävitame selle siis hävitaja funktsiooni kutsumisega.

Kood:

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

Väljund:

Näide 2

Selle näite puhul kasutame konstruktoris kahte muutujat; töötaja ees- ja perekonnanimi ning siis hävitame objekti Töötaja vahetult enne PHP koodi lõppemist hävitajale helistades.

Kood:

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

Väljund:

Näide 3

Selles näites näeme, kuidas käsitleda faili test_doc.txt, mis on eeltingimuseks vajalik tekstidokument, mis asub põhifailiga samas töökataloogis. Lisage test_doc.txt-le kindlasti mõni tekst, mis tuleb koodi osana kuvada.

fopen on faili avamiseks kasutatav sisseehitatud funktsioon ja fread on faili sisu lugemiseks kasutatav funktsioon. Hävitaja kutsutakse faili käepide sulgema / hävitama.

Kood:

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

Väljund:

Nagu koodis mainiti, saame skripti keskel funktsiooni gc_collect_cycles () kommentaari märkimata järgmiselt:

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

Väljund:

Kui test_doc.txt pole loodud, visatakse järgmine hoiatus.

Hävitajate eelised

  • Destruktorid aitavad mälu eraldamist vabastada, veendudes, et konstruktori poolt loodud uute objektide jaoks on vajalikku ruumi või vabastatakse ressursse muudeks toiminguteks.
  • Tagab kõigi toimingute tõhusa toimimise, kuna see hoolitseb puhastusprotsessi eest.
  • Juhtudel, kui on eraldatud palju muutujaid ja struktuure, aitab destruktorite kasutamine mälu lekkeid vältida, vabastades sisemisi ressursse.
  • See hoolitseb nii staatiliste kui ka lokaalsete muutujate eest.

Hävitajate piirangud

  • Hävitajad ei saa võtta ühtegi parameetrit ja ka nad ei anna mingit tagastamisväärtust (isegi mitte tühist).
  • Pärimine pole hävitajate kaudu lubatud
  • Hävitaja pole staatiline
  • Hävitaja aadressile viitamine pole võimalik
  • Objekti, mis kuulub klassi, mis sisaldab hävitajat, ei tohi olla ametiühingu liige.
  • Hävitaja funktsioonil peab olema avalik juurdepääs.

Järeldus

Nagu nägime, kasutatakse hävitajaid, mis on konstruktorite täpne pöördväärtus, objekti hävitamiseks pärast selle kasutamist ja neid pole koodis täiendavalt vaja. Nii tagate, et see puhastab soovimatud ressursid, jättes ruumi tulevastele ressurssidele. Selleks kuulutatakse välja funktsioon __destruct (), mida PHP kutsub skripti lõpus automaatselt.

Soovitatavad artiklid

See on juhend hävitajale PHP-s. Siin käsitleme hävitaja tööd, eeliseid ja piiranguid PHP-s koos näidetega. Lisateabe saamiseks võite vaadata ka järgmisi artikleid -

  1. Assotsiatiivne massiiv PHP-s
  2. Ruutjuur PHP-s
  3. Funktsioonid PHP-s
  4. Hankige IP-aadress PHP-s

Kategooria:

Tarkvaraarendus