Les Getters et Setters en JavaScript

Ici, le getter balance formate la valeur pour garantir qu’elle est toujours affichée avec deux décimales, ce qui permet d’offrir une interface utilisateur cohérente.

3. Encapsulation de la Logique

Utiliser un getter est une bonne pratique pour encapsuler la logique d’accès à une propriété, surtout si cette logique peut évoluer avec le temps.

Cela permet d’isoler le changement et de minimiser les impacts sur le reste du code.

Dans cet exemple, fullName combine firstName et lastName, offrant une interface propre et intuitive pour accéder au nom complet de l’utilisateur. Si la structure du nom change à l’avenir, il suffira de modifier le getter sans impacter le reste du code.

4. Validation et Nettoyage des Données

Même si les setters sont généralement utilisés pour la validation, les getters peuvent également jouer un rôle dans la validation ou le nettoyage des données lorsqu’elles sont lues.

 
class User {
  constructor(email) {
    this._email = email;
  }

  get email() {
    return this._email.trim().toLowerCase();
  }
}

const user = new User('   Example@DOMAIN.COM ');
console.log(user.email); // example@domain.com

Dans cet exemple, le getter email s’assure que l’adresse email est toujours en minuscule et sans espaces inutiles avant d’être renvoyée, ce qui garantit une utilisation cohérente et propre de la donnée.

Les cas d’utilisation de getter sont divers et variés

Les getters sont essentiels lorsque vous souhaitez offrir un accès contrôlé, sécurisé et propre aux propriétés d’un objet.

Ils permettent de masquer les détails d’implémentation, d’effectuer des calculs dynamiques, et d’assurer que les données sont présentées de manière cohérente et formatée. En comprenant quand et comment les utiliser, vous pouvez concevoir des objets JavaScript plus robustes et maintenables.

Maintenant Voyons Quels sont les Cas d’utilisation des Setters en JavaScript ?

Les setters en JavaScript enferme la logique de modification des propriétés d’un objet.

Ils permettent non seulement de contrôler l’affectation des valeurs, mais aussi d’ajouter des vérifications ou transformations avant que ces valeurs ne soient enregistrées. Voici quelques situations où les setters sont particulièrement utiles :

1. Validation des Données

L’un des cas les plus courants pour utiliser un setter est de valider les données avant qu’elles ne soient attribuées à une propriété. Cela permet de garantir que seules des valeurs valides sont enregistrées dans l’objet.

 
class User {
  constructor(age) {
    this._age = age;
  }

  set age(value) {
    if (value > 0 && Number.isInteger(value)) {
      this._age = value;
    } else {
      console.log('Invalid age');
    }
  }
}

const user = new User(25);
user.age = -5; // Invalid age
console.log(user._age); // 25

Dans cet exemple, le setter age vérifie que l’âge est un nombre entier positif avant de l’affecter. Si la validation échoue, l’âge n’est pas modifié, ce qui protège l’intégrité des données.

2. Encapsulation de la Logique de Modification

Les setters permettent de centraliser la logique de modification des propriétés. Au lieu de disperser des vérifications ou des transformations dans tout le code, vous pouvez les encapsuler dans un setter. Cela rend le code plus propre et plus facile à maintenir.

Le setter salary garantit que le salaire ne peut pas être inférieur à un certain seuil, ce qui centralise la règle de gestion dans une seule méthode.

3. Transformation Automatique des Données

Les setters peuvent être utilisés pour transformer automatiquement les données avant qu’elles ne soient stockées dans une propriété.

Cela peut inclure des opérations comme la conversion de types, la mise en forme ou d’autres ajustements nécessaires.

4. Déclenchement d’Actions Additionnelles

Parfois, vous souhaitez que la modification d’une propriété déclenche d’autres actions, comme la mise à jour d’une interface utilisateur ou l’enregistrement de données dans une base.

Les setters offrent une façon propre de lier ces actions à des changements de propriété.

Dans cet exemple, à chaque fois que la température est modifiée via le setter temperature, l’affichage est automatiquement mis à jour en appelant la méthode updateDisplay.

5. Protection Contre les Modifications Directes

Enfin, les setters peuvent être utilisés pour protéger certaines propriétés contre les modifications directes, en appliquant des règles strictes ou en rendant certaines propriétés en lecture seule, sauf dans des conditions spécifiques.

 
class Account {
  constructor(balance) {
    this._balance = balance;
  }

  set balance(value) {
    console.log('Balance modification is not allowed directly.');
  }
}

const account = new Account(1000);
account.balance = 500; // Balance modification is not allowed directly.
console.log(account._balance); // 1000

 
class Car {
  constructor(brand, speed) {
    this._brand = brand;
    this._speed = speed;
  }

  get brand() {
    return this._brand;
  }

  set speed(value) {
    if (value > 0) {
      this._speed = value;
    }
  }
}

 
class BankAccount {
  constructor(balance) {
    this._balance = balance;
  }

  get balance() {
    return this._balance;
  }

  set balance(value) {
    if (value >= 0) {
      this._balance = value;
    }
  }
}

 
class Rectangle {
  constructor(width, height) {
    this._width = width;
    this._height = height;
  }

  get area() {
    return this._width * this._height;
  }

  set width(value) {
    this._width = value;
  }
}

Dans cet exemple, toute la logique concernant les dimensions et l’aire du rectangle est contenue dans la classe Rectangle, rendant le code plus intuitif et plus facile à suivre.

4. Facilité de Maintenance

En regroupant les getters et setters avec la définition de la classe, vous facilitez la maintenance de votre code.

Si la logique d’accès ou de modification d’une propriété doit être modifiée, vous savez exactement où chercher : dans la classe elle-même.

Cette centralisation réduit les risques d’introduire des bugs lors de mises à jour.

5. Conformité aux Principes de la POO

L’utilisation de getters et setters à l’intérieur de la classe est conforme aux principes de la programmation orientée objet, notamment le principe d’encapsulation et celui du moindre étonnement (principle of least astonishment).

Cela permet de créer des objets qui gèrent leurs propres états, conformément aux meilleures pratiques de la POO.

6. Interopérabilité avec les Outils et Frameworks

De nombreux outils et frameworks JavaScript s’attendent à ce que les méthodes de manipulation des propriétés soient définies à l’intérieur de la classe.

Par exemple, les frameworks de gestion d’état ou de liaison de données (comme Vue.js) peuvent utiliser les getters et setters pour détecter les changements de propriété et mettre à jour automatiquement l’interface utilisateur.

Définir ces méthodes à l’intérieur de la classe garantit une meilleure compatibilité.

Les Getters et les Setters dans les Classes Meilleure Option ?

 
const person = {
  firstName: 'John',
  lastName: 'Doe',
  // Définition d'un getter pour la propriété 'fullName'
  get fullName() {
    return `${this.firstName} ${this.lastName}`;
  },
  // Définition d'un setter pour la propriété 'fullName'
  set fullName(name) {
    const [first, last] = name.split(' ');
    this.firstName = first;
    this.lastName = last;
  }
};

// Utilisation du getter
console.log(person.fullName); // John Doe

// Utilisation du setter
person.fullName = 'Jane Smith';
console.log(person.firstName); // Jane
console.log(person.lastName); // Smith

 
function Person(firstName, lastName) {
  this.firstName = firstName;
  this.lastName = lastName;

  Object.defineProperty(this, 'fullName', {
    get() {
      return `${this.firstName} ${this.lastName}`;
    },
    set(name) {
      const [first, last] = name.split(' ');
      this.firstName = first;
      this.lastName = last;
    }
  });
}

const person = new Person('John', 'Doe');
console.log(person.fullName); // John Doe

person.fullName = 'Jane Smith';
console.log(person.firstName); // Jane
console.log(person.lastName); // Smith

Le Guide Bonus Exclusif

En allant plus loin, avec ce Guide Bonus Exclusif rien que pour Toi !

Voici un guide complet sur le JavaScript, où tu verras des techniques pour performer en programmation Js.

Ce guide te permettra de perfectionner tes compétences et de devenir un expert JavaScript. Ne le rate pas et développe ton expertise !

En adoptant ce qu’il contient, tu rends ton apprentissage de JavaScript plus performant avec une plus grande facilité tous les jours . Voici de quoi enrichir tout de suite ton savoir-faire ? Le guide complet t’attend !