static

Le mot-clé PHP static

Le mot-clé static en PHP a deux utilisations distinctes, et il est utile de les distinguer dès le départ :

1. Membres de classe — static marque une propriété ou une méthode comme appartenant à la classe elle-même plutôt qu'à un objet individuel. Vous y accédez sans créer d'instance, et toutes les instances partagent la même valeur.
2. Variables locales statiques — à l'intérieur d'une fonction, static permet à une variable locale de conserver sa valeur entre les appels au lieu d'être réinitialisée à chaque fois.

Ce chapitre couvre les deux usages, ainsi que les mots-clés associés self, static:: et parent:: que l'on rencontre presque toujours aux côtés des membres statiques. Si les classes et les objets sont nouveaux pour vous, lisez d'abord Classes et Objets.

Membres de classe statiques

Une propriété normale vit sur chaque objet. Une propriété statique vit sur la classe — il n'en existe qu'une seule copie, partagée par toutes les instances et accessible même lorsqu'aucune instance n'existe.

Syntaxe de base

<?php

class MyClass {
  public static $myProperty = "Hello, world!";

  public static function myMethod() {
    return self::$myProperty;
  }
}

Vous accédez à un membre statique avec l'opérateur de résolution de portée ::, et non l'opérateur objet -> :

<?php

echo MyClass::$myProperty;   // Hello, world!
echo MyClass::myMethod();    // Hello, world!

À l'intérieur de la classe, référencez vos propres membres statiques avec self:: (ou static::, expliqué ci-dessous) — jamais $this, car une méthode statique peut s'exécuter sans aucun objet.

Pour une couverture plus approfondie, consultez Propriétés statiques et Méthodes statiques.

Variables locales statiques

Le même mot-clé fait quelque chose de complètement différent à l'intérieur d'une fonction : il permet à une variable de persister entre les appels. Sans static, une variable locale est réinitialisée à chaque appel ; avec lui, la valeur initiale est définie une seule fois et la variable conserve ce qu'elle contenait la dernière fois.

<?php

function counter() {
  static $count = 0;   // initialised only on the first call
  $count++;
  return $count;
}

echo counter(); // 1
echo counter(); // 2
echo counter(); // 3

C'est pratique pour mettre en cache un résultat coûteux ou compter combien de fois une fonction a été exécutée, sans exposer une variable globale.

Exemples

Voyons quelques exemples pratiques de membres de classe statiques :

Exemples du mot-clé static en PHP

<?php

// Example 1
class Counter
{
  public static $count = 0;

  public static function increment()
  {
    self::$count++;
  }
}

Counter::increment();
Counter::increment();
echo Counter::$count . PHP_EOL;

// Example 2
class User
{
  public static $name;

  public static function setName($name)
  {
    self::$name = $name;
  }
}

User::setName("John Doe");
echo User::$name;

Dans Counter, la propriété statique $count est partagée, donc deux appels à increment() s'accumulent pour atteindre 2. Dans User, setName() stocke des données sur la classe elle-même plutôt que sur un objet.

self vs static (liaison statique tardive)

Lorsque vous référencez un membre statique depuis l'intérieur d'une méthode, vous avez deux options, et la différence est importante en cas d'héritage :

• self:: est résolu au moment de la compilation — il pointe toujours vers la classe où le code est écrit.
• static:: utilise la liaison statique tardive — il est résolu au moment de l'exécution vers la classe qui a été réellement appelée.

<?php

class Base {
  public static function create() {
    return new static();   // runtime class
  }
  public static function createSelf() {
    return new self();     // always Base
  }
}

class Child extends Base {}

echo get_class(Child::create());     // Child
echo "\n";
echo get_class(Child::createSelf()); // Base

Utilisez static:: lorsqu'une sous-classe doit pouvoir remplacer un comportement ou être celle qui est instanciée — le modèle ci-dessus est la base des méthodes de fabrique. Utilisez self:: lorsque vous visez spécifiquement cette classe. Pour appeler la méthode statique d'un parent, utilisez parent::. Consultez Héritage pour une vue d'ensemble.

Cas d'utilisation courants

• Compteurs et état partagé — une seule valeur suivie sur toutes les instances, comme le Counter ci-dessus.
• Méthodes utilitaires / assistantes — fonctions sans état regroupées sous une classe, par ex. Math::clamp(), appelées sans objet.
• Méthodes de fabrique — User::fromArray($data) retourne une instance configurée ; new static() le rend compatible avec les sous-classes.
• Singletons et caches simples — une propriété statique contient l'instance unique ou un résultat mémoïsé.

Pour des valeurs partagées nommées et immuables, préférez une constante de classe plutôt qu'une propriété statique.

Pièges courants

• Pas de $this dans les méthodes statiques. Une méthode statique peut être appelée sans objet, donc $this y est indéfini. Accéder à l'état d'instance depuis une méthode statique est un signe de mauvaise conception.
• Les propriétés statiques sont un état partagé quasi-global. Comme chaque instance partage la même copie, la modifier depuis n'importe où affecte tout le monde — il est facile d'introduire un couplage caché et de briser l'isolation des tests. Utilisez-les délibérément.
• :: pour le statique, -> pour l'instance. MyClass::$prop (statique) vs $obj->prop (instance). Notez que $ reste sur le nom de la propriété dans la forme statique : Counter::$count, pas Counter::count.
• Les variables locales statiques sont par fonction, pas par appel. Deux appels récursifs partagent la même variable static, ce qui peut parfois surprendre.

Conclusion

Le mot-clé static remplit deux rôles : il définit des propriétés et des méthodes au niveau de la classe partagées entre toutes les instances et accessibles sans objet, et il permet à une variable locale d'une fonction de survivre entre les appels. Combinez-le avec self::, static:: et parent:: pour contrôler précisément vers quelle classe vos appels statiques sont résolus. Utilisez les membres statiques pour un état véritablement partagé et des assistants sans état — mais traitez les données statiques mutables partagées avec la même prudence qu'une variable globale.

Pratique