Classes JavaScript : Encapsulation

Maîtriser class, constructor, this et les propriétés privées #

Objectifs de la leçon

1. Maîtriser la syntaxe

class, constructor et this

2. Comprendre new

Ce que fait le mot-clé new

3. Propriétés privées #

Protéger les données vraiment

4. Getters

Exposer en lecture seule

5. Encapsulation

Personne ne touche mes données directement

Plan du cours

1. Rappel

class, constructor, this — solidifier les bases

2. Le problème

N'importe qui peut modifier les propriétés

3. Propriétés privées #

Personne ne touche mes données de l'extérieur

4. Getters

Exposer des données en lecture seule

5. Graine d'architecture

Private = protéger l'état interne (futur aggregate)

Module 1

Rappel : class, constructor, this

Solidifier les bases

La syntaxe class

Un template pour créer des objets

class User {

name;

age;

}

Une class définit la structure de vos objets

Le constructor

Initialiser les propriétés à la création

class User {

constructor(name, age) {

this.name = name;

this.age = age;

}

}

constructor() est appelé automatiquement avec new

this — L'instance courante

this = l'objet en cours de création

const user1 = new User('Alice', 25);

// this = user1

const user2 = new User('Bob', 30);

// this = user2

new — Ce qui se passe

new fait 4 choses en arrière-plan

1 Crée un objet vide {}

2 Lie this à cet objet

3 Exécute constructor()

4 Retourne l'objet créé

Module 2

Le problème

N'importe qui peut modifier les propriétés directement

Le problème : accès direct

const user = new User('Alice', 25);

user.age = -5; // 😱 Valide mais absurde!

user.name = null; // 😱 Pas de validation

Les propriétés sont publiques par défaut

N'importe qui peut les modifier sans contrôle

Besoin de protection

Sans protection

• • Données invalides possibles
• • Pas de validation
• • État incohérent
• • Bugs difficiles à tracer

Avec protection

• • Données validées
• • Contrôle total
• • État cohérent garanti
• • Code prévisible

Module 3

Propriétés privées #

Personne ne touche mes données de l'extérieur

La syntaxe #propriete

Vraiment privé, pas juste une convention

class User {

#name; // propriété privée

#age; // propriété privée

constructor(name, age) {

this.#name = name;

this.#age = age;

}

}

Accès depuis l'extérieur = ERREUR

const user = new User('Alice', 25);

user.#age; // SyntaxError!

Impossible d'accéder à #age depuis l'extérieur

C'est une ERREUR JavaScript, pas juste une convention

Convention vs Vrai privé

_convention (faux privé)

this._age = 25;

user._age = -5; // ✅ Ça marche!

Juste une convention, pas de protection

#vraiPrivé

this.#age = 25;

user.#age = -5; // ❌ SyntaxError!

Vraiment protégé par le langage

Module 4

Getters

Exposer des données en lecture seule

Syntaxe get

Lire sans pouvoir modifier

class User {

#age;

constructor(age) { this.#age = age; }

get age() {

return this.#age;

}

}

user.age → lit la valeur

user.age = 30 → impossible sans setter

Getter + Setter avec validation

class User {

#age;

get age() { return this.#age; }

set age(value) {

if (value < 0) throw new Error('Âge invalide');

this.#age = value;

}

}

Maintenant l'âge est validé !

Module 5

Graine d'architecture

Private = protéger l'état interne

Pourquoi protéger l'état ?

"Un objet doit garantir que son état reste valide"

État interne protégé

Personne ne peut casser l'objet

Accès contrôlé

Via getters/setters uniquement

Lien avec Clean Architecture

Les aggregates protègent leur état exactement comme ça

Dans l'architecture Clean :

• • Les Aggregates ont des propriétés privées
• • Les méthodes modifient l'état de façon contrôlée
• • Jamais d'accès direct aux propriétés

Pièges courants

Les erreurs à éviter

Piège #1 : Confondre _ et #

✗ ERREUR

this._age = 25;

// Juste une convention

// Pas de protection réelle

✓ CORRECT

this.#age = 25;

// Vraiment privé

// Erreur si accès externe

Piège #2 : Oublier le # dans this.#prop

✗ ERREUR

this.age = 25;

// Crée une propriété publique!

// #age reste undefined

✓ CORRECT

this.#age = 25;

// Accède à la propriété privée

Piège #3 : Accéder à # depuis l'extérieur

const user = new User('Alice', 25);

user.#age; // SyntaxError: Private field...

Solution : utiliser un getter

user.age; // ✅ Via getter public

Points clés à retenir

# = Vrai privé

Erreur si accès externe, pas juste une convention

Getter

Exposer en lecture seule, contrôle total

Encapsulation

Protéger les données = état valide garanti

Architecture

Les aggregates font exactement ça

À retenir !

• ✓ #propriete est réellement privée — erreur si accès externe
• ✓ Un getter permet de lire sans modifier
• ✓ Protéger les données garantit un état valide
• ✓ C'est le fondement des aggregates en Clean Architecture

C'est terminé !

Vous savez maintenant protéger vos données

Questions ?