PHP Academy · Leçon

Présentation des méthodes magiques

Découvrir __toString, __get, __set et d’autres méthodes magiques de PHP.

Présentation des méthodes magiques est une leçon PHP Academy gratuite sur CoddyKit. Ceci est la leçon 4 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage PHP Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours PHP Academy comprend 4 leçons au total.

Introduction : méthodes magiques de PHP

Les méthodes magiques sont des méthodes spéciales de PHP dont le nom commence par deux traits de soulignement et qui sont déclenchées automatiquement par le moteur PHP dans certaines situations. Elles vous donnent accès au comportement des objets.

Concepts fondamentaux

Concepts clés des méthodes magiques de PHP :

__toString() — conversion d'un objet en chaîne de caractères
__get/__set/__isset/__unset — interception de l'accès aux propriétés
__call/__callStatic — interception des appels de méthodes
__invoke() — objet appelable

__toString

Exemple :

<?php
class Money {
    public function __construct(
        private float  $amount,
        private string $currency
    ) {}

    public function __toString(): string {
        return number_format($this->amount, 2) . ' ' . $this->currency;
    }
}

$price = new Money(9.99, 'USD');
echo $price;            // 9.99 USD
echo 'Price: ' . $price; // Price: 9.99 USD

get et set

Suite :

<?php
class DynamicObject {
    private array $data = [];

    public function __get(string $name): mixed {
        return $this->data[$name] ?? null;
    }

    public function __set(string $name, mixed $value): void {
        $this->data[$name] = $value;
    }
}

$obj = new DynamicObject();
$obj->name = 'Alice';
echo $obj->name;  // Alice

isset et unset

Entraînement :

<?php
class Model {
    private array $attributes = [];

    public function __set(string $k, mixed $v): void { $this->attributes[$k] = $v; }
    public function __get(string $k): mixed { return $this->attributes[$k] ?? null; }
    public function __isset(string $k): bool { return isset($this->attributes[$k]); }
    public function __unset(string $k): void { unset($this->attributes[$k]); }
}

$m = new Model();
$m->email = 'a@b.com';
var_dump(isset($m->email));  // true
unset($m->email);
var_dump(isset($m->email));  // false

call et callStatic

Pour aller plus loin :

<?php
class FluentQuery {
    private array $clauses = [];

    public function __call(string $name, array $args): static {
        $this->clauses[$name] = $args[0] ?? null;
        return $this;
    }

    public function toSql(): string {
        return 'SELECT * FROM '
            . ($this->clauses['from'] ?? 'unknown');
    }
}

echo (new FluentQuery())->from('users')->toSql();
// SELECT * FROM users

__invoke

Utilisation avancée :

<?php
class Multiplier {
    public function __construct(private float $factor) {}

    public function __invoke(float $value): float {
        return $value * $this->factor;
    }
}

$double = new Multiplier(2);
echo $double(5);   // 10
echo $double(21);  // 42

$funcs = [new Multiplier(2), new Multiplier(3)];
foreach ($funcs as $fn) echo $fn(4) . ' '; // 8 12

__clone

Modèle concret :

<?php
class Config {
    private array $data = [];

    public function set(string $k, mixed $v): self {
        $this->data[$k] = $v;
        return $this;
    }

    public function __clone() {
        // deep clone nested objects if needed
    }
}

$original = (new Config())->set('theme', 'dark');
$copy = clone $original;  // triggers __clone

__debugInfo

Bonnes pratiques :

<?php
class ApiClient {
    public function __construct(
        private string $baseUrl,
        private string $apiKey  // sensitive!
    ) {}

    public function __debugInfo(): array {
        return [
            'baseUrl' => $this->baseUrl,
            'apiKey'  => '***' . substr($this->apiKey, -4),  // mask key
        ];
    }
}

var_dump(new ApiClient('https://api.example.com', 'secret123'));
// Shows masked key

Modèle pratique

Mettons tout cela en pratique avec un modèle concret pour les méthodes magiques de PHP.

Pièges courants

Évitez ces erreurs courantes avec les méthodes magiques de PHP :

Utilisez __toString() pour que l'affichage des objets soit pertinent
__get/__set permettent de créer des modèles de proxy ou de décorateur
__invoke permet d'utiliser les objets comme des fonctions appelables (utile avec array_map)
__debugInfo empêche l'apparition de données sensibles dans var_dump

Vérification rapide

Quelle méthode magique permet d'appeler un objet PHP comme une fonction ?

Récapitulatif : méthodes magiques de PHP

Vous avez étudié les méthodes magiques de PHP. Voici les points essentiels à retenir :

Utilisez __toString() pour que l'affichage des objets soit pertinent
__get/__set permettent de créer des modèles de proxy ou de décorateur
__invoke permet d'utiliser les objets comme des fonctions appelables (utile avec array_map)
__debugInfo empêche l'apparition de données sensibles dans var_dump

Questions Fréquemment Posées

La leçon « Présentation des méthodes magiques » est-elle gratuite ?

Oui — le texte complet de « Présentation des méthodes magiques » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours PHP Academy, passe à CoddyKit PRO. Le cours PHP Academy comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « Présentation des méthodes magiques » ?

Découvrir __toString, __get, __set et d’autres méthodes magiques de PHP. Tu pratiques PHP Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer PHP Academy ?

Aucune expérience préalable n'est requise. PHP Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 4 sur 4.

Combien de temps prend la leçon « Présentation des méthodes magiques » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon PHP Academy ?

Oui. Chaque leçon PHP Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

← Retour à PHP Academy