Réponse.

Contexte :

Les propriétés et méthodes statiques sont apparues dans les classes JavaScript à partir de l'ES6, mais le typage strict de ces éléments est devenu possible grâce à TypeScript. Dans le JavaScript dynamique, les éléments statiques de la classe ne diffèrent pas en type de ceux non statiques, mais TypeScript permet d'ajouter la sécurité des types et une structure des classes en tenant compte des membres statiques.

Problème :

Les propriétés et méthodes statiques appartiennent à la classe elle-même, et non à ses instances. Cependant, de nombreux développeurs confondent le typage de l'instance (via this ou le constructeur) et le typage de la classe elle-même en tant qu'objet. Cela conduit parfois à des erreurs lors de l'accès aux champs statiques à l'intérieur des méthodes ou lors de l'héritage.

Solution :

Dans TypeScript, les membres statiques des classes sont typés séparément des membres non statiques :

Pour les membres non statiques, une description est utilisée à travers le corps de la classe.
Pour les membres statiques — via le mot-clé static.
Le type de la classe elle-même peut être décrit à l'aide de la construction typeof, pour passer et utiliser en toute sécurité comme un objet avec une structure définie.

Exemple de code :

class User {
  static count: number = 0;

  name: string;
  constructor(name: string) {
    this.name = name;
    User.count++;
  }

  static getCount(): number {
    return User.count;
  }
}

function createUserClass(): typeof User {
  return User;
}

Caractéristiques clés :

Les membres statiques ne vivent pas dans l'instance, mais dans le constructeur de la classe, donc ils ne sont accessibles que via la classe elle-même
Pour passer/typer la classe elle-même, on utilise typeof User, et pour les instances — User
Pour les méthodes statiques, il y a des restrictions (pas d'accès à this, à moins d'appeler via le constructeur de la classe)

Questions pièges.

Les méthodes statiques peuvent-elles accéder directement aux propriétés non statiques de la classe ?

Non, les méthodes statiques n'ont pas accès aux propriétés non statiques via this, car this pointe sur la classe elle-même (le constructeur). Pour travailler avec des propriétés non statiques, il est nécessaire de travailler avec des instances d'objet.

class Demo {
  static demoStatic() {
    // this.value; // Erreur — value n'est pas static
  }
}

Peut-on accéder à une propriété statique via une instance de la classe ?

Non, l'accès aux propriétés statiques est uniquement possible via le nom de la classe elle-même, et non via une instance :

const u = new User('Max');
console.log(u.count); // Erreur
console.log(User.count); // OK

Est-il possible d'hériter et de redéfinir les méthodes statiques lors de l'héritage d'une classe ?

Oui, les méthodes statiques peuvent être héritées et redéfinies, et cela fonctionnera comme prévu :

class Animal {
  static who() { return 'Animal'; }
}
class Dog extends Animal {
  static who() { return 'Dog'; }
}
console.log(Dog.who()); // 'Dog'

Erreurs de typage et anti-modèles

Confusion entre les membres statiques et non statiques de la classe
Tentative d'accès aux champs statiques via une instance
Erreurs lors de l'utilisation de this dans les méthodes statiques

Exemple de la vie réelle

Cas négatif

Un développeur conserve un compteur des instances créées en tant que propriété d'instance ordinaire, et non comme statique. À chaque création d'objet, le champ augmente, mais n'est pas synchronisé pour tous les objets de la classe.

Avantages :

Facile à mettre en œuvre sans connaissance de static

Inconvénients :

Violation des invariants, le compteur ne reflète pas le nombre d'objets, possibilité d'erreurs lors de la création massive

Cas positif

Utilisation de static count pour suivre tous les objets, augmentation correcte dans le constructeur et méthode statique pour obtenir le compteur.