Modèles de conception de logiciels : la sauce secrète derrière chaque grande application

Imaginez construire un ensemble LEGO sans manuel. Bien sûr, vous pourriez vous retrouver avec quelque chose qui ressemble vaguement à un vaisseau spatial, mais plus probablement, vous vous retrouverez avec un tas de chaos coloré. Dans le monde du codage, les modèles de conception sont comme ce manuel LEGO : ils vous donnent un plan éprouvé pour résoudre les problèmes courants, rendant votre code plus propre, plus efficace et plus facile à maintenir.

Mais ne vous inquiétez pas, il ne s’agit pas d’un cours aride sur les principes du codage. Considérez-le comme un petit guide amusant sur certains des modèles de conception les plus courants en JavaScript, complété par des analogies réelles qui rendent ces concepts faciles à digérer.

1. Le modèle Singleton : le seul et unique

Qu'est-ce que c'est?

Le modèle Singleton garantit qu'une classe n'a qu'une seule instance et fournit un point d'accès global à celle-ci. C'est comme avoir une seule télécommande pour votre téléviseur. Vous n'avez pas besoin de plusieurs télécommandes pour contrôler le volume, changer de chaîne ou l'éteindre : vous n'avez besoin que d'une seule télécommande.

Cas d'utilisation réel :

En JavaScript, ce modèle est couramment utilisé pour gérer l'état global des applications. Par exemple, si vous avez un panier sur un site Web de commerce électronique, vous souhaitez que tous les composants qui interagissent avec le panier (comme l'ajout d'articles, la suppression d'articles ou le paiement) fassent référence à la même instance du panier. Un Singleton garantit que toutes ces actions affectent le même panier, et non différentes copies de celui-ci.

class ShoppingCart {
  constructor() {
    if (!ShoppingCart.instance) {
      this.items = [];
      ShoppingCart.instance = this;
    }
    return ShoppingCart.instance;
  }

  addItem(item) {
    this.items.push(item);
  }

  getItems() {
    return this.items;
  }
}

const cart1 = new ShoppingCart();
const cart2 = new ShoppingCart();

cart1.addItem('Laptop');
console.log(cart2.getItems()); // ['Laptop']

2. Le modèle d’observateur : le réseau Gossip

Qu'est-ce que c'est?

Le modèle Observer consiste à garder les objets synchronisés. Lorsqu’un objet change, les autres doivent en être informés. C’est comme une discussion de groupe où tout le monde est constamment informé de ce qui se passe. Si quelqu'un modifie le plan du week-end, tous les membres du groupe reçoivent le mémo.

Cas d'utilisation réel :

En JavaScript, ce modèle est souvent utilisé dans les systèmes de gestion d'événements. Disons que vous créez une application de médias sociaux. Lorsque quelqu'un aime une publication, vous souhaitez mettre à jour le nombre de likes, avertir l'auteur de la publication et peut-être déclencher une animation. Le pattern Observer permet à ces différents composants de rester à jour sans être directement connectés.

class Subject {
  constructor() {
    this.observers = [];
  }

  subscribe(observer) {
    this.observers.push(observer);
  }

  unsubscribe(observer) {
    this.observers = this.observers.filter(obs => obs !== observer);
  }

  notify(data) {
    this.observers.forEach(observer => observer.update(data));
  }
}

class Observer {
  update(data) {
    console.log(`Observer received: ${data}`);
  }
}

const subject = new Subject();
const observer1 = new Observer();
const observer2 = new Observer();

subject.subscribe(observer1);
subject.subscribe(observer2);

subject.notify('New post liked!'); 
// Output: Observer received: New post liked!
// Output: Observer received: New post liked!

3. Le modèle d'usine : l'emporte-pièce

Qu'est-ce que c'est?

Le modèle Factory consiste à créer des objets sans spécifier la classe exacte d'objet qui sera créé. Imaginez un emporte-pièce. Vous ne savez pas exactement quelle forme prendra la pâte jusqu'à ce que vous appuyiez sur l'emporte-pièce, mais vous savez que vous obtiendrez un cookie.

Cas d'utilisation réel :

Ce modèle est particulièrement utile lorsque vous disposez d'une collection d'objets qui partagent une interface ou une structure commune mais ont des implémentations sous-jacentes différentes. Par exemple, dans un jeu, vous pouvez avoir différents types d'ennemis (zombies, vampires, loups-garous), mais ils partagent tous des propriétés communes telles que la santé, la vitesse et la puissance d'attaque. Une Usine peut vous aider à créer ces ennemis sans vous soucier du type spécifique.

class Enemy {
  constructor(type) {
    this.type = type;
    this.health = 100;
  }

  attack() {
    console.log(`${this.type} attacks with ${this.attackPower}`);
  }
}

class EnemyFactory {
  createEnemy(type) {
    let enemy;

    if (type === 'zombie') {
      enemy = new Enemy('Zombie');
      enemy.attackPower = 10;
    } else if (type === 'vampire') {
      enemy = new Enemy('Vampire');
      enemy.attackPower = 20;
    } else if (type === 'werewolf') {
      enemy = new Enemy('Werewolf');
      enemy.attackPower = 30;
    }

    return enemy;
  }
}

const factory = new EnemyFactory();

const zombie = factory.createEnemy('zombie');
zombie.attack(); // Zombie attacks with 10

const vampire = factory.createEnemy('vampire');
vampire.attack(); // Vampire attacks with 20

4. Le modèle de module : l'espace de travail organisé

Qu'est-ce que c'est?

Le modèle Module, c'est comme avoir un espace de travail bien organisé où tout a sa place. Il vous aide à garder différentes parties de votre code organisées et encapsulées, évitant ainsi que l'espace de noms global ne devienne un désordre encombré.

Cas d'utilisation réel :

Ce modèle est particulièrement utile en JavaScript pour créer des variables et des fonctions publiques et privées. Par exemple, lorsque vous créez une bibliothèque ou un plugin, vous souhaiterez peut-être exposer certaines méthodes au monde extérieur tout en en gardant d’autres cachées. Le modèle Module vous permet de faire exactement cela.

const Calculator = (function() {
  let result = 0;

  function add(x) {
    result += x;
    return result;
  }

  function subtract(x) {
    result -= x;
    return result;
  }

  function multiply(x) {
    result *= x;
    return result;
  }

  function divide(x) {
    if (x !== 0) {
      result /= x;
      return result;
    } else {
      console.error('Cannot divide by zero');
    }
  }

  return {
    add,
    subtract,
    multiply,
    divide,
    getResult: () => result,
  };
})();

console.log(Calculator.add(10)); // 10
console.log(Calculator.subtract(2)); // 8
console.log(Calculator.multiply(3)); // 24
console.log(Calculator.divide(4)); // 6

5. Le modèle d’adaptateur : le convertisseur de prise

Qu'est-ce que c'est?

Le modèle Adaptateur permet à des interfaces incompatibles de fonctionner ensemble. Considérez-le comme un adaptateur de prise que vous utilisez lorsque vous voyagez à l'étranger. La fiche du chargeur de votre ordinateur portable ne rentre peut-être pas dans la prise murale d'un autre pays, mais avec le bon adaptateur, il fonctionne parfaitement.

Cas d'utilisation réel :

En JavaScript, vous pouvez utiliser le modèle Adapter lorsque vous effectuez une intégration avec des bibliothèques ou des API tierces qui ne correspondent pas exactement à la structure de votre application. L'adaptateur peut transformer l'interface d'une classe en une autre interface attendue par les clients, rendant l'intégration transparente.

class OldApi {
  constructor() {
    this.data = 'Old API data';
  }

  getData() {
    return this.data;
  }
}

class NewApi {
  fetchData() {
    return 'New API data';
  }
}

class ApiAdapter {
  constructor(oldApi) {
    this.oldApi = oldApi;
  }

  fetchData() {
    return this.oldApi.getData();
  }
}

const oldApi = new OldApi();
const adapter = new ApiAdapter(oldApi);

console.log(adapter.fetchData()); // 'Old API data'

6. The Composite Pattern: The Russian Nesting Dolls

What is it?

The Composite pattern allows you to treat individual objects and compositions of objects uniformly. It’s like Russian nesting dolls where each doll is part of a larger structure, but you can interact with them both as individual dolls and as a nested set.

Real-Life Use Case:

This pattern is often used in scenarios where you need to manage a hierarchy of objects. For example, consider a file system where files and folders are represented as objects. A folder can contain multiple files or even other folders, and you want to treat both files and folders similarly when it comes to operations like moving, copying, or deleting.

class File {
  constructor(name) {
    this.name = name;
  }

  display() {
    console.log(this.name);
  }
}

class Folder {
  constructor(name) {
    this.name = name;
    this.children = [];
  }

  add(child) {
    this.children.push(child);
  }

  display() {
    console.log(this.name);
    this.children.forEach(child => child.display());
  }
}

const file1 = new File('file1.txt');
const file2 = new File('file2.txt');
const folder = new Folder('MyFolder');
folder.add(file1);
folder.add(file2);

folder.display();
// Output:
// MyFolder
// file1.txt
// file2.txt

Conclusion

These are just a few of the many design patterns that can make your JavaScript code more robust, maintainable, and, let’s face it, fun to write. Whether you’re building the next big app or just trying to organize your code a bit better, these patterns can be your secret weapon. So next time you’re stuck, remember: there’s probably a pattern for that!

And hey, even if your code doesn’t end up looking like a LEGO spaceship, at least it won’t be a pile of colorful chaos.

Happy coding! ?

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!