Pemusnah dalam PHP

Destructor ialah fungsi yang digunakan untuk memadam contoh objek yang dicipta oleh pembina untuk kelas tertentu, sebagai sebahagian daripada ciri fungsinya. Setiap kali pembina digunakan dalam program PHP, ia tidak wajib mempunyai fungsi pemusnah untuk melengkapkan fungsinya. Tetapi ia dianggap sebagai amalan yang baik untuk mempunyai pemusnah dalam program di mana pembina dipanggil. Selain itu, kaedah ini tidak dipanggil secara khusus untuk pelaksanaan, sebaliknya ia dilaksanakan apabila kawalan tidak lagi menemui rujukan berfungsi kepada kaedah pembina.

Sintaks asas untuk memanggil pemusnah: Fungsi __destruct(),

IKLAN Kursus Popular dalam kategori ini PEMBANGUN PHP - Pengkhususan | 8 Siri Kursus | 3 Ujian Olok-olok

Mulakan Kursus Pembangunan Perisian Percuma Anda

Pembangunan web, bahasa pengaturcaraan, ujian perisian & lain-lain

Sintaks:

__destruct ( void ) : void

Untuk setiap pemusnah dipanggil, mesti ada pembina sebelum ia seperti yang ditunjukkan di bawah:

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

Kerja Pemusnah dalam PHP

Destructor pada asasnya diuruskan oleh Garbage Collector yang membersihkan objek apabila ia tidak diperlukan lagi. Ia tidak boleh mengambil sebarang hujah sebagai inputnya berbeza dengan pembina.

Kaedah ini juga digunakan untuk membersihkan sumber dan membebaskan memori untuk menampung lebih banyak. Lebihan muatan tidak boleh dilakukan dengan pemusnah dan hanya pemusnah tunggal boleh wujud dalam kelas yang sama. Satu lagi ciri uniknya ialah walaupun skrip telah menghentikan pelaksanaannya dengan bantuan perintah exit(), pemusnah masih akan dipanggil. Exit() ini tidak akan membenarkan kaedah penutupan yang tinggal daripada berhenti.

Contoh Destructor dalam PHP

Mari kita ambil beberapa contoh untuk memahami pemusnah dengan lebih baik:

Contoh #1

Ini ialah contoh mudah di mana kita mencipta fungsi pembina asas dan kemudian memusnahkan fungsi yang sama dengan memanggil fungsi pemusnah.

Kod:

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

Output:

Contoh #2

Untuk contoh ini kami menggunakan dua pembolehubah dalam pembina; nama pertama dan nama keluarga pekerja dan kemudian kami memusnahkan objek Pekerja sejurus sebelum kod PHP tamat dengan memanggil pemusnah.

Kod:

<?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...<br/>";
$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 . "<br/>";
}
}
// Class object declaration
$harry = new Employee("Harry", "Potter");
$harry->showName();
?>

Output:

Contoh #3

Dalam contoh ini, kita akan melihat cara mengendalikan fail test_doc.txt yang merupakan dokumen teks pra-syarat untuk hadir dalam direktori kerja yang sama dengan fail utama. Pastikan anda memasukkan beberapa teks dalam test_doc.txt yang perlu dipaparkan sebagai sebahagian daripada kod.

fopen ialah fungsi terbina dalam yang digunakan untuk membuka fail dan fread ialah fungsi yang digunakan untuk membaca kandungan fail. Di sini pemusnah akan dipanggil untuk menutup/memusnahkan pemegang fail.

Kod:

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

Output:

Seperti yang dinyatakan dalam kod, jika kita menyahkomen fungsi gc_collect_cycles() di tengah-tengah skrip, kita mendapat output seperti di bawah:

Contoh #4

Kod:

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

Output:

Amaran berikut dilemparkan jika test_doc.txt tidak dibuat.

Kelebihan Pemusnah

• Pemusnah membantu dalam mengosongkan peruntukan memori sekali gus memastikan ruang yang diperlukan hadir untuk objek yang baru dicipta oleh pembina atau membebaskan sumber untuk sebarang tugas lain.
• Memastikan semua tugas berjalan dengan cekap kerana ia menjaga proses pembersihan.
• Dalam kes di mana banyak pembolehubah dan struktur diperuntukkan, penggunaan pemusnah akan membantu mencegah kebocoran memori dengan melepaskan sumber dalaman.
• Ia menjaga pembolehubah Statik dan setempat.

Batasan Pemusnah

• Pemusnah tidak boleh mengambil sebarang parameter dan mereka juga tidak memberikan sebarang nilai pulangan (walaupun batal).
• Pewarisan tidak dibenarkan melalui pemusnah
• Tidak wajib bahawa pemusnah akan menjadi statik
• Merujuk kepada alamat pemusnah tidak boleh dilakukan
• Objek yang tergolong dalam kelas yang mengandungi pemusnah tidak dibenarkan menjadi ahli kesatuan.
• Adalah wajib bahawa fungsi pemusnah harus mempunyai akses awam.

Kesimpulan

Seperti yang kita lihat, pemusnah sebagai songsang tepat bagi pembina digunakan untuk memusnahkan objek selepas penggunaannya dilakukan dan tidak diperlukan lagi dalam kod. Dengan itu memastikan ia membersihkan sumber yang tidak diingini yang membolehkan ruang untuk sumber masa depan. Ini dilakukan dengan mengisytiharkan fungsi __destruct() yang akan dipanggil oleh PHP secara automatik pada penghujung skrip.

Atas ialah kandungan terperinci Pemusnah dalam PHP. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!