Introducción a Destructor en PHP

PHP ha introducido un método destructor igual al presente en otros lenguajes OOP como C ++. Como su nombre lo indica, un destructor es el significado de un objeto cuando se destruye o cuando el script se interrumpe o se detiene. Los constructores son miembros de funciones especiales para las instancias de objeto que se crean recientemente. Los destructores son exactamente lo contrario de los constructores y se llaman cuando la instancia creada se elimina de la memoria.

La función __construct () llama a un constructor mientras que se llama a un destructor utilizando la función __destruct () a la que PHP llama automáticamente en la parte inferior del script. Cuando básicamente no queda ninguna de las referencias a un objeto en ningún orden, se llama automáticamente a un destructor.

Sintaxis básica para llamar a un destructor: la función __destruct (),

Sintaxis:

__destruct ( void ) : void

Para que se llame a cada destructor, debe haber un constructor como se muestra a continuación:

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

Trabajo de Destructor en PHP

Básicamente, Destructor es administrado por el recolector de basura que borra un objeto cuando ya no es necesario. No puede tomar ningún argumento como su entrada en contraste con el constructor.

Este método también se utiliza para limpiar recursos y liberar la memoria para acomodar más. La sobrecarga no se puede realizar con destructores y solo puede existir un único destructor en la misma clase. Otra característica única es que incluso si el script ha detenido su ejecución con la ayuda de un comando exit (), se seguirá llamando al destructor. Esta salida () no permitirá que se salgan los métodos de apagado restantes.

Ejemplos de Destructor en PHP

Tomemos algunos ejemplos para comprender mejor el destructor:

Ejemplo 1

Este es un ejemplo simple en el que estamos creando una función constructora básica y luego destruyendo la misma llamando a la función destructora.

Código:

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

Salida:

Ejemplo # 2

Para este ejemplo estamos usando dos variables en el constructor; nombre y apellido del empleado y luego estamos destruyendo el objeto Empleado justo antes de que el código PHP termine llamando al destructor.

Código:

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

Salida:

Ejemplo # 3

En este ejemplo, veremos cómo manejar un archivo test_doc.txt que es un documento de texto de requisito previo para estar presente en el mismo directorio de trabajo que el archivo principal. Asegúrese de incluir texto en test_doc.txt que debe mostrarse como parte del código.

fopen es la función incorporada utilizada para abrir el archivo y fread es la función utilizada para leer el contenido del archivo. Aquí se llamará al destructor para cerrar / destruir el identificador de archivo.

Código:

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

Salida:

Como se menciona en el código, si descomentamos la función gc_collect_cycles () en el centro del script obtenemos la salida de la siguiente manera:

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

Salida:

Se genera la siguiente advertencia si test_doc.txt no se crea.

Ventajas de los destructores

  • Los destructores ayudan a liberar la asignación de memoria, asegurándose de que el espacio requerido esté presente para los objetos recién creados por el constructor o liberando recursos para cualquier otra tarea.
  • Asegura que todas las tareas se ejecuten de manera eficiente, ya que se encarga del proceso de limpieza.
  • En los casos en que se asignan muchas variables y estructuras, el uso de destructores ayudará a evitar pérdidas de memoria al liberar recursos internos.
  • Se ocupa de las variables estáticas y locales.

Limitaciones de los destructores

  • Los destructores no pueden tomar ningún parámetro y tampoco dan ningún valor de retorno (ni siquiera nulo).
  • La herencia no está permitida a través de destructores
  • No es obligatorio que un destructor sea estático
  • No es posible hacer referencia a una dirección de un destructor
  • Un objeto que pertenece a la clase que contiene el destructor no puede ser miembro de la unión.
  • Es obligatorio que una función destructora tenga acceso público.

Conclusión

Como vimos, los destructores, que son el inverso exacto de los constructores, se usan para destruir un objeto después de que se hace su uso y no se requieren más en el código. De este modo, se garantiza que limpia los recursos no deseados y deja espacio para recursos futuros. Esto se hace declarando la función __destruct () que PHP invocará automáticamente al final del script.

Artículos recomendados

Esta es una guía para Destructor en PHP. Aquí discutimos el funcionamiento, las ventajas y las limitaciones de destructor en PHP junto con ejemplos. También puede consultar los siguientes artículos para obtener más información:

  1. Matriz asociativa en PHP
  2. Raíz cuadrada en PHP
  3. Funciones en PHP
  4. Obtener dirección IP en PHP

Categoría:

Desarrollo de software