Liste des méthodes magiques

Détails des méthodes

__construct

Cette méthode est appelée sitôt que la classe est instanciée, ce qui permet de lancer une initialisation. En PHP4, le constructeur existait déjà, son nommage était celui de la classe.
Pour assurer la compatibilité PHP4/PHP5, il est intéressant de procéder comme suit:

<?php
class foo() {
   var $var;
   function foo($var) {
      $this->__construct($var);
   }
   function __construct($var) {
      $this->var = $var;
      echo $this->var
   }
?>
$test = new foo('Ceci est un test');

Il est toutefois à noter qu'en PHP5, si la méthode __construct() n'est pas trouvée, une méthode du nom de la classe est recherchée.
Note: Les constructeurs parents ne sont pas appelés implicitement si la classe enfant définie un constructeur. Si vous voulez utiliser un constructeur parent, il sera nécessaire de faire appel à parent::__construct().

__destruct

Cete fonction est appelée lorsque toutes les références à un objet sont effacées ou lorsque l'objet est explicitement détruit (unset()).
Comme pour __construct, les destructeurs parents ne sont pas implicitement appelés.

__call

__call() est lancé lorsque l'on invoque des méthodes inaccessibles dans le contexte de l'objet. Cela permet donc de gérer l'absence d'une méthode sans provoquer d'erreur bloquante.
Elle prend deux arguments: $name et $arguments qui sont:

  • $name : Nom de la méthode appelée
  • $argument : Tableau des arguments envoyés
<?php
class foo() {
   function __call($name, $argument) {
      echo 'La méthode ', $name, ' n\'existe pas', '<br />', var_dump($argument);
   }
}
$test = new foo();
$test->alert('abc', 123);
?>

__callStatic

Cette méthode agit exactement comme __call mais lors de l'appel statique d'une méthode inexistante:

<?php
class foo() {
   public static function __callStatic($name, $argument) {
      echo 'La méthode ', $name, ' n\'existe pas', '<br />', var_dump($argument);
   }
}
$test = foo::alert('abc', 123);
?>

__get

Cette méthode sert à lire une donnée normalement inaccessible, par exemple une variable private dans le parent d'une classe.

__set

Cette méthode sert à écrire une donnée normalement inaccessible

__isset

Cette méthode est lancée en appelant la fonction isset() ou la fonction empty() sur des membres inaccessibles.

__unset

Cette méthode est appelée lorsque unset() est appelé sur des membres inaccessibles.

__sleep

La fonction serialize() vérifie si votre classe a une fonction avec le nom magique __sleep. Si c'est le cas, cette fonction sera exécutée avant toute linéarisation. Elle peut nettoyer l'objet et elle est supposée retourner un tableau avec les noms de toutes les variables de l'objet qui doivent être linéarisées. Si la méthode ne retourne rien, alors NULL est linéarisé et une alerte de type E_NOTICE est émise.

Le but avoué de __sleep est de valider des données en attente ou d'effectuer les opérations de nettoyage. De plus, cette fonction est utile si vous avez de très gros objets qui n'ont pas besoin d'être sauvegardés en totalité.

__wakeup

Réciproquement, la fonction unserialize() vérifie la présence d'une fonction dont le nom est le nom magique __wakeup. Si elle est présente, cette fonction peut reconstruire toute ressource que l'objet possède.

Le but avoué de __wakeup est de rétablir toute connexion base de données qui aurait été perdue durant la linéarisation et d'effectuer des tâches de réinitialisation.

__toString

La méthode __toString détermine comment la classe doit réagir lorsqu'elle est convertie en chaîne de caractères.

<?php
class foo {
   public $foo;
    public function __construct($foo) {
        $this->foo = $foo;
    }
    public function __toString() {
        return $this->foo;
    }
}
$test = new foo('un test');
echo $foo; // Renvoit "un test"
?>

__invoke

La méthode __invoke est appelée lorsque le script tente d'appeler un objet comme une fonction.

<?php
class foo {
   function __invoke($vars) {
      echo '<pre>', var_dump($vars), '</pre>';
   }
}
 
$test = new foo();
$test('une chaîne');
?>

__setstate

Cette méthode statique est appelée pour les classes exportées par la fonction var_export() depuis PHP 5.1.0.

Le seul paramètre de cette méthode est un tableau contenant les propriétés exportées sous la forme array('propriété' => valeur, ...).

<?php
class foo {
    public $var1;
    public $var2;
    public static function __set_state($array) {
        $obj = new foo;
        $obj->var1 = $array['var1'];
        $obj->var2 = $array['var2'];
        return $obj;
    }
}
$a = new foo;
$a->var1 = 5;
$a->var2 = 'foo';
eval('$b = ' . var_export($a, true) . ';'); // $b = foo::__set_state(array(
                                            //    'var1' => 5,
                                            //    'var2' => 'foo',
                                            // ));
var_dump($b);
?>

__clone

Cette méthode crée la copie d'un objet. Elle ne peut pas être appelée directement, elle réagit à l'appel de la fonction clone $object.