Comment définir et utiliser les classes Ty­peS­cript ?

Les classes Ty­peS­cript four­nis­sent une méthode organisée et trans­pa­rente pour struc­tu­rer les données et les actions au sein d’un objet. Cela rend la mo­dé­li­sa­tion des entités et des concepts dans votre code plus simple et plus intuitive.

À quoi servent les classes Ty­peS­cript ?

Les classes sont un concept clé du langage de pro­gram­ma­tion Ty­peS­cript, basé sur Ja­vaS­cript. Elles re­pré­sen­tent une méthode struc­tu­rée pour créer des objets selon le principe de la pro­gram­ma­tion orientée objet (OOP, Object-Oriented Pro­gram­ming). Ces classes agissent comme des schémas, per­met­tant de générer des objets qui intègrent à la fois des données et des fonctions étroi­te­ment con­nec­tées.

Ty­peS­cript contient toutes les fonctions de Ja­vaS­cript et comprend en plus le typage statique. Il est ainsi possible de spécifier des types de données pour des fonctions Ty­peS­cript, des variables et des classes afin de détecter les erreurs lors de la com­pi­la­tion. Outre la sécurité des types, les classes Ty­peS­cript prennent en charge des concepts tels que l’héritage et l’abs­trac­tion, ce qui facilite le dé­ve­lop­pe­ment d’ap­pli­ca­tions complexes.

En utilisant les classes Ty­peS­cript, il est possible d’établir une hié­rar­chie ordonnée de classes per­met­tant l’héritage de pro­prié­tés et de méthodes, ce qui encourage la réu­ti­li­sa­tion du code et sa struc­tu­ra­tion efficace. Les cons­truc­teurs au sein de ces classes jouent un rôle crucial en ini­tia­li­sant les instances, assurant ainsi une création d’objets uniforme et conforme.

Comment se présente la syntaxe des classes Ty­peS­cript ?

L’écriture des classes Ty­peS­cript est similaire à celle de EC­MAS­cript 6 (ES6) et constitue une version plus élaborée de la syntaxe des classes Ja­vaS­cript. Une classe en Ty­peS­cript peut contenir dif­fé­rents éléments pour définir la structure et le com­por­te­ment des objets. Les prin­ci­paux éléments sont :

• Pro­prié­tés
• Cons­truc­teur
• Méthodes

Pro­prié­tés

Les pro­prié­tés dé­ter­mi­nent l’état d’un objet. Elles stockent des valeurs de données et peuvent être annotées avec des types de données afin qu’elles ne con­tien­nent que des valeurs valides.

class ClassName {
    propertyName: propertyType;
}

• ClassName : le nom de la classe
• pro­per­ty­Name : le nom de la propriété que vous souhaitez définir
• pro­per­ty­Type : le type de données de la propriété

Voici un exemple concret :

class Person {
    name: string;
}

Tout d’abord, une classe Person est définie avec une propriété name de type string. Cela signifie que les instances de la classe Person ont une propriété name qui stocke des chaînes de ca­rac­tères (strings).

Cons­truc­teur

En Ty­peS­cript, le cons­truc­teur est une méthode unique activée au moment de générer une instance (un objet) d’une classe. Son rôle est crucial pour définir les pro­prié­tés initiales d’un objet. Par ailleurs, ce cons­truc­teur établit l’état de départ de l’instance. Il est possible d’y insérer des pa­ra­mètres afin de fournir des valeurs spé­ci­fiques lors de la création d’instances de classes Ty­peS­cript.

La syntaxe de base d’un cons­truc­teur en Ty­peS­cript est la suivante :

class ClassName {
    constructor(parameter1: Type1, parameter2: Type2, ...) {
    }
}

• cons­truc­tor : chaque classe ne peut avoir qu’un seul cons­truc­teur. Si aucun cons­truc­teur n’est défini, un cons­truc­teur vide est créé par défaut.
• parameter: type : les pa­ra­mètres sont fa­cul­ta­tifs et dépendent de la classe et de ses exigences. Les pa­ra­mètres doivent être iden­ti­fiés par leur type de données.

Voici un exemple de cons­truc­teur :

class Person {
    firstName: string;
    lastName: string;
    constructor(firstName: string, lastName: string) {
        this.firstName = firstName;
        this.lastName = lastName;
    }
}

Dans cet exemple, la classe Person comprend un cons­truc­teur qui requiert deux pa­ra­mètres, firstName et lastName. À la création d’une instance de la classe, ces pa­ra­mètres doivent être fournis, per­met­tant au cons­truc­teur d’attribuer les valeurs reçues aux pro­prié­tés firstName et lastName de l’instance. Le terme this est utilisé pour faire référence à l’instance en cours de la classe, sur laquelle le code s’exécute.

Méthodes

Dans Ty­peS­cript, les méthodes sont des fonctions qui peuvent être définies dans les classes et ap­pli­quées à leurs instances. Les méthodes vous per­met­tent d’effectuer certaines actions ou opé­ra­tions dans le contexte d’une classe.

class ClassName {
    // ...
    methodName(parameter1: Type1, parameter2: Type2, ...): ReturnType {
    }
    // ...
}

• me­thod­Name : nom de la méthode
• parameter: type : pa­ra­mètres op­tion­nels acceptés par la méthode
• Re­turn­Type : type de données qui détermine la valeur que la méthode renvoie. Si la méthode ne renvoie rien, vous pouvez indiquer void.

Pour accéder à une propriété ou appeler une méthode sur une instance d’une classe, utilisez l’opérateur point . suivi du nom de la méthode et des arguments né­ces­saires si la méthode attend des pa­ra­mètres.

class Person {
    firstName: string;
    lastName: string;
    constructor(firstName: string, lastName: string) {
        this.firstName = firstName;
        this.lastName = lastName;
    }
    getFullName(): string {
        return this.firstName + " " + this.lastName;
    }
}
const person = new Person("John", "Doe");
const fullName = person.getFullName();

La méthode getFullName sert à créer et à renvoyer le nom complet de la personne. Elle accède aux valeurs des pro­prié­tés firstName et lastName, qui ont été définies dans la classe et ini­tia­li­sées dans le cons­truc­teur. L’objet person est créé par le mot-clé new suivi du nom de la classe et des pa­ra­mètres cor­res­pon­dants. Lors de l’appel, la méthode con­ca­té­nera les deux chaînes de ca­rac­tères et renverra le nom complet sous forme de chaîne de ca­rac­tères. Le résultat pour l’objet person est donc « John Doe ».

Les classes Ty­peS­cript : exemples d’uti­li­sa­tion

Les classes Ty­peS­cript possèdent dif­fé­rents mé­ca­nismes per­met­tant d’organiser et de contrôler la structure et le com­por­te­ment des objets. Nous vous pré­sen­tons ci-dessous dif­fé­rentes uti­li­sa­tions.

Vi­si­bi­lité

La vi­si­bi­lité dans les classes Ty­peS­cript régit l’accès aux pro­prié­tés et aux méthodes à l’intérieur et à l’extérieur de la classe. Ty­peS­cript propose trois mo­di­fi­ca­teurs de vi­si­bi­lité : public, private et protected.

• public (standard) : les pro­prié­tés et méthodes marquées par public peuvent être appelées de n’importe où, aussi bien à l’intérieur qu’à l’extérieur de la classe.
• private : private se réfère aux pro­prié­tés et méthodes qui ne peuvent être appelées qu’à l’intérieur de la classe elle-même. Elles sont inac­ces­sibles aux parties de code externes.
• protected : les pro­prié­tés et méthodes marquées par protected peuvent être appelées par la classe elle-même et par les classes dérivées (dans l’héritage), mais pas par du code externe.

class Person {
    private socialSecurityNumber: string;
    constructor(ssn: string) {
        this.socialSecurityNumber = ssn;
    }
    greet() {
        console.log("Hello, I am a person with SSN: " + this.socialSecurityNumber);
    }
}
const person = new Person("123-45-6789");
person.greet();

Dans cet exemple, socialSecurityNumber est une propriété privée qui n’est ac­ces­sible qu’à l’intérieur de la classe Person. La méthode greet peut cependant être appelée de l’extérieur.

Héritage

L’héritage est un concept fon­da­men­tal de la pro­gram­ma­tion orientée objet, utilisé dans Ty­peS­cript et dans de nombreux autres langages de pro­gram­ma­tion Web. Il permet de créer une nouvelle classe à partir d’une classe de base ou d’une su­per­classe existante. La classe dérivée (sous-classe) hérite alors des pro­prié­tés et des méthodes de la classe de base et peut l’étendre ou l’adapter.

class Animal {
    name: string;
    constructor(name: string) {
        this.name = name;
    }
    makeSound() {
        console.log("Some generic sound");
    }
}
class Dog extends Animal {
    makeSound() {
        console.log(this.name + " barks");
    }
}
const myDog = new Dog("Buddy");
myDog.makeSound();

Ici, la classe Dog hérite de la classe de base Animal à l’aide du mot-clé extends. La classe dérivée Dog écrase la méthode makeSound pour ajouter un com­por­te­ment spé­ci­fique, tout en prenant la propriété name de Animal.

Readonly

Le mot-clé readonly peut être utilisé pour déclarer des pro­prié­tés de classes ou d’objets Ty­peS­cript comme en lecture seule (Read only). Cela signifie qu’après l’ini­tia­li­sa­tion d’une propriété en lecture seule, sa valeur ne peut plus être modifiée.

class Circle {
    readonly pi: number = 3.14159;
    radius: number;
    constructor(radius: number) {
        this.radius = radius;
    }
    getArea() {
        return this.pi    *this.radius*    this.radius;
    }
}
const myCircle = new Circle(5);
console.log(myCircle.getArea()); // Output: ≈ 78,54

Dans cet exemple, la propriété pi est définie comme étant en lecture seule et reçoit une valeur lors de l’ini­tia­li­sa­tion dans le cons­truc­teur. Une fois ini­tia­li­sée, la mo­di­fi­ca­tion de pi est interdite. Toute tentative de changer sa valeur après son ini­tia­li­sa­tion en­traî­nera une erreur de com­pi­la­tion par Ty­peS­cript.