Romboló a PHP-ben A PHP pusztítójának teljes útmutatója, példákkal

• Bevezetés a pusztítóhoz a PHP-ben

Bevezetés a pusztítóhoz a PHP-ben

A PHP egy olyan pusztító módszert vezetett be, mint amely más OOP nyelveken, mint például a C ++. Ahogy a név is kimondja, a pusztító az objektum jelentése, amikor azt megsemmisítik, vagy amikor a szkript megszakad vagy leáll. A konstruktorok az újonnan létrehozott objektumpéldányok speciális funkcióinak tagjai. A pusztítók pontosan ellentétesek a konstruktorokkal, és akkor hívják őket, amikor a létrehozott példányt törlik a memóriából.

A konstruktort az __construct () függvény hívja, míg a pusztítót az __destruct () függvény segítségével hívják, amelyet a PHP automatikusan meghív a szkript alján. Ha alapvetően egyetlen objektumra sem marad semmilyen sorrendben, akkor automatikusan elhívják a pusztítót.

Alapszintaxis a pusztító hívására: Az __destruct () függvény,

Szintaxis:

__destruct ( void ) : void

Minden romboló behívásához előbb építőnek kell lennie, az alábbiak szerint:

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

Destructor működése a PHP-ben

A pusztítót alapvetően a Szemétgyűjtő kezeli, amely egy tárgyat megtisztít, amikor már nincs rá szüksége. Semmi érvet nem fogadhat el, mivel hozzájárul ellentétben a kivitelezővel.

Ezt a módszert az erőforrások tisztítására és a memória felszabadítására is használják, hogy többet tárolhassunk. A túlterhelés nem végezhető destruktúrákkal, ugyanabban az osztályban csak egyetlen destruktor létezhet. Egy másik egyedülálló tulajdonsága, hogy még ha a szkript is leállította a végrehajtását az exit () parancs segítségével, a rombolót továbbra is hívják. Ez a kilépés () nem teszi lehetővé a maradék leállítási módszerek kilépését.

Példák a PHP pusztítójára

Vegyünk néhány példát a pusztító jobb megértésére:

1. példa

Ez egy egyszerű példa, amikor létrehozunk egy alapvető konstruktorfüggvényt, majd ezt megsemmisítjük a pusztító funkció hívásával.

Kód:

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

Kimenet:

2. példa

Ebben a példában két változót használunk az építőben; az alkalmazott vezeték- és utóneve, majd a pusztító felhívásával elpusztítjuk a Munkavállaló objektumot, mielőtt a PHP-kód véget ér.

Kód:

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

Kimenet:

3. példa

Ebben a példában megvizsgáljuk, hogyan kell kezelni a test_doc.txt fájlt, amely előfeltétele a szöveges dokumentumnak, hogy ugyanabban a munkakönyvtárban legyen, mint a fő fájl. Ne felejtsen el belefoglalni egy szöveget a test_doc.txt fájlba, amelyet a kód részeként kell megjeleníteni.

A fopen a fájl megnyitásához használt beépített függvény, a fread pedig a fájl tartalmának olvasásához használt funkció. Itt a pusztítót felhívják a fájlkezelő bezárására / megsemmisítésére.

Kód:

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

Kimenet:

Mint a kódban említettem, ha a gc_collect_cycles () függvényt a szkript közepén nem veszünk észre, akkor az alábbiak szerint kapjuk a kimenetet:

4. példa

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

Kimenet:

A következő figyelmeztetés eldobásra kerül, ha a test_doc.txt nem lett létrehozva.

A pusztítók előnyei

• A desztruktorok segítenek a memóriaelosztás felszabadításában, így biztosítva, hogy az építő által az újonnan létrehozott objektumok számára rendelkezésre álljon-e a szabad hely, vagy bármilyen más feladathoz szabadítson fel erőforrásokat.
• Biztosítja, hogy az összes feladat hatékonyan működjön, mivel gondoskodik a tisztítási folyamatról.
• Azokban az esetekben, amikor sok változó és struktúra van kiosztva, a pusztítók használata a belső erőforrások felszabadításával segít megelőzni a memória szivárgását.
• Mind statikus, mind lokális változókkal foglalkozik.

A pusztítók korlátozásai

• A pusztítók nem tudnak paramétereket venni, és nem adnak semmilyen visszatérési értéket (még érvénytelennek sem is).
• Az öröklés nem megengedett a destruktorok révén
• Nem kötelező, hogy a pusztító statikus legyen
• A pusztító címére történő hivatkozás nem lehetséges
• A pusztítót tartalmazó osztályba tartozó objektumok nem lehetnek szakszervezeti tagok.
• Kötelező, hogy a pusztító funkció nyilvános hozzáféréssel rendelkezzen.

Következtetés

Mint láttuk, a destruktúrák, amelyek a konstruktorok pontos inverze, felhasználásra kerülnek egy objektum megsemmisítése után, miután felhasználták, és erre a kódban nincs szükség. Így biztosítva, hogy megtisztítsa a nem kívánt erőforrásokat, lehetővé téve a jövőbeli források számára helyet. Ezt úgy végezzük, hogy deklaráljuk az __destruct () függvényt, amelyet a PHP automatikusan meghív a szkript végén.

Ajánlott cikkek

Ez a PHP Destructor útmutatója. Itt a PHP pusztítójának működését, előnyeit és korlátozásait tárgyaljuk példákkal együtt. A következő cikkeket is megnézheti további információkért -

1. Asszociatív tömb a PHP-ben
2. Négyzetgyökér a PHP-ben
3. Funkciók a PHP-ben
4. IP-címet szerezhet a PHP-ben