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 Background Title Scope of Access Modifiers public Inside class ✓ Subclass ✓ External ✓ protected Inside class ✓ Subclass ✓ External ✗ private Inside class ✓ Subclass ✗ External ✗ Example area Use cases public scenario public Public methods/properties E.g., user name, login method protected scenario protected Methods visible to subclasses E.g., calculation formulas, template methods private scenario private Internal implementation details E.g., database connection, internal calculations

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

// Définir une classe Animal
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

// Définir une classe de compte bancaire
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

// Définir une classe de base Person
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

// Définir une classe User
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

// Définir une classe Point
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

Recommandations :Prenez l'habitude d'utiliser des modificateurs d'accès ; c'est la base pour écrire du code TypeScript de haute qualité.

Autres extensions