TypeScript - Modificateurs d'accès : Votre guide amical pour la confidentialité du code

Bonjour là-bas, future star du codage ! ? Je suis ravi de vous guider sur ce voyage passionnant à travers les modificateurs d'accès de TypeScript. En tant que quelqu'un qui enseigne la programmation depuis des années, je peux vous dire que comprendre ces concepts, c'est comme apprendre les poignées de main secrètes du monde du codage. Alors, plongeons dedans et découvrons ces mystères ensemble !

Qu'est-ce que les modificateurs d'accès ?

Avant de rentrer dans les détails, parlons de ce que sont les modificateurs d'accès. Imaginez que vous construisez une superbe cabane dans un arbre (ceci est notre code !). Les modificateurs d'accès sont comme les règles que vous définissez pour savoir qui peut grimper, qui peut jeter un coup d'œil à l'intérieur, et qui peut utiliser les compartiments secrets. Ils nous aident à contrôler comment les différentes parties de notre code peuvent être accédées et utilisées.

En TypeScript, nous avons trois principaux modificateurs d'accès :

Modificateur	Description
public	Accessible depuis n'importe où
private	Accès uniquement à l'intérieur de la même classe
protected	Accès à l'intérieur de la classe et ses sous-classes

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

Modificateur d'accès public

Le modificateur public est comme laisser la porte de votre cabane grande ouverte. N'importe qui peut entrer, utiliser le balançoire, ou emprunter vos bandes dessinées. En termes de code, cela signifie que n'importe quelle partie de votre programme peut accéder et utiliser ces éléments.

Voici un exemple amusant :

class Superhero {
public name: string;
public power: string;

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

public usePower() {
console.log(`${this.name} utilise ${this.power} !`);
}
}

const spiderman = new Superhero("Spider-Man", "lancer des toiles");
console.log(spiderman.name); // Outputs: Spider-Man
spiderman.usePower(); // Outputs: Spider-Man utilise lancer des toiles !

Dans cet exemple, name, power, et usePower() sont tous public. Nous pouvons les accéder et les utiliser depuis n'importe où dans notre code. C'est comme Spider-Man qui se déplace librement à travers la ville !

Modificateur d'accès private

Maintenant, parlons de private. C'est comme avoir un journal secret dans votre cabane que seulement vous pouvez lire. En TypeScript, les membres private ne peuvent être accédés qu'à l'intérieur de la même classe.

Mettons à jour notre classe Superhero :

class Superhero {
public name: string;
private secretIdentity: string;

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

private changeClothes() {
console.log("Changement rapide dans une cabine téléphonique !");
}

public goOnMission() {
this.changeClothes();
console.log(`${this.name} est prêt à l'action !`);
}
}

const superman = new Superhero("Superman", "Clark Kent");
console.log(superman.name); // Outputs: Superman
// console.log(superman.secretIdentity); // Error! secretIdentity est private
// superman.changeClothes(); // Error! changeClothes() est private
superman.goOnMission(); // Ça fonctionne ! Outputs: Changement rapide dans une cabine téléphonique ! Superman est prêt à l'action !

Voyez comment nous ne pouvons pas accéder à secretIdentity ou appeler changeClothes() directement ? C'est la puissance du private ! Il garde les secrets de Superman en sécurité.

Modificateur d'accès protected

Enfin, nous avons protected. Pensez à cela comme une règle spéciale de la cabane qui s'applique à vous et à vos frères et sœurs, mais pas aux enfants du quartier. En TypeScript, les membres protected sont accessibles à l'intérieur de la classe et de ses sous-classes.

Créons une famille de Superhéros :

class Superhero {
public name: string;
protected superpower: string;

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

protected useSuperpowerInternal() {
console.log(`Utilisation ${this.superpower} en interne`);
}
}

class Sidekick extends Superhero {
public useSuperheroPower() {
console.log(`${this.name} emprunte le pouvoir : ${this.superpower}`);
this.useSuperpowerInternal();
}
}

const batman = new Superhero("Batman", "gadgets");
const robin = new Sidekick("Robin", "acrobaties");

// console.log(batman.superpower); // Error! superpower est protected
// batman.useSuperpowerInternal(); // Error! useSuperpowerInternal() est protected

robin.useSuperheroPower(); // Ça fonctionne ! Outputs: Robin emprunte le pouvoir : acrobaties Utilisation acrobaties en interne

Ici, Sidekick peut accéder aux membres protected de Superhero, mais nous ne pouvons pas y accéder directement de l'extérieur des classes.

Conclusion

Et voilà, mes apprentis codeurs ! Nous avons exploré le monde secret des modificateurs d'accès de TypeScript. Souvenez-vous :

1. public est pour tout le monde (comme un parc public)
2. private est juste pour la classe elle-même (comme votre journal personnel)
3. protected est pour la classe et ses enfants (comme les secrets de famille)

Utiliser ces modificateurs avec sagesse vous aidera à créer du code plus sûr, mieux organisé et plus facile à entretenir. C'est comme être un superhéros du monde de la programmation - vous savez quand partager vos pouvoirs et quand les garder cachés !

Alors continuez à coder, continuez à apprendre, et souvenez-vous : avec de grands pouvoirs vient une grande responsabilité... et des classes TypeScript vraiment cool ! ??‍♂️?‍♀️

Credits: Image by storyset