PHP 8.1.0 RC 4 available for testing

Construtores e Destrutores

Construtores

__construct(mixed ...$values = ""): void

O PHP permite aos desenvolvedores declararem métodos construtores para as classes. Classes que tem um método construtor chamam o método a cada objeto recém criado, sendo apropriado para qualquer inicialização que o objeto necessite antes de ser utilizado.

Nota: Construtores pais não são chamados implicitamente se a classe filha define um construtor. Para executar o construtor da classe pai, uma chamada a parent::__construct() dentro do construtor da classe filha é necessária. Se a classe filha não definir um construtor, será herdado da classe pai como um método normal (se não foi declarado como privado).

Exemplo #1 Construtoras em herança

<?php
class BaseClass {
    function 
__construct() {
        print 
"In BaseClass constructor\n";
    }
}

class 
SubClass extends BaseClass {
    function 
__construct() {
        
parent::__construct();
        print 
"In SubClass constructor\n";
    }
}

class 
OtherSubClass extends BaseClass {
    
// inherits BaseClass's constructor
}

// In BaseClass constructor
$obj = new BaseClass();

// In BaseClass constructor
// In SubClass constructor
$obj = new SubClass();

// In BaseClass constructor
$obj = new OtherSubClass();
?>

Diferente de outros métodos, __construct() não precisa seguir as regras usuais de compatibilidade de assinatura em objetos derivados.

Construtores são métodos ordinários que são chamados durante a criação do objeto correspondente. Eles podem definir um número arbitrários de argumentos, quais podem ser obrigatórios, podem ter um tipo, e podem ter valores padrão. Argumentos de construtores são informados dentro de parênteses depois do nome da classe.

Exemplo #2 Utilizando argumentos de construtor

<?php
class Point {
    protected 
int $x;
    protected 
int $y;

    public function 
__construct(int $xint $y 0) {
        
$this->$x;
        
$this->$y;
    }
}

// Passagem de ambos os argumentos.
$p1 = new Point(45);
// Passar somente o argumento obrigatório, $y terá o valor padrão zero.
$p2 = new Point(4);
// Com parâmetros nomeados (a partir do PHP 8.0):
$p3 = new Point(y5x4);
?>

Se a classe não tem construtor, ou o construtor não tem argumentos obrigatórios, o parêntesis pode ser omitido.

Construtores obsoletos

Anteriormente ao PHP 8.0.0 as classes no namespace global interpretam um método com o mesmo nome da classe como sendo um construtor válido. Essa sintaxe é obsoleta, e gerará um erro E_DEPRECATED embora ainda continue funcionando como um construtor. Se ambos o __construct() e um método homônimo da classe estiverem definidos, __construct() que será chamado.

Em classes dentro de namespaces, ou quaisquer classes a partir do PHP 8, um método homônimo ao nome da classe não tem um significado especial.

Sempre utilize __construct() em novos códigos.

Promoção de propriedades no construtor

A partir do PHP 8, parâmetros de construtores podem ser promovidos a uma propriedade do objeto. Isto é bastante comum quando parâmetros do construtor de serem informados em uma propriedade no construtor, sem nenhum processamento. Promoção de construtor fornece uma sintaxe reduzida para esse caso. O exemplo acima pode ser reescrito assim:

Exemplo #3 Utilizando promoção de propriedades no construtor

<?php
class Point {
    public function 
__construct(protected int $x, protected int $y 0) {
    }
}

Quanto um argumento de construtor incluir um modificador de visibilidade, o PHP interpretará como sendo uma propriedade de objeto e como um argumento do construtor, e assimilará o valor do argumento a uma propriedade de mesmo nome. O corpo do construtor pode estar vazio ou conter outras operações. Quaisquer operações serão executados após os valores dos argumentos serem definidos nas respectivas propriedades.

Nem todos os argumentos são promovidos. É possível misturar os argumentos promovidos e não promovidos em qualquer ordem. Argumentos promovidos não têm impacto no código chamador do construtor.

Nota:

Propriedades de objeto não podem ser do tipo callable dado uma ambiguidade que poderia introduzir. Argumentos promovidos, portanto, não podem ser do tipo callable. Quaisquer outra declaração de tipo é permitida.

Nota:

Atributos informados em um argumento promovido será replicado tanto na propriedade como no no argumento.

Métodos de criação estáticos

O PHP suporta apenas um único construtor por classe. Em alguns casos pode ser desejável de permitir a um objeto ser construído de maneiras diferentes, a partir de argumentos diferentes. O método recomendado para realizar isso é através de métodos estáticos, utilizados como empacotadores do construtor.

Exemplo #4 Utilizando métodos estáticos para construção

<?php
class Product {

    private ?
int $id;
    private ?
string $name;

    private function 
__construct(?int $id null, ?string $name null) {
        
$this->id $id;
        
$this->name $name;
    }

    public static function 
fromBasicData(int $idstring $name): static {
        
$new = new static($id$name);
        return 
$new;
    }

    public static function 
fromJson(string $json): static {
        
$data json_decode($json);
        return new static(
$data['id'], $data['name']);
    }

    public static function 
fromXml(string $xml): static {
        
// Custom logic here.
        
$data convert_xml_to_array($xml);
        
$new = new static();
        
$new->id $data['id'];
        
$new->name $data['name'];
        return 
$new;
    }
}

$p1 Product::fromBasicData(5'Widget');
$p2 Product::fromJson($some_json_string);
$p3 Product::fromXml($some_xml_string);

O construtor pode ser private ou protected para evitar que ele seja chamado externamente. Nesses casos apenas um construtor estático será capaz de instanciar a classe. Por eles estarem nas mesma definição de classe, os métodos estáticos são capazes de instanciar o objeto, mesmo em uma instância diferente. O construtor privado é opcional e pode não fazer sentido em todos os casos.

Os três métodos estáticos a seguir demonstram as maneiras diferentes de instanciar um objeto.

  • fromBasicData() obtém os exatos parâmetros que são necessários, e então cria o objeto através da chamada do construtor e retorna o resultado
  • fromJson() aceita uma string JSON, realiza algum pré-processamento para converter os dados no formato necessário ao construtor. Só então retorna o novo objeto.
  • fromXml() aceita uma string XML, pré-processa, e então cria um objeto limpo. O construtor é chamado, mas com todos os parâmetros opcionais o método os ignora. Por fim informa os valores nas propriedades do objeto antes de retornar o resultado.

Nos três casos, a palavra chave static é convertida no nome da classe onde o código reside. Nesse caso a classe Product.

Destrutor

__destruct(): void

O PHP introduz um conceito de destrutor similar ao de outras linguagens orientadas a objeto, como C++. O método destrutor será chamado assim que todas as referências a um objeto particular forem removidas ou quando o objeto for explicitamente destruído ou qualquer ordem na sequência de encerramento.

Exemplo #5 Exemplo de Destrutor

<?php

class MyDestructableClass
{
    function 
__construct() {
        print 
"In constructor\n";
    }

    function 
__destruct() {
        print 
"Destroying " __CLASS__ "\n";
    }
}

$obj = new MyDestructableClass();

Assim como os construtores, os destrutores da classe pai não serão chamados implicitamente pelo PHP. Para executar o destrutor pai, deve-se fazer uma chamada explícita a parent::__destruct() no corpo do destrutor. Assim como construtores, uma classe filha pode herdar o destrutor caso não implemente um.

O destrutor será chamado mesmo se o script for terminado utilizando-se exit(). Chamar exit() em um destrutor irá impedir que as demais rotinas de encerramento executem.

Nota:

Destrutores chamados durante o encerramento da execução do script já enviaram os cabeçalhos HTTP. O diretório atual na fase de encerramento do script pode ser diferente em alguns SAPIs (e.g. Apache).

Nota:

Tentar disparar uma exceção em um destrutor (chamado no término do script), lançará um erro fatal.

add a note add a note

User Contributed Notes 12 notes

up
112
david dot scourfield at llynfi dot co dot uk
10 years ago
Be aware of potential memory leaks caused by circular references within objects.  The PHP manual states "[t]he destructor method will be called as soon as all references to a particular object are removed" and this is precisely true: if two objects reference each other (or even if one object has a field that points to itself as in $this->foo = $this) then this reference will prevent the destructor being called even when there are no other references to the object at all.  The programmer can no longer access the objects, but they still stay in memory.

Consider the following example:

<?php

header
("Content-type: text/plain");

class
Foo {
   
   
/**
     * An indentifier
     * @var string
     */
   
private $name;
   
/**
     * A reference to another Foo object
     * @var Foo
     */
   
private $link;

    public function
__construct($name) {
       
$this->name = $name;
    }

    public function
setLink(Foo $link){
       
$this->link = $link;
    }

    public function
__destruct() {
        echo
'Destroying: ', $this->name, PHP_EOL;
    }
}

// create two Foo objects:
$foo = new Foo('Foo 1');
$bar = new Foo('Foo 2');

// make them point to each other
$foo->setLink($bar);
$bar->setLink($foo);

// destroy the global references to them
$foo = null;
$bar = null;

// we now have no way to access Foo 1 or Foo 2, so they OUGHT to be __destruct()ed
// but they are not, so we get a memory leak as they are still in memory.
//
// Uncomment the next line to see the difference when explicitly calling the GC:
// gc_collect_cycles();
//
// see also: http://www.php.net/manual/en/features.gc.php
//

// create two more Foo objects, but DO NOT set their internal Foo references
// so nothing except the vars $foo and $bar point to them:
$foo = new Foo('Foo 3');
$bar = new Foo('Foo 4');

// destroy the global references to them
$foo = null;
$bar = null;

// we now have no way to access Foo 3 or Foo 4 and as there are no more references
// to them anywhere, their __destruct() methods are automatically called here,
// BEFORE the next line is executed:

echo 'End of script', PHP_EOL;

?>

This will output:

Destroying: Foo 3
Destroying: Foo 4
End of script
Destroying: Foo 1
Destroying: Foo 2

But if we uncomment the gc_collect_cycles(); function call in the middle of the script, we get:

Destroying: Foo 2
Destroying: Foo 1
Destroying: Foo 3
Destroying: Foo 4
End of script

As may be desired.

NOTE: calling gc_collect_cycles() does have a speed overhead, so only use it if you feel you need to.
up
25
domger at freenet dot de
4 years ago
The __destruct magic method must be public.

public function __destruct()
{
    ;
}

The method will automatically be called externally to the instance.  Declaring __destruct as protected or private will result in a warning and the magic method will not be called.

Note: In PHP 5.3.10 i saw strange side effects while some Destructors were declared as protected.
up
3
iwwp at outlook dot com
1 year ago
To better understand the __destrust method:

class A {
    protected $id;

    public function __construct($id)
    {
        $this->id = $id;
        echo "construct {$this->id}\n";
    }

    public function __destruct()
    {
        echo "destruct {$this->id}\n";
    }
}

$a = new A(1);
echo "-------------\n";
$aa = new A(2);
echo "=============\n";

The output content:

construct 1
-------------
construct 2
=============
destruct 2
destruct 1
up
14
spleen
12 years ago
It's always the easy things that get you -

Being new to OOP, it took me quite a while to figure out that there are TWO underscores in front of the word __construct.

It is __construct
Not _construct

Extremely obvious once you figure it out, but it can be sooo frustrating until you do.

I spent quite a bit of needless time debugging working code.

I even thought about it a few times, thinking it looked a little long in the examples, but at the time that just seemed silly(always thinking "oh somebody would have made that clear if it weren't just a regular underscore...")

All the manuals I looked at, all the tuturials I read, all the examples I browsed through  - not once did anybody mention this! 

(please don't tell me it's explained somewhere on this page and I just missed it,  you'll only add to my pain.)

I hope this helps somebody else!
up
8
prieler at abm dot at
14 years ago
i have written a quick example about the order of destructors and shutdown functions in php 5.2.1:

<?php
class destruction {
    var
$name;

    function
destruction($name) {
       
$this->name = $name;
       
register_shutdown_function(array(&$this, "shutdown"));
    }

    function
shutdown() {
        echo
'shutdown: '.$this->name."\n";
    }

    function
__destruct() {
        echo
'destruct: '.$this->name."\n";
    }
}

$a = new destruction('a: global 1');

function
test() {
   
$b = new destruction('b: func 1');
   
$c = new destruction('c: func 2');
}
test();

$d = new destruction('d: global 2');

?>

this will output:
shutdown: a: global 1
shutdown: b: func 1
shutdown: c: func 2
shutdown: d: global 2
destruct: b: func 1
destruct: c: func 2
destruct: d: global 2
destruct: a: global 1

conclusions:
destructors are always called on script end.
destructors are called in order of their "context": first functions, then global objects
objects in function context are deleted in order as they are set (older objects first).
objects in global context are deleted in reverse order (older objects last)

shutdown functions are called before the destructors.
shutdown functions are called in there "register" order. ;)

regards, J
up
8
Per Persson
9 years ago
As of PHP 5.3.10 destructors are not run on shutdown caused by fatal errors.

For example:
<?php
class Logger
{
    protected
$rows = array();

    public function
__destruct()
    {
       
$this->save();
    }

    public function
log($row)
    {
       
$this->rows[] = $row;
    }

    public function
save()
    {
        echo
'<ul>';
        foreach (
$this->rows as $row)
        {
            echo
'<li>', $row, '</li>';
        }
        echo
'</ul>';
    }
}

$logger = new Logger;
$logger->log('Before');

$nonset->foo();

$logger->log('After');
?>

Without the $nonset->foo(); line, Before and After will both be printed, but with the line neither will be printed.

One can however register the destructor or another method as a shutdown function:
<?php
class Logger
{
    protected
$rows = array();

    public function
__construct()
    {
       
register_shutdown_function(array($this, '__destruct'));
    }
   
    public function
__destruct()
    {
       
$this->save();
    }
   
    public function
log($row)
    {
       
$this->rows[] = $row;
    }
   
    public function
save()
    {
        echo
'<ul>';
        foreach (
$this->rows as $row)
        {
            echo
'<li>', $row, '</li>';
        }
        echo
'</ul>';
    }
}

$logger = new Logger;
$logger->log('Before');

$nonset->foo();

$logger->log('After');
?>
Now Before will be printed, but not After, so you can see that a shutdown occurred after Before.
up
4
Yousef Ismaeil cliprz[At]gmail[Dot]com
8 years ago
<?php

/**
* a funny example Mobile class
*
* @author Yousef Ismaeil Cliprz[At]gmail[Dot]com
*/

class Mobile {

   
/**
     * Some device properties
     *
     * @var string
     * @access public
     */
   
public $deviceName,$deviceVersion,$deviceColor;
   
   
/**
     * Set some values for Mobile::properties
     *
     * @param string device name
     * @param string device version
     * @param string device color
     */
   
public function __construct ($name,$version,$color) {
       
$this->deviceName = $name;
       
$this->deviceVersion = $version;
       
$this->deviceColor = $color;
        echo
"The ".__CLASS__." class is stratup.<br /><br />";
    }
   
   
/**
     * Some Output
     *
     * @access public
     */
   
public function printOut () {
        echo
'I have a '.$this->deviceName
           
.' version '.$this->deviceVersion
           
.' my device color is : '.$this->deviceColor;
    }
   
   
/**
     * Umm only for example we will remove Mobile::$deviceName Hum not unset only to check how __destruct working
     *
     * @access public
     */
   
public function __destruct () {
       
$this->deviceName = 'Removed';
        echo
'<br /><br />Dumpping Mobile::deviceName to make sure its removed, Olay :';
       
var_dump($this->deviceName);
        echo
"<br />The ".__CLASS__." class is shutdown.";
    }

}

// Oh ya instance
$mob = new Mobile('iPhone','5','Black');

// print output
$mob->printOut();

?>

The Mobile class is stratup.

I have a iPhone version 5 my device color is : Black

Dumpping Mobile::deviceName to make sure its removed, Olay :
string 'Removed' (length=7)

The Mobile class is shutdown.
up
2
Jonathon Hibbard
11 years ago
Please be aware of when using __destruct() in which you are unsetting variables...

Consider the following code:
<?php
class my_class {
  public
$error_reporting = false;

  function
__construct($error_reporting = false) {
   
$this->error_reporting = $error_reporting;
  }

  function
__destruct() {
    if(
$this->error_reporting === true) $this->show_report();
    unset(
$this->error_reporting);
  }
?>

The above will result in an error:
Notice: Undefined property: my_class::$error_reporting in my_class.php on line 10

It appears as though the variable will be unset BEFORE it actually can execute the if statement.  Removing the unset will fix this.  It's not needed anyways as PHP will release everything anyways, but just in case you run across this, you know why ;)
up
1
bolshun at mail dot ru
13 years ago
Ensuring that instance of some class will be available in destructor of some other class is easy: just keep a reference to that instance in this other class.
up
-1
instatiendaweb at gmail dot com
7 months ago
/**
* Haciendo una prueba con dos clases y dos destructores
* La prueba consta de acceder a la variable global del primer objeto en el segundo
* objeto el destructor 2
* Primera clase ==> $GLOBALS['obj']
* SEgunda clase ==> $GLOBALS['obj2']
* Se ejecuta construct y todo el codigo....
* Primer destruct borra el objeto y lo hace null
* Tratamos de acceder a $GLOBALS['obj'] en el segundo destruct pero
* ya no esta es un objeto null
* Warning: Undefined array key "obj" in...
*/

class MyDestructableClass{
public $parametro;

     function __construct($parametro) {
echo("<div class=\"div\">"), "Construyendo ",__CLASS__ , ("</div>");
         escribir::verifacionnota($this ,'Antes de guardar la variable  ');
         $this->parametro = $parametro;
         escribir::verifacionnota($this ,'Despues de guardar la variable  ');
     }

  

     function __destruct() {
        escribir::linea(5); //Separador
        echo("<div class=\"div\">"), "Destruyendo " ,  __CLASS__ , ("</div>");
        escribir::verifacionnota($this ,'Antes de borrar la variable  ');
        unset($this->parametro);
        escribir::verifacionnota($this ,'Despues de borrar la variable  ');

       // unset($GLOBALS[$this]);
     }
}

$obj = new MyDestructableClass('parametroone');
escribir::verifacionnota($obj ,' Verificar la clase MyDestructableClass, no es necesario
borrar la clase porque se ejecuta al final del script  ');
escribir::titulosep('Provando ejemplo aqui se puede acceder a la variable global');
escribir::verificacion($GLOBALS['obj']);

class destructora{
    function __destruct(){
        escribir::titulosep('Sin embargo esta variable muere aqui');
        escribir::verificacion($GLOBALS['obj']);
    }
}

$obj2 = new destructora();
up
0
Reza Mahjourian
15 years ago
Peter has suggested using static methods to compensate for unavailability of multiple constructors in PHP.  This works fine for most purposes, but if you have a class hierarchy and want to delegate parts of initialization to the parent class, you can no longer use this scheme.  It is because unlike constructors, in a static method you need to do the instantiation yourself.  So if you call the parent static method, you will get an object of parent type which you can't continue to initialize with derived class fields.

Imagine you have an Employee class and a derived HourlyEmployee class and you want to be able to construct these objects out of some XML input too.

<?php
class Employee {
   public function
__construct($inName) {
      
$this->name = $inName;
   }

   public static function
constructFromDom($inDom)
   {
      
$name = $inDom->name;
       return new
Employee($name);
   }

   private
$name;
}

class
HourlyEmployee extends Employee {
   public function
__construct($inName, $inHourlyRate) {
      
parent::__construct($inName);
      
$this->hourlyRate = $inHourlyRate;
   }

   public static function
constructFromDom($inDom)
   {
      
// can't call parent::constructFromDom($inDom)
       // need to do all the work here again
      
$name = $inDom->name// increased coupling
      
$hourlyRate = $inDom->hourlyrate;
       return new
EmployeeHourly($name, $hourlyRate);
   }

   private
$hourlyRate;
}
?>

The only solution is to merge the two constructors in one by adding an optional $inDom parameter to every constructor.
up
-3
david at synatree dot com
13 years ago
When a script is in the process of die()ing, you can't count on the order in which __destruct() will be called.

For a script I have been working on, I wanted to do transparent low-level encryption of any outgoing data.  To accomplish this, I used a global singleton class configured like this:

class EncryptedComms
{
    private $C;
    private $objs = array();
    private static $_me;
   
    public static function destroyAfter(&$obj)
    {
        self::getInstance()->objs[] =& $obj;
        /*
            Hopefully by forcing a reference to another object to exist
            inside this class, the referenced object will need to be destroyed
            before garbage collection can occur on this object.  This will force
            this object's destruct method to be fired AFTER the destructors of
            all the objects referenced here.
        */
    }
    public function __construct($key)
    {
            $this->C = new SimpleCrypt($key);
            ob_start(array($this,'getBuffer'));
    }
    public static function &getInstance($key=NULL)
    {
        if(!self::$_me && $key)
            self::$_me = new EncryptedComms($key);
        else
            return self::$_me;
    }
   
    public function __destruct()
    {
        ob_end_flush();
    }
   
    public function getBuffer($str)
    {
        return $this->C->encrypt($str);
    }

}

In this example, I tried to register other objects to always be destroyed just before this object.  Like this:

class A
{

public function __construct()
{
     EncryptedComms::destroyAfter($this);
}
}

One would think that the references to the objects contained in the singleton would be destroyed first, but this is not the case.  In fact, this won't work even if you reverse the paradigm and store a reference to EncryptedComms in every object you'd like to be destroyed before it.

In short, when a script die()s, there doesn't seem to be any way to predict the order in which the destructors will fire.
To Top