Accesseurs (getters et setters) en TypeScript : guide complet avec exemples

Get et Set en TypeScript : la magie des accesseurs sans douleur

Avez-vous déjà écrit une classe en TypeScript en vous disant : « Et si je rendais cette propriété intelligente, pour qu'elle calcule quelque chose à la lecture et valide les données à l'écriture » ? Découvrez les accesseurs (get et set). Ce n'est pas simplement du sucre syntaxique, mais un outil puissant pour contrôler l'accès aux données.

Si vous avez déjà cherché sur Stack Overflow, vous savez que la question « get and set in TypeScript » cumule des milliers de vues. Beaucoup hésitent entre l'utilisation des accesseurs et celle des méthodes classiques. Dans cet article, nous allons tout clarifier : des bases aux subtilités avancées.

Prêt ? C'est parti !

Que sont get et set en TypeScript ?

Un getter est une méthode appelée lors de la lecture d'une propriété. Un setter est une méthode appelée lors de l'affectation d'une valeur. Ensemble, ils forment les accesseurs. Cela donne l'impression de travailler avec un champ classique, mais avec une logique sous le capot.

Voici un exemple minimal :

class User {\n  private _name: string = '';\n\n  get name(): string {\n    return this._name;\n  }\n\n  set name(value: string) {\n    if (value.length > 0) {\n      this._name = value;\n    } else {\n      console.log('Le nom ne peut pas être vide');\n    }\n  }\n}\n\nconst user = new User();\nuser.name = 'Marie'; // appelle le setter\nconsole.log(user.name); // appelle le getter → 'Marie'\nuser.name = ''; // tentative de définir un nom vide → message dans la console

Remarquez que la propriété _name avec le préfixe _ est un champ privé. L'accès direct depuis l'extérieur est impossible. Nous utilisons à la place l'accesseur public name.

Pourquoi utiliser les getters et setters ? 3 raisons principales

1. Validation des données

Le setter est l'endroit idéal pour vérifier les valeurs d'entrée. Vous pouvez filtrer les données incorrectes avant qu'elles n'atteignent l'objet.

class Temperature {\n  private _celsius: number = 0;\n\n  get celsius(): number {\n    return this._celsius;\n  }\n\n  set celsius(value: number) {\n    if (value < -273.15) {\n      throw new Error('La température ne peut pas être inférieure au zéro absolu');\n    }\n    this._celsius = value;\n  }\n}

2. Propriétés calculées

Un getter peut retourner non pas une valeur stockée, mais le résultat d'un calcul basé sur d'autres données.

class Rectangle {\n  constructor(public width: number, public height: number) {}\n\n  get area(): number {\n    return this.width * this.height;\n  }\n\n  get perimeter(): number {\n    return 2 * (this.width + this.height);\n  }\n}\n\nconst rect = new Rectangle(10, 5);\nconsole.log(rect.area); // 50 — calculé à la volée

3. Encapsulation et contrôle d'accès

Vous pouvez rendre une propriété en lecture seule (getter uniquement) ou en écriture seule (setter uniquement). Cela permet de respecter les principes de la POO.

class Config {\n  private _apiKey: string = 'secret123';\n\n  get apiKey(): string {\n    // Possibilité d'ajouter une journalisation ou une vérification des droits\n    return this._apiKey;\n  }\n  // Pas de setter défini — propriété en lecture seule\n}\n\nconst config = new Config();\nconsole.log(config.apiKey); // 'secret123'\n// config.apiKey = 'newKey'; // Erreur de compilation !

Questions fréquentes sur get et set en TypeScript

Examinons ce que les débutants (et les autres) demandent le plus souvent sur Stack Overflow et les forums.

Question 1 : Quelle est la différence entre get/set et des méthodes classiques ?

La principale différence est la syntaxe d'appel. Les accesseurs se comportent comme des propriétés : sans parenthèses. Cela rend le code plus propre et plus intuitif. Comparez :

// Avec des méthodes\nuser.getName();\nuser.setName('Pierre');\n\n// Avec des accesseurs\nuser.name;\nuser.name = 'Pierre';

La deuxième différence est que les accesseurs ne peuvent pas être surchargés (overload). Chaque accesseur a une seule signature.