Classes en TypeScript

Introduction aux Classes

Dans TypeScript, les classes permettent de structurer le code d'une manière orientée objet. Elles permettent, grâce à des annotations de type, de définir clairement le lien entre les membres d'une classe et leurs types statiques, tout en respectant les principes fondamentaux de JavaScript. TypeScript offre des syntaxes supplémentaires qui vous aident à écrire des classes de manière sécurisée.

Les Membres de Classe

Les types des membres d'une classe fonctionnent de manière similaire à ceux des paramètres et des variables. Si une valeur initiale est fournie, le type est déduit automatiquement. En l'absence de valeur initiale, le type est implicitement défini comme any, sauf si une annotation de type est fournie.

Prenons cet exemple de classe Container :

class Container {  
  itemsCount = 10;  
  label: string;  

  constructor(label: string) {  
    this.label = label;  
  }  
}

Dans cet exemple, itemsCount est de type number car sa valeur initiale est 10, tandis que label est explicitement défini comme étant de type string. Ainsi, nous pouvons faire des appels tels que :

const myContainer = new Container('Boîtes');
myContainer.itemsCount; // Type: number
myContainer.label; // Type: string

Visibilité des Membres

JavaScript utilise le préfixe # pour indiquer qu'un membre est privé, c'est-à-dire accessible uniquement à l'intérieur de la classe.

class SecretBox {  
  #content: string;  

  constructor(content: string) {  
    this.#content = content;  
  }  

  getContent() {  
    return this.#content;  
  }  
}

const mySecretBox = new SecretBox('secret!');  
mySecretBox.getContent(); // Ok  
mySecretBox.#content; // Erreur : Propriété '#content' inaccessible en dehors de la classe 'SecretBox'.

Public, Privé ou Protégé

TypeScript permet d'ajouter les mots-clés public, protected ou private devant les membres d'une classe pour indiquer leur accessibilité : - public (par défaut) : tout le monde peut y accéder. - protected : seules la classe et ses classes dérivées peuvent y accéder. - private : seule la classe elle-même y a accès.

Prenons une classe MainBase qui initialise plusieurs variables :

class MainBase {  
  public name = '';  
  secondName = '';  
  protected identifier = '';  
  private secret = '';  
  #privateInfo = '';  
}

La classe ExtendedBase peut hériter de la classe MainBase, mais uniquement les membres publics et protégés peuvent être utilisés :

class ExtendedBase extends MainBase {  
  testAccess() {  
    this.name; // Ok : public  
    this.secondName; // Ok : public  
    this.identifier; // Ok : protected  
    this.secret; // Erreur : propriété 'secret' est privée.  
    this.#privateInfo; // Erreur : propriété '#privateInfo' est inaccessible.
  }
}

Mise en Œuvre des Interfaces

Les classes peuvent également implémenter des interfaces en TypeScript pour mieux définir leur structure. Cela signifie qu'une instance d’une classe sera conforme à une interface donnée. Pour cela, on utilise le mot-clé implements :

interface Communicator {  
  speak(): string;  
}

class Orateur implements Communicator {  
  constructor(private message: string) {}  

  changeMessage() {  
    this.message += '!';  
  }  

  speak() {  
    return this.message;  
  }  
}

Les classes peuvent aussi implémenter plusieurs interfaces, séparées par des virgules. Cela ne modifie en rien la classe elle-même, mais permet de s'assurer qu'elle respecte bien l'interface spécifiée.