Quelles méthodes magiques existent en PHP et comment…

Les méthodes magiques en PHP sont des méthodes spéciales qui commencent par un double underscore (par exemple, __construct) et qui sont appelées automatiquement dans certaines situations.

Les méthodes magiques principales et leur utilisation :

__construct(): Appelé lors de la création d'un objet de la classe. Utilisé pour initialiser les propriétés de l'objet et effectuer des actions initiales.

<?php
class MyClass {
    public function __construct() {
        echo "Objet créé!";
    }
}
$obj = new MyClass(); // Affichera "Objet créé!"

__destruct(): Appelé lors de la destruction de l'objet (par exemple, lorsque le script se termine ou que l'objet est supprimé de la mémoire). Utilisé pour libérer des ressources (fermer des fichiers, des connexions à des bases de données).
```
<?php
class MyClass {
    public function __destruct() {
        echo "Objet détruit!";
    }
}
$obj = new MyClass();
unset($obj); // Affichera "Objet détruit!"
```

__call(string $name, array $arguments): Appelé lorsqu'on tente d'invoquer une méthode inaccessible ou inexistante dans le contexte de l'objet. $name contient le nom de la méthode, et $arguments est un tableau d'arguments.

<?php
class MyClass {
    public function __call($name, $arguments) {
        echo "Méthode inaccessible '{$name}' appelée avec arguments : " . implode(', ', $arguments);
    }
}
$obj = new MyClass();
$obj->nonExistentMethod('arg1', 'arg2'); // Affichera "Méthode inaccessible 'nonExistentMethod' appelée avec arguments : arg1, arg2"

__callStatic(string $name, array $arguments): Appelé lorsqu'on tente d'invoquer une méthode statique inaccessible ou inexistante dans le contexte de la classe. Semblable à __call, mais pour les appels statiques.

<?php
class MyClass {
    public static function __callStatic($name, $arguments) {
        echo "Méthode statique inaccessible '{$name}' appelée avec arguments : " . implode(', ', $arguments);
    }
}
MyClass::nonExistentStaticMethod('static_arg'); // Affichera "Méthode statique inaccessible 'nonExistentStaticMethod' appelée avec arguments : static_arg"

__get(string $name): Appelé lorsqu'on tente d'obtenir la valeur d'une propriété inaccessible ou inexistante dans le contexte de l'objet. $name contient le nom de la propriété.

<?php
class MyClass {
    private $data = ['key' => 'value'];
    public function __get($name) {
        if (array_key_exists($name, $this->data)) {
            return $this->data[$name];
        }
        return null;
    }
}
$obj = new MyClass();
echo $obj->key; // Affichera "value"
echo $obj->nonExistentKey; // Affichera une chaîne vide (en fonction de la valeur de retour null)

__set(string $name, mixed $value): Appelé lorsqu'on tente de définir la valeur d'une propriété inaccessible ou inexistante dans le contexte de l'objet. $name contient le nom de la propriété, et $value est la valeur à définir.

<?php
class MyClass {
    private $data = [];
    public function __set($name, $value) {
        $this->data[$name] = $value;
    }
    public function getData() {
        return $this->data;
    }
}
$obj = new MyClass();
$obj->newKey = 'newValue';
print_r($obj->getData()); // Affichera Array ( [newKey] => newValue )

__isset(string $name): Appelé lors de l'utilisation de isset() ou empty() sur une propriété inaccessible ou inexistante dans le contexte de l'objet. Retourne une valeur booléenne.

<?php
class MyClass {
    private $data = ['present' => 'value'];
    public function __isset($name) {
        return array_key_exists($name, $this->data);
    }
}
$obj = new MyClass();
var_dump(isset($obj->present));     // Affichera bool(true)
var_dump(isset($obj->absent));      // Affichera bool(false)

__unset(string $name): Appelé lors de l'utilisation de unset() sur une propriété inaccessible ou inexistante dans le contexte de l'objet.

<?php
class MyClass {
    private $data = ['remove_me' => 'value_to_remove'];
    public function __unset($name) {
        if (array_key_exists($name, $this->data)) {
            unset($this->data[$name]);
            echo "Propriété '{$name}' supprimée.\n";
        }
    }
    public function getData() {
        return $this->data;
    }
}
$obj = new MyClass();
print_r($obj->getData());
unset($obj->remove_me); // Affichera "Propriété 'remove_me' supprimée." et supprimera l'élément de $data
print_r($obj->getData());

__sleep(): Appelé avant la sérialisation de l'objet avec serialize(). Doit retourner un tableau des noms des propriétés à sérialiser.

<?php
class MyClass {
    public $prop1 = 'value1';
    public $prop2 = 'value2';
    public function __sleep() {
        return ['prop1']; // Sérialise uniquement prop1
    }
}
$obj = new MyClass();
$serialized = serialize($obj); // Sérialise uniquement prop1
echo $serialized; // Affichera environ O:7:"MyClass":1:{s:5:"prop1";s:6:"value1";}

__wakeup(): Appelé après la désérialisation avec unserialize(). Utilisé pour restaurer des connexions à des bases de données ou d'autres actions nécessaires après la restauration de l'objet.

<?php
class MyClass {
    public $prop1;
    public $resource; // Supposons que c'est une ressource de connexion
    public function __wakeup() {
        // Restaurer la ressource, par exemple, une connexion à la base de données
        $this->resource = fopen('/tmp/my_file.txt', 'w'); // Exemple
        echo "Objet réveillé et ressource restaurée!\n";
    }
    public function __sleep() {
        // En __sleep, on ne sérialise pas la ressource
        return ['prop1'];
    }
    public function __destruct() {
        if (is_resource($this->resource)) {
            fclose($this->resource);
            echo "Ressource fermée.\n";
        }
    }
}
$obj = new MyClass();
$obj->prop1 = 'valeur désérialisée';
$serialized = serialize($obj);
unset($obj);

$deserialized_obj = unserialize($serialized); // Appellera __wakeup()
var_dump($deserialized_obj->prop1);

__toString(): Appelé lorsque l'objet est utilisé comme chaîne (par exemple, avec echo ou concaténation). Doit retourner une représentation en chaîne de l'objet.

<?php
class MyClass {
    public $name = "MyObject";
    public function __toString() {
        return "Objet de type MyClass avec le nom : " . $this->name;
    }
}
$obj = new MyClass();
echo $obj; // Affichera "Objet de type MyClass avec le nom : MyObject"

__invoke(...): Appelé lorsqu'on tente d'invoquer l'objet comme une fonction. Peut accepter n'importe quel nombre d'arguments.

<?php
class MyCallableClass {
    public function __invoke(...$args) {
        echo "L'objet a été appelé comme une fonction avec arguments : " . implode(', ', $args);
    }
}
$obj = new MyCallableClass();
$obj('arg1', 123); // Affichera "L'objet a été appelé comme une fonction avec arguments : arg1, 123"

__set_state(array $properties): Appelé de manière statique pour les classes exportées avec var_export(). Reçoit un tableau des propriétés exportées. Doit créer un nouvel objet de la classe et le retourner.

<?php
class MyClass {
    public $prop;
    public static function __set_state(array $properties) {
        $obj = new MyClass();
        $obj->prop = $properties['prop'];
        return $obj;
    }
}
$obj = new MyClass();
$obj->prop = 'valeur exportée';
$exported = var_export($obj, true); // Exporte l'objet
// $exported contiendra le code pour créer l'objet, utilisant __set_state()
eval('$restored_obj = ' . $exported . ';');
var_dump($restored_obj); // Affichera un objet MyClass avec la propriété 'valeur exportée'

__debugInfo(): Appelé lors de l'utilisation de fonctions comme var_dump() sur l'objet. La méthode doit retourner un tableau avec les informations sur les propriétés de l'objet à afficher.

<?php
class MyClass {
    public $publicProp = 'public';
    private $privateProp = 'privé';
    public function __debugInfo() {
        return ['publicProp' => $this->publicProp, 'private_info' => 'quelques détails sur privateProp'];
    }
}
$obj = new MyClass();
var_dump($obj); // Affichera les informations retournées par __debugInfo()

__clone(): Appelé après l'opération de clonage (clone) de l'objet. Utilisé pour faire une copie en profondeur des objets internes ou des structures de données.

<?php
class SubObject {
    public $value;
    public function __construct($value) {
        $this->value = $value;
    }
}
class MyClass {
    public $object;
    public $anotherProp;
    public function __construct() {
        $this->object = new SubObject('initial');
        $this->anotherProp = 'original';
    }
    public function __clone() {
        // Clonage en profondeur de l'objet interne
        $this->object = clone $this->object;
    }
}
$obj = new MyClass();
$cloned_obj = clone $obj;

// Maintenant, $obj->object et $cloned_obj->object sont des instances différentes de SubObject
$cloned_obj->object->value = 'modifié';

var_dump($obj->object->value);       // Affichera "initial"
var_dump($cloned_obj->object->value); // Affichera "modifié"

Tableau avec une brève description :

Méthode	Description	Appelée lorsque...
`__construct()`	Constructeur de la classe.	Lors de la création d'une nouvelle instance de la classe.
`__destruct()`	Destructeur de la classe.	Lors de la suppression de l'objet ou de la fin du script.
`__call()`	Gère l'appel de méthodes non existantes ou inaccessibles de l'objet.	Lorsqu'on tente d'appeler une méthode non accessible ou inexistante.
`__callStatic()`	Gère l'appel de méthodes statiques non existantes ou inaccessibles.	Lorsqu'on tente d'appeler une méthode statique non accessible ou inexistante.
`__get()`	Gère la récupération de valeurs de propriétés non accessibles ou inexistantes.	Lorsqu'on tente d'obtenir la valeur d'une propriété non accessible ou inexistante.
`__set()`	Gère l'affectation de valeurs à des propriétés non accessibles ou inexistantes.	Lorsqu'on tente de définir une valeur pour une propriété non accessible ou inexistante.
`__isset()`	Gère l'utilisation de `isset()` ou `empty()` sur des propriétés non accessibles ou inexistantes.	Lorsqu'on utilise `isset()` ou `empty()` sur une propriété non accessible ou inexistante.
`__unset()`	Gère l'utilisation de `unset()` sur des propriétés non accessibles ou inexistantes.	Lorsqu'on utilise `unset()` sur une propriété non accessible ou inexistante.
`__sleep()`	Prépare l'objet à la sérialisation.	Lorsqu'on appelle `serialize()` sur l'objet.
`__wakeup()`	Post-traitement après la désérialisation.	Lorsqu'on appelle `unserialize()` sur l'objet.
`__toString()`	Représentation en chaîne de l'objet.	Lorsqu'on utilise l'objet comme chaîne (par exemple, avec `echo`).
`__invoke()`	Appel de l'objet comme une fonction.	Lorsqu'on tente d'appeler l'objet comme une fonction.
`__set_state()`	Création de l'objet après exportation avec `var_export()`.	Lorsqu'on évalue du code généré par `var_export()`.
`__debugInfo()`	Informations pour les fonctions de débogage (`var_dump()`).	Lorsqu'on appelle `var_dump()` sur l'objet.
`__clone()`	Post-traitement après clonage.	Lorsqu'on utilise `clone` sur l'objet.

Quelles méthodes magiques existent en PHP et comment sont-elles utilisées?