Modificateurs d'accès TypeScript
Les modificateurs d’accès sont l’une des fonctionnalités principales de la programmation orientée objet en TypeScript.
Ils servent à contrôler la visibilité des membres d'une classe (propriétés, méthodes, constructeurs).
Grâce aux modificateurs d'accès, l'encapsulation peut être réalisée, protégeant les détails d'implémentation internes d'une classe.
Diagramme SVG : portée des modificateurs d'accès
Pourquoi avons-nous besoin de modificateurs d'accès ?
L'encapsulation est l'un des trois principes de la programmation orientée objet.
L'encapsulation consiste à masquer les données et les méthodes qui opèrent sur ces données, en n'exposant vers l'extérieur que les interfaces nécessaires.
Les modificateurs d'accès sont le moyen de réaliser l'encapsulation ; ils contrôlent la portée de visibilité des membres d'une classe.
Explication du concept :Les modificateurs d'accès déterminent où l'on peut accéder aux membres d'une classe. TypeScript fournit trois modificateurs d'accès : public, protected et private.
modificateur public
public est le modificateur d'accès par défaut, ce qui signifie que les membres sont accessibles partout.
Que ce soit à l'intérieur de la classe, dans une sous-classe ou à l'extérieur de la classe, les membres publics sont accessibles.
Exemple
class Animal {
// Utiliser public pour modifier la propriété name (peut être omis, public par défaut)
public name: string;
// Constructeur
public constructor(name: string) {
this.name = name;
}
// Méthode publique speak
public speak(): void {
console.log(this.name + " émet un son");
}
}
// Créer une instance
var animal = new Animal("Animal");
// Accéder à une propriété publique en dehors de la classe
console.log(animal.name);
// Appeler une méthode publique en dehors de la classe
animal.speak();
Sortie :
animal Animals make sounds.
Explication :Si vous n'écrivez pas de modificateur d'accès, TypeScript utilisera public par défaut. Par conséquent, public peut être omis, mais pour la clarté du code, il est recommandé de le déclarer explicitement.
modificateur private
private indique des membres privés, qui ne sont accessibles qu'à l'intérieur de la classe où ils sont définis.
Ni les sous-classes ni l'extérieur de la classe ne peuvent accéder aux membres privés.
Ceci est souvent utilisé pour masquer les détails d'implémentation internes d'une classe et protéger les données contre une modification accidentelle.
Exemple
class BankAccount {
// Utiliser private pour modifier le solde, accessible uniquement à l'intérieur de la classe
private balance: number;
// Constructeur
constructor(initialBalance: number) {
this.balance = initialBalance;
}
// Méthode de dépôt
public deposit(amount: number): void {
if (amount > 0) {
this.balance += amount; // Les propriétés privées sont accessibles à l'intérieur de la classe
console.log("Dépôt réussi, solde actuel : " + this.balance);
}
}
// Obtenir le solde
public getBalance(): number {
return this.balance; // Les propriétés privées sont accessibles à l'intérieur de la classe
}
}
// Créer une instance de compte
var account = new BankAccount(1000);
// Dépôt
account.deposit(500);
// Obtenir le solde via une méthode publique
console.log("Solde : " + account.getBalance());
// Erreur : les propriétés privées ne sont pas accessibles directement en dehors de la classe
// console.log(account.balance); // Erreur de compilation !
Sortie :
存款成功,当前余额: 1500 余额: 1500
Bonne pratique :Rendre l'état interne d'une classe privé et fournir un accès contrôlé par des méthodes publiques est la méthode standard pour mettre en œuvre l'encapsulation.
modificateur protected
protected indique les membres protégés, qui sont accessibles à l'intérieur de la classe et dans les sous-classes.
L'extérieur de la classe ne peut pas accéder directement aux membres protégés.
C'est très utile lorsque vous avez besoin que les sous-classes héritent de certaines fonctionnalités de la classe parente tout en masquant les détails d'implémentation.
Exemple
class Person {
// Utiliser protected pour modifier name, accessible dans les sous-classes
protected name: string;
constructor(name: string) {
this.name = name;
}
}
// Définir une classe Employee qui hérite de Person
class Employee extends Person {
// Department est private
private department: string;
constructor(name: string, department: string) {
super(name); // Appeler le constructeur de la classe parente
this.department = department;
}
// Méthode d'auto-présentation
public introduce(): string {
// Les sous-classes peuvent accéder au membre protégé name
return "Je suis " + this.name + ", au " + this.department + " travaillant";
}
}
// Créer une instance d'Employee
var emp = new Employee("Alice", "Département Technologique");
console.log(emp.introduce());
// Erreur : les membres protégés ne sont pas accessibles en dehors de la classe
// console.log(emp.name); // Erreur de compilation !
Sortie :
我是 Alice,在 技术部 工作
Cas d'utilisation :protected est souvent utilisé pour définir des propriétés que les sous-classes doivent utiliser mais qui ne doivent pas être exposées à l'extérieur.
modificateur readonly
readonly est utilisé pour définir des propriétés en lecture seule.
Elles ne peuvent être affectées que lors de la déclaration ou dans le constructeur, et ne peuvent pas être modifiées par la suite.
C'est très utile pour définir des constantes ou des identifiants.
Exemple
class User {
// Les propriétés modifiées avec readonly ne peuvent être affectées que lors de l'initialisation
// ID utilisateur
readonly id: number;
// Nom d'utilisateur
readonly name: string;
constructor(id: number, name: string) {
this.id = id;
this.name = name;
}
}
// Créer une instance de User
var user = new User(1, "Alice");
console.log("User: " + user.id + ", " + user.name);
// Erreur : les propriétés readonly ne peuvent pas être modifiées
// user.id = 2; // Erreur de compilation !
// user.name = "Bob"; // Erreur de compilation !
Sortie :
User: 1, Alice
Remarque :readonly et private n'entrent pas en conflit. Vous pouvez utiliser readonly et private ensemble ; la propriété ne peut être ni modifiée ni accessible depuis l'extérieur.
Propriétés de paramètres
TypeScript fournit une syntaxe abrégée pour les propriétés de paramètres.
Les modificateurs d'accès peuvent être utilisés directement sur les paramètres du constructeur pour créer et initialiser automatiquement des propriétés.
Exemple
class Point {
// Utiliser les modificateurs directement sur les paramètres du constructeur
// Équivalent à déclarer des propriétés et à affecter des valeurs en même temps
constructor(
// modificateur public : crée la propriété publique x
public x: number,
// modificateur public : crée la propriété publique y
public y: number,
// modificateur privé : crée la propriété privée z
private z: number
) {
// Le corps du constructeur peut être vide ; les propriétés sont créées automatiquement
}
// Calculer la somme des trois dimensions
public sum(): number {
// Toutes les propriétés sont accessibles à l'intérieur de la classe
return this.x + this.y + this.z;
}
}
// Créer une instance de Point
var point = new Point(1, 2, 3);
// Les propriétés publiques sont accessibles depuis l'extérieur
console.log("x: " + point.x);
console.log("y: " + point.y);
// Appeler la méthode
console.log("Somme : " + point.sum());
// Erreur : les propriétés privées ne sont pas accessibles depuis l'extérieur
// console.log(point.z); // Erreur de compilation !
Sortie :
x: 1 y: 2 总和: 6
Code simplifié :Les propriétés de paramètre peuvent grandement simplifier les définitions de classe, en évitant le code répétitif de déclaration et d'affectation.
Comparaison des modificateurs d'accès
Voici une comparaison de la portée des trois modificateurs d'accès.
| Modificateur | Dans la classe | Sous-classe | En dehors de la classe (instance) |
|---|---|---|---|
| public | ✓ Accessible | ✓ Accessible | ✓ Accessible |
| protected | ✓ Accessible | ✓ Accessible | ✗ Inaccessible |
| private | ✓ Accessible | ✗ Inaccessible | ✗ Inaccessible |
Suggestions de sélection :Par défaut, utilisez private. Utilisez protected lorsqu'un accès depuis une sous-classe est nécessaire. Utilisez public lorsqu'un accès public complet est requis.
Notes
- Modificateur par défaut :Lorsqu'aucun modificateur n'est écrit, il vaut public par défaut
- Constructeur :Les constructeurs peuvent aussi utiliser des modificateurs d'accès pour contrôler les autorisations d'instanciation
- Combinaison avec readonly :readonly peut être combiné avec public, protected et private
- Impact sur la compilation :Les modificateurs d'accès ne sont vérifiés qu'à la compilation et n'ont aucun effet à l'exécution
Bonnes pratiques :Utilisez le modificateur d'accès le plus restrictif possible. N'exposez que les interfaces publiques nécessaires et rendez les implémentations internes private ou protected.
Résumé
Les modificateurs d'accès sont l'outil central de TypeScript pour implémenter l'encapsulation.
- public:Accès public, la valeur par défaut
- private:Privé, visible uniquement à l'intérieur de la classe
- protected:Protégé, visible à l'intérieur de la classe et des sous-classes
- readonly:Lecture seule, ne peut pas être modifié après l'initialisation
- Propriétés de paramètres :Syntaxe pour simplifier les déclarations de propriétés
Autres extensionsRecommandations :Prenez l'habitude d'utiliser des modificateurs d'accès ; c'est la base pour écrire du code TypeScript de haute qualité.