Encapsulation

9.1 Concepts de base

Encapsulation — c'est l'une des idées clés de la programmation orientée objet (OOP), qui permet de cacher les détails internes d'un objet et de fournir un accès à ces détails via des interfaces strictement définies. Cela aide à améliorer la sécurité et simplifie la gestion du code.

Avantages de l'encapsulation :

1. Caché des données : l'encapsulation permet de masquer les détails internes de l'implémentation et de ne fournir un accès qu'aux méthodes et propriétés nécessaires. Cela empêche l'utilisation incorrecte des objets et améliore la sécurité du code.
2. Contrôle d'accès : l'encapsulation permet de contrôler l'accès aux données et aux méthodes, permettant de modifier l'état interne de l'objet uniquement via des méthodes définies.
3. Maintenance : l'encapsulation améliore la maintenance du code car les modifications de l'implémentation n'affectent pas l'interface externe de la classe. Cela permet de modifier l'implémentation sans modifier le code qui utilise la classe.
4. Amélioration des tests : l'encapsulation permet d'isoler l'implémentation interne d'un objet, ce qui simplifie les tests unitaires et réduit le risque d'effets secondaires.

En JavaScript, l'encapsulation est réalisée en utilisant des méthodes et des propriétés, et à partir d'ES2022, des champs et méthodes privés sont également disponibles.

9.2 Encapsulation via les closures

Avant l'introduction des champs privés dans ES2022, l'encapsulation en JavaScript était souvent réalisée à l'aide des closures.

Exemple :

• La variable count est accessible uniquement à l'intérieur de la fonction createCounter et n'est pas accessible de l'extérieur
• Les méthodes increment, decrement et getCount peuvent interagir avec la variable privée count

    
      function createCounter() {
        let count = 0; // variable privée

        return {
          increment() {
            count++;
            console.log(count);
          },
          decrement() {
            count--;
            console.log(count);
          },
          getCount() {
            return count;
          }
        };
      }

      const counter = createCounter();
      counter.increment(); // 1
      counter.increment(); // 2
      console.log(counter.getCount()); // 2
      counter.decrement(); // 1
    
  

9.3 Champs privés dans ES2022

Dans ES2022, des champs et méthodes privés ont été introduits, qui sont déclarés en utilisant le symbole #. Les champs et méthodes privés ne peuvent pas être accessibles ou modifiés de l'extérieur de la classe.

Exemple :

• Les champs privés #name et #age sont déclarés en utilisant le symbole #
• Les méthodes getName, getAge, setName et setAge permettent d'interagir avec les champs privés
• Une tentative d'accès aux champs privés de l'extérieur de la classe entraîne une erreur

    
      class Person {
        #name; // champ privé
        #age; // champ privé

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

        getName() {
          return this.#name;
        }

        getAge() {
          return this.#age;
        }

        setName(name) {
          this.#name = name;
        }

        setAge(age) {
          if (age > 0) {
            this.#age = age;
          }
        }
      }

      const person = new Person('Alice', 30);
      console.log(person.getName()); // "Alice"
      console.log(person.getAge()); // 30
      person.setName('Bob');
      person.setAge(25);
      console.log(person.getName()); // "Bob"
      console.log(person.getAge()); // 25
      
      console.log(person.#name); // Erreur : champ privé inaccessible
    
  

9.4 Méthodes privées

Les méthodes privées peuvent également être déclarées en utilisant le symbole # et être inaccessibles de l'extérieur de la classe.

Exemple :

• Le champ privé #balance et la méthode privée #logTransaction sont utilisés pour gérer l'état de l'objet BankAccount
• La méthode privée #logTransaction est appelée à l'intérieur des méthodes publiques deposit et withdraw pour enregistrer les transactions

    
      class BankAccount {
        #balance;

        constructor(initialBalance) {
          this.#balance = initialBalance;
        }

        deposit(amount) {
          if (amount > 0) {
            this.#balance += amount;
            this.#logTransaction('deposit', amount);
          }
        }

        withdraw(amount) {
          if (amount > 0 && amount <= this.#balance) {
            this.#balance -= amount;
            this.#logTransaction('withdraw', amount);
          }
        }

        getBalance() {
          return this.#balance;
        }

        #logTransaction(type, amount) {
          console.log(`Transaction: ${type} ${amount}`);
        }
      }

      const account = new BankAccount(1000);
      account.deposit(500); // "Transaction: deposit 500"
      console.log(account.getBalance()); // 1500
      account.withdraw(200); // "Transaction: withdraw 200"
      console.log(account.getBalance()); // 1300
      
      account.#logTransaction('test', 100); // Erreur : méthode privée inaccessible