self ou $this en PHP : quand utiliser quoi ? Analyse avec exemples

Introduction : Pourquoi cette question tourmente-t-elle un développeur PHP sur deux ?

Si vous avez déjà écrit du PHP en orienté objet, vous avez forcément été confronté au dilemme : quand utiliser self et quand utiliser $this ? Cette question est l'une des plus populaires sur Stack Overflow (des milliers de vues et des dizaines de votes). La différence semble évidente, mais dès qu'on creuse un peu, même les développeurs expérimentés commencent à s'embrouiller.

Dans cet article, nous allons tout clarifier. Vous apprendrez :

\n
• Ce qui distingue fondamentalement self et $this ;
\n
• Dans quelles situations chacun est obligatoire ;
\n
• Comment fonctionnent l'héritage et les contextes statiques ;
\n
• Et, bien sûr, vous verrez des exemples de code réels que vous pourrez appliquer immédiatement.
\n

C'est parti pour une bonne fois pour toutes !

Règle de base : statique vs instance

La chose la plus importante à retenir :

\n
• $this — fait référence à l'objet courant (instance de la classe). Fonctionne uniquement dans un contexte non statique.
\n
• self — fait référence à la classe courante dans laquelle le code est écrit. Utilisé pour accéder aux propriétés statiques, constantes et méthodes statiques.
\n

Cela semble simple ? Vérifions avec un exemple.

Exemple 1 : Classe simple

<?php\nclass Coffee\n{\n    public static $type = 'Arabica';\n    public $sugar = 2;\n\n    public function info()\n    {\n        // $this — pour les propriétés de l'objet\n        echo "Sucre : {$this->sugar} cuillères.";\n\n        // self — pour la propriété statique\n        echo "Type de café : " . self::$type;\n    }\n}\n\n$cup = new Coffee();\n$cup->info(); // Affiche : Sucre : 2 cuillères. Type de café : Arabica\n?>

Tout est logique ici : $this->sugar est unique pour chaque tasse, tandis que self::$type est commun à toutes.

Le piège de l'héritage : self vs static

C'est là que les choses deviennent intéressantes. Beaucoup pensent que self se comporte de manière polymorphe, mais ce n'est pas le cas. self pointe toujours vers la classe où il est écrit, même si vous appelez la méthode depuis une classe enfant.

Si vous avez besoin que le code tienne compte de la classe depuis laquelle il a été appelé (liaison statique tardive), utilisez static.

Exemple 2 : Héritage et piège

<?php\nclass Animal\n{\n    public static $sound = '...';\n\n    public static function speak()\n    {\n        // ATTENTION : self fait référence à Animal, pas à Dog !\n        echo self::$sound;\n    }\n\n    public static function speakCorrect()\n    {\n        // static fait référence à la classe qui a appelé la méthode\n        echo static::$sound;\n    }\n}\n\nclass Dog extends Animal\n{\n    public static $sound = 'Ouaf !';\n}\n\nDog::speak();       // Affiche : ... (car self = Animal)\nDog::speakCorrect(); // Affiche : Ouaf ! (car static = Dog)\n?>

Cet exemple est une source fréquente de bugs. Si vous écrivez une bibliothèque et que vous attendez que les classes enfants puissent redéfinir les propriétés statiques, utilisez toujours static au lieu de self.

Quand ne peut-on pas se passer de self ?

Il y a des situations où $this ne fonctionne tout simplement pas, et self est la seule option :

\n
• Méthodes statiques : à l'intérieur d'une méthode déclarée comme public static function, il n'y a pas d'objet, donc $this n'est pas disponible. Seulement self.
\n
• Constantes de classe : on y accède via self::CONSTANT (ou ClassName::CONSTANT).
\n
• Propriétés statiques : self::$property.
\n
• À l'intérieur du constructeur ou du destructeur : bien que $this soit disponible, pour les opérations statiques, il est préférable d'utiliser