Comment utiliser les classes TypeScript avec des exemples simples

TypeScript apporte de puissantes fonctionnalités à JavaScript, notamment le concept de classes, qui permet la programmation orientée objet. Les classes fournissent un modèle pour la création d'objets, l'encapsulation de données et la définition de comportements. Ce guide vous guidera à travers les bases des classes TypeScript avec des exemples simples.

Qu'est-ce qu'une classe ?

Une classe est un plan directeur pour la création d'objets avec des propriétés et des méthodes prédéfinies. Elle permet d'organiser le code, de promouvoir la réutilisabilité et de créer des applications évolutives. Les classes dans TypeScript fonctionnent de manière similaire aux classes dans d'autres langages de programmation orientés objet.

Définition d'une classe de base

Pour définir une classe dans TypeScript, utilisez le mot-clé class suivi du nom de la classe et d'un ensemble d'accolades contenant des propriétés et des méthodes.

Exemple de classe de base

Vous trouverez ci-dessous un exemple d'une classe Person simple avec des propriétés et une méthode:

class Person {
  name: string;
  age: number;

  constructor(name: string, age: number) {
    this.name = name;
    this.age = age;
  }

  greet(): void {
    console.log(`Hello, my name is ${this.name} and I am ${this.age} years old.`);
  }
}

const person1 = new Person("Alice", 30);
person1.greet(); // Output: Hello, my name is Alice and I am 30 years old.

Dans cet exemple, la classe Person possède deux propriétés: name et age. La méthode constructeur initialise ces propriétés et la méthode greet génère un message d'accueil.

Modificateurs d'accès

TypeScript fournit trois modificateurs d'accès pour contrôler la visibilité des membres de la classe:

• public: Les membres sont accessibles de n'importe où (par défaut).
• privé: Les membres ne sont accessibles qu'au sein de la classe.
• protected: Les membres sont accessibles dans la classe et ses sous-classes.

Utilisation des modificateurs d'accès

Voici comment vous pouvez utiliser les modificateurs d’accès dans une classe TypeScript:

class Animal {
  public name: string;
  private age: number;

  constructor(name: string, age: number) {
    this.name = name;
    this.age = age;
  }

  public getAge(): number {
    return this.age;
  }
}

const dog = new Animal("Buddy", 5);
console.log(dog.name); // Output: Buddy
console.log(dog.getAge()); // Output: 5
// console.log(dog.age); // Error: 'age' is private and only accessible within class 'Animal'.

Dans cet exemple, name est une propriété publique, accessible depuis l'extérieur de la classe, tandis que age est une propriété privée, accessible uniquement au sein de la classe.

Héritage dans TypeScript

TypeScript prend en charge l'héritage, ce qui permet à une classe d'hériter des propriétés et des méthodes d'une autre classe. Cela permet de réutiliser le code et de créer une hiérarchie de classes.

Exemple d'héritage

Vous trouverez ci-dessous un exemple de classe Dog qui hérite d'une classe de base Animal:

class Animal {
  constructor(public name: string) {}

  makeSound(): void {
    console.log(`${this.name} makes a sound.`);
  }
}

class Dog extends Animal {
  constructor(name: string) {
    super(name); // Call the constructor of the base class
  }

  makeSound(): void {
    console.log(`${this.name} barks.`);
  }
}

const dog = new Dog("Buddy");
dog.makeSound(); // Output: Buddy barks.

Dans cet exemple, la classe Dog étend la classe Animal et remplace la méthode makeSound.

Getters et Setters

TypeScript vous permet de définir des getters et des setters pour les propriétés, offrant un accès contrôlé aux membres de la classe.

Exemple de getters et de setters

class Person {
  private _name: string;

  constructor(name: string) {
    this._name = name;
  }

  get name(): string {
    return this._name;
  }

  set name(newName: string) {
    if (newName) {
      this._name = newName;
    } else {
      console.log("Name cannot be empty.");
    }
  }
}

const person = new Person("Alice");
console.log(person.name); // Output: Alice
person.name = "Bob";
console.log(person.name); // Output: Bob

Dans cet exemple, la propriété name est accessible et modifiée à l'aide des méthodes getter et setter.

Conclusion

Les classes TypeScript constituent un moyen puissant d'écrire du code orienté objet de manière propre et efficace. Elles offrent un moyen structuré de définir des propriétés, des méthodes, des modificateurs d'accès, l'héritage, etc. En comprenant comment utiliser les classes TypeScript, vous pouvez écrire du code plus robuste et plus facile à gérer pour vos applications.