TypeScript - Accesseurs

Bonjour à tous, futurs programmeurs ! Aujourd'hui, nous allons plonger dans le monde fascinant des accesseurs TypeScript. Ne vous inquiétez pas si vous êtes nouveaux en programmation - je vais vous guider pas à pas à travers ce sujet, tout comme j'ai fait pour des centaines d'étudiants au fil des ans. Alors, prenez une tasse de votre boisson favorite et c'est parti !

Qu'est-ce que les Accesseurs ?

Avant de nous plonger dans les détails des accesseurs TypeScript, comprenons ce qu'are les accesseurs en général. Imaginez que vous avez un coffre au trésor (c'est notre objet), et que vous souhaitez contrôler comment les gens interagissent avec les trésors à l'intérieur (les propriétés de l'objet). Les accesseurs sont comme les clés magiques qui vous permettent d'obtenir ou de définir ces trésors de manière contrôlée.

En TypeScript, nous avons deux types d'accesseurs :

1. Getters : Ils nous aident à récupérer la valeur d'une propriété.
2. Setters : Ils nous permettent de définir la valeur d'une propriété.

Maintenant, explorons chacun de ces éléments en détail.

Getters en TypeScript

Qu'est-ce qu'un Getter ?

Un getter est une méthode spéciale qui vous permet d'accéder à une propriété d'un objet. C'est comme avoir un assistant personnel qui vous fetch l'information.

Comment définir un Getter

Regardons un exemple simple :

class Person {
private _name: string;

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

get name(): string {
console.log("Obtention du nom");
return this._name;
}
}

let person = new Person("Alice");
console.log(person.name); // Output: Obtention du nom \n Alice

Dans cet exemple :

• Nous avons une classe Person avec une propriété privée _name.
• Nous définissons un getter appelé name en utilisant le mot-clé get.
• Quand nous accédons à person.name, il appelle notre méthode getter.

Pourquoi utiliser des Getters ?

1. Propriétés calculées : Les getters peuvent retourner des valeurs calculées.

class Circle {
private _radius: number;

constructor(radius: number) {
this._radius = radius;
}

get area(): number {
return Math.PI * this._radius ** 2;
}
}

let circle = new Circle(5);
console.log(circle.area); // Output: 78.53981633974483

2. Chargement paresseux : Les getters peuvent aider à optimiser les performances en chargeant les données uniquement lorsque cela est nécessaire.

class DataFetcher {
private _data: string | null = null;

get data(): string {
if (this._data === null) {
console.log("Récupération des données...");
this._data = "Des données coûteuses";
}
return this._data;
}
}

let fetcher = new DataFetcher();
console.log(fetcher.data); // Output: Récupération des données... \n Des données coûteuses
console.log(fetcher.data); // Output: Des données coûteuses (pas de récupération cette fois)

Setters en TypeScript

Qu'est-ce qu'un Setter ?

Un setter est comme le counterpart d'un getter. C'est une méthode qui définit la valeur d'une propriété, souvent avec un peu de logique supplémentaire.

Comment définir un Setter

Voici un exemple de base :

class Temperature {
private _celsius: number = 0;

set celsius(value: number) {
if (value < -273.15) {
throw new Error("La température en dessous du zéro absolu n'est pas possible");
}
this._celsius = value;
}

get celsius(): number {
return this._celsius;
}
}

let temp = new Temperature();
temp.celsius = 25; // Cela appelle le setter
console.log(temp.celsius); // Output: 25

// temp.celsius = -300; // Cela lancerait une erreur

Dans cet exemple :

• Nous avons une classe Temperature avec une propriété privée _celsius.
• Nous définissons un setter pour celsius qui vérifie si la valeur est valide avant de la définir.

Pourquoi utiliser des Setters ?

1. Validation des données : Les setters peuvent garantir que seules les valeurs valides sont affectées aux propriétés.

2. Effets secondaires : Les setters peuvent déclencher d'autres actions lorsque une propriété est modifiée.

class User {
private _name: string = "";
private _lastUpdated: Date = new Date();

set name(value: string) {
this._name = value;
this._lastUpdated = new Date();
}

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

get lastUpdated(): Date {
return this._lastUpdated;
}
}

let user = new User();
user.name = "Bob";
console.log(user.name); // Output: Bob
console.log(user.lastUpdated); // Output: Date et heure actuelle

Tableau des Méthodes Accesseurs

Voici un résumé des méthodes accesseurs que nous avons couvertes :

Type d'Accesseur	Mot-clé	Objectif	Exemple
Getter	get	Récupérer une valeur de propriété	get name(): string { return this._name; }
Setter	set	Définir une valeur de propriété	set name(value: string) { this._name = value; }

Conclusion

Les accesseurs en TypeScript offrent un moyen puissant de contrôler la manière dont les propriétés des objets sont accédées et modifiées. Ils vous permettent d'ajouter de la logique, de la validation et des propriétés calculées à vos classes, rendant votre code plus robuste et plus facile à维护.

N'oubliez pas, comme pour toute nouvelle compétence, maîtriser les accesseurs nécessite de la pratique. Ne soyez pas découragé si cela ne vous vient pas immédiatement - continuez à coder, continuez à expérimenter, et bientôt vous utiliserez les getters et setters comme un pro !

Comme je le dis toujours à mes élèves, la programmation est comme apprendre une nouvelle langue. Au début, cela peut sembler confus, mais avec de la patience et de la pratique, vous serez bientôt "parler" TypeScript couramment. Bonne programmation, et n'oubliez pas de vous amuser en cours de route !

Credits: Image by storyset