0Pricing
TypeScript Academy · Leçon

Modificateurs public, private et protected

Contrôlez l’accès aux membres des classes avec des modificateurs

Modificateurs public, private et protected est une leçon TypeScript Academy gratuite sur CoddyKit. Ceci est la leçon 2 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage TypeScript Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours TypeScript Academy comprend 4 leçons au total.

Bienvenue

Les modificateurs d’accès de TypeScript contrôlent la visibilité des membres d’une classe. Ils contribuent à l’encapsulation et empêchent les utilisations involontaires.

public : accessible partout

public est le modificateur par défaut. Les membres publics sont accessibles depuis n’importe où — dans la classe, les sous-classes et le code externe.
class Car {
  public brand: string;
  constructor(brand: string) { this.brand = brand; }
}
const c = new Car('Toyota');
console.log(c.brand); // OK

private : accès limité à la classe

Les membres privés sont accessibles uniquement au sein de la classe qui les déclare. Les sous-classes et le code externe ne peuvent pas y accéder.
class BankAccount {
  private balance: number = 0;
  deposit(n: number) { this.balance += n; }
}
const a = new BankAccount();
// a.balance; // Error!

protected : accès à la classe et aux sous-classes

Les membres protégés sont accessibles dans la classe qui les déclare et dans toutes ses sous-classes, mais pas depuis le code externe.
class Animal {
  protected name: string;
  constructor(name: string) { this.name = name; }
}
class Dog extends Animal {
  bark() { console.log(this.name + ' says woof!'); } // OK
}

Vérification uniquement à la compilation

Les modificateurs d’accès de TypeScript ne sont vérifiés qu’à la compilation. Le code JavaScript produit contient toujours des propriétés publiques : aucune vérification n’est effectuée à l’exécution.

Champs privés JavaScript avec #

JavaScript possède des champs privés natifs avec `#`, dont l’accès est contrôlé à l’exécution. TypeScript prend en charge cette syntaxe en plus de son propre mot-clé `private`.
class Counter {
  #count = 0; // runtime private (JavaScript)
  increment() { this.#count++; }
  get value() { return this.#count; }
}

Modificateur readonly

Les propriétés readonly ne peuvent être définies que pendant la construction. Elles ne peuvent plus être modifiées après leur initialisation.
class User {
  readonly id: number;
  constructor(id: number) { this.id = id; }
}
const u = new User(1);
// u.id = 2; // Error!

Combiner les modificateurs

Vous pouvez combiner des modificateurs d’accès avec readonly sur une même propriété.
class Config {
  constructor(
    public readonly host: string,
    private readonly port: number
  ) {}
}

private sur un constructeur

Rendre un constructeur privé empêche son instanciation depuis l’extérieur. Utilisez plutôt des méthodes statiques de fabrique.
class Singleton {
  private static instance: Singleton;
  private constructor() {}
  static getInstance(): Singleton {
    return this.instance ??= new Singleton();
  }
}

Constructeur protected

Un constructeur protégé empêche l’instanciation directe, mais permet aux sous-classes de l’appeler via super().
class Base {
  protected constructor(public id: number) {}
}
class Derived extends Base {
  constructor(id: number) { super(id); }
}

Les modificateurs d’accès n’ajoutent aucune surcharge à l’exécution

Comme TypeScript supprime toutes les informations de type, les modificateurs d’accès n’ont aucun impact sur la taille ni sur les performances du code JavaScript compilé.

Vérification rapide

Quel modificateur d’accès rend un membre de classe accessible dans la classe et ses sous-classes (AND), mais pas depuis le code externe (NOT) ?

Récapitulatif

Utilisez public (par défaut) pour les membres accessibles, private pour les éléments internes encapsulés et protected pour les membres destinés aux sous-classes. Ajoutez readonly pour empêcher toute modification après la construction.

Questions Fréquemment Posées

La leçon « Modificateurs public, private et protected » est-elle gratuite ?

Oui — le texte complet de « Modificateurs public, private et protected » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours TypeScript Academy, passe à CoddyKit PRO. Le cours TypeScript Academy comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « Modificateurs public, private et protected » ?

Contrôlez l’accès aux membres des classes avec des modificateurs Tu pratiques TypeScript Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer TypeScript Academy ?

Aucune expérience préalable n'est requise. TypeScript Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 2 sur 4.

Combien de temps prend la leçon « Modificateurs public, private et protected » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon TypeScript Academy ?

Oui. Chaque leçon TypeScript Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

  1. Classes et constructeurs TypeScript
  2. Modificateurs public, private et protected
  3. Propriétés readonly et propriétés de paramètres
  4. Implémenter des interfaces avec des classes
← Retour à TypeScript Academy