Introdução ao Destructor em PHP

O PHP introduziu um método destruidor igual ao presente em outras linguagens OOP como C ++. Como o nome indica, um destruidor é o significado de um objeto quando ele é destruído ou quando o script é interrompido ou parado. Construtores são membros de funções especiais para as instâncias de objetos que são criadas recentemente. Destruidores são exatamente o oposto de construtores e são chamados quando a instância criada é excluída da memória.

Um construtor é chamado pela função __construct () enquanto um destruidor é chamado usando a função __destruct () que o PHP chama automaticamente na parte inferior do script. Quando basicamente não resta nenhuma referência a um objeto em nenhuma ordem, um destruidor é chamado automaticamente.

Sintaxe básica para chamar um destruidor: A função __destruct (),

Sintaxe:

__destruct ( void ) : void

Para que todo destruidor seja chamado, deve haver um construtor antes dele, como mostrado abaixo:

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

Trabalho de destruidor em PHP

O destruidor é basicamente gerenciado pelo Garbage Collector, que limpa um objeto quando não é mais necessário. Ele não pode aceitar argumentos como entrada em contraste com o construtor.

Esse método também é usado para limpar recursos e liberar memória para acomodar mais. A sobrecarga não pode ser executada com destruidores e apenas um único destruidor pode existir na mesma classe. Outra característica exclusiva é que, mesmo que o script tenha interrompido sua execução com a ajuda de um comando exit (), o destruidor ainda será chamado. Esta saída () não permitirá que os métodos de encerramento restantes sejam encerrados.

Exemplos de destruidor em PHP

Vamos dar alguns exemplos para entender melhor o destruidor:

Exemplo 1

Este é um exemplo simples em que estamos criando uma função construtora básica e, em seguida, destruindo a mesma chamando a função destruidora.

Código:

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

Resultado:

Exemplo 2

Neste exemplo, estamos usando duas variáveis ​​no construtor; nome e sobrenome do funcionário e, em seguida, estamos destruindo o objeto Employee pouco antes do código PHP terminar chamando o destruidor.

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

Resultado:

Exemplo 3

Neste exemplo, veremos como lidar com um arquivo test_doc.txt que é um documento de texto obrigatório para estar presente no mesmo diretório de trabalho que o arquivo principal. Certifique-se de incluir algum texto no test_doc.txt que precisa ser exibido como parte do código.

fopen é a função interna usada para abrir o arquivo e fread é a função usada para ler o conteúdo do arquivo. Aqui, o destruidor será chamado para fechar / destruir o arquivo.

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

Resultado:

Como mencionado no código, se descomentarmos a função gc_collect_cycles () no centro do script, obtemos a saída como abaixo:

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

Resultado:

O seguinte aviso será lançado se test_doc.txt não for criado.

Vantagens dos destruidores

  • Os destruidores ajudam a liberar a alocação de memória, garantindo que o espaço necessário esteja presente para objetos recém-criados pelo construtor ou liberando recursos para qualquer outra tarefa.
  • Garante que todas as tarefas sejam executadas com eficiência, pois cuida do processo de limpeza.
  • Nos casos em que muitas variáveis ​​e estruturas são alocadas, o uso de destruidores ajudará a impedir o vazamento de memória, liberando recursos internos.
  • Ele cuida de variáveis ​​estáticas e locais.

Limitações de destruidores

  • Os destruidores não podem aceitar nenhum parâmetro e também não fornecem nenhum valor de retorno (nem mesmo nulo).
  • A herança não é permitida através de destruidores
  • Não é obrigatório que um destruidor seja estático
  • Não é possível fazer referência ao endereço de um destruidor
  • Um objeto que pertence à classe que contém o destruidor não pode ser um membro da união.
  • É obrigatório que uma função destruidora tenha acesso público.

Conclusão

Como vimos, os destruidores que são exatamente o inverso dos construtores são usados ​​para destruir um objeto depois que seu uso é feito e não é mais necessário no código. Assegurando assim que ele limpa recursos indesejados, permitindo espaço para recursos futuros. Isso é feito declarando a função __destruct () que será chamada pelo PHP automaticamente no final do script.

Artigos recomendados

Este é um guia para o Destructor em PHP. Aqui discutimos o trabalho, vantagens e limitações do destruidor no PHP, juntamente com exemplos. Você também pode consultar os seguintes artigos para saber mais -

  1. Matriz associativa em PHP
  2. Raiz quadrada em PHP
  3. Funções em PHP
  4. Obter endereço IP em PHP

Categoria:

Desenvolvimento de software