Modèle de conception d'usine en JavaScript

Le Factory Design Pattern est un modèle de conception créationnel qui permet de créer des objets sans spécifier la classe exacte de l'objet qui sera créé. Cela implique la création d’une méthode d’usine qui décide quelle classe instancier en fonction de l’entrée ou de la configuration. Il est utilisé lorsque toute la création d'objets et sa logique métier doivent être conservées au même endroit.

Le principal avantage du modèle de conception d'usine est sa capacité à dissocier la création d'un objet d'une implémentation particulière.
Il permet de créer un objet dont la classe est déterminée au moment de l'exécution.
Factory nous permet d'exposer une "surface" bien plus petite que celle d'une classe, la classe peut être étendue, manipulée, tandis que factory n'étant qu'une fonction offre moins d'options à l'utilisateur, la rendant plus robuste.
Par conséquent, l'usine peut également être utilisée pour appliquer l'encapsulation en tirant parti des fermetures.

Une méthode pour imposer l’encapsulation

En Javascript, l'un des principaux moyens d'appliquer l'encapsulation consiste à utiliser les portées et les fermetures des fonctions.

Une usine peut également être utilisée comme mécanisme d'encapsulation.

L'encapsulation fait référence au contrôle de l'accès à certains détails internes du composant en empêchant le code externe de les manipuler directement. L'interaction avec le composant se produit uniquement via son interface publique, isolant le code externe des modifications apportées aux détails d'implémentation du composant.

Les fermetures vous permettent de créer des variables et des méthodes privées qui ne sont pas accessibles de l'extérieur de l'usine, appliquant ainsi l'encapsulation et masquant les détails internes de la création et de l'implémentation des objets.

Découplage de la création et de l'implémentation d'objets

Invoquer une usine, au lieu de créer directement un nouvel objet à partir d'une classe à l'aide de l'opérateur new ou Object.create(), est bien plus pratique et flexible à plusieurs égards.

Factory nous permet de séparer la création d'un objet de la mise en œuvre. Une usine enveloppe la création d'une nouvelle instance, nous donnant plus de flexibilité et de contrôle dans la manière dont nous le faisons. À l'intérieur de l'usine, nous choisissons de créer une nouvelle instance d'une classe à l'aide de l'opérateur new, ou d'exploiter les fermetures pour créer dynamiquement un littéral d'objet avec état, ou même de renvoyer un type d'objet différent en fonction d'une condition particulière. Le consommateur d'usine ignore totalement comment s'effectue la création d'instance.

Prenons un petit exemple pour comprendre pourquoi nous avons besoin d'un modèle de conception d'usine

function createImg(name) {
    return new Image(name);
}

const image = createImg('photo.jpg');

Vous auriez pu dire pourquoi écrire cette ligne de code supplémentaire, alors qu'on peut directement écrire :

const image = new Image(name);

L'idée derrière l'utilisation d'une fonction d'usine (createImg) est donc d'abstraire le processus de création d'un objet.

Avantages de la fonction d'usine dans la refactorisation :

Point de changement unique : En utilisant une fonction d'usine, vous centralisez le processus de création d'objets. La refactorisation ou l'extension de la logique nécessite des modifications au même endroit plutôt que dans l'ensemble de la base de code.

Simplifie le code client : le code client qui consomme la fonction d'usine reste inchangé, même si la complexité du processus de création d'objet augmente.

Encapsulation : la fonction d'usine encapsule toute logique supplémentaire (par exemple, la mise en cache, les paramètres par défaut ou les nouveaux types d'objets). Cela évite la duplication de la logique à plusieurs endroits et réduit le risque d'erreurs lors de la refactorisation.

Maintenabilité : à mesure que votre code grandit, maintenir une fonction d'usine devient beaucoup plus facile que de refactoriser l'instanciation directe. Avec une fonction d'usine, vous pouvez introduire de nouvelles fonctionnalités, effectuer des optimisations ou corriger des bugs sans affecter le reste du code.

Exemple

Voici un exemple de base d'implémentation du modèle de conception d'usine en JavaScript :
Scénario : Une usine pour créer différents types de véhicules (voiture, vélo, camion), en fonction de l'entrée.

// Vehicle constructor functions
class Car {
  constructor(brand, model) {
    this.vehicleType = 'Car';
    this.brand = brand;
    this.model = model;
  }

  drive() {
    return `Driving a ${this.brand} ${this.model} car.`;
  }
}

class Bike {
  constructor(brand, model) {
    this.vehicleType = 'Bike';
    this.brand = brand;
    this.model = model;
  }

  ride() {
    return `Riding a ${this.brand} ${this.model} bike.`;
  }
}

class Truck {
  constructor(brand, model) {
    this.vehicleType = 'Truck';
    this.brand = brand;
    this.model = model;
  }

  haul() {
    return `Hauling with a ${this.brand} ${this.model} truck.`;
  }
}

// Vehicle factory that creates vehicles based on type
class VehicleFactory {
  static createVehicle(type, brand, model) {
    switch (type) {
      case 'car':
        return new Car(brand, model);
      case 'bike':
        return new Bike(brand, model);
      case 'truck':
        return new Truck(brand, model);
      default:
        throw new Error('Vehicle type not supported.');
    }
  }
}

// Using the factory to create vehicles
const myCar = VehicleFactory.createVehicle('car', 'Tesla', 'Model 3');
console.log(myCar.drive()); // Output: Driving a Tesla Model 3 car.

const myBike = VehicleFactory.createVehicle('bike', 'Yamaha', 'MT-15');
console.log(myBike.ride()); // Output: Riding a Yamaha MT-15 bike.

const myTruck = VehicleFactory.createVehicle('truck', 'Ford', 'F-150');
console.log(myTruck.haul()); // Output: Hauling with a Ford F-150 truck.

Comment ça marche :

1. Classes de véhicules : nous définissons différents types de véhicules (voiture, vélo, camion), chacun avec son propre constructeur et des méthodes spécifiques comme drive(), ride() et haul().
2. Méthode Factory : La méthode VehicleFactory.createVehicle() est la fabrique qui gère la logique de création d'objets. Il décide quel type de véhicule instancier en fonction de l'argument de type qui lui est transmis.
3. Réutilisabilité : l'usine centralise la logique de création de véhicules, ce qui facilite la gestion, l'extension ou la modification du processus de création.

Ps : dans les exemples de modèles de conception d'usine ci-dessus, des classes telles que Car, Bike et Truck sont instanciées à l'aide du nouveau mot-clé à l'intérieur de la méthode d'usine (VehicleFactory.createVehicle)
Le Factory Pattern résume la création d’objets, ce qui signifie que le client n’a pas besoin d’utiliser lui-même le nouveau mot-clé. Ils s'appuient sur la méthode d'usine pour renvoyer la bonne instance.

Quand utiliser le modèle d'usine :

• Lorsque les types exacts d'objets doivent être déterminés au moment de l'exécution.
• Lorsque vous souhaitez centraliser la logique de création d'objets.
• Lorsque le processus de création implique une logique complexe ou plusieurs étapes.

Résumé

• Le Factory Design Pattern est un moyen utile de gérer la création d'objets complexes ou variés en JavaScript.
• Il fait abstraction de la logique d'instanciation, permettant une flexibilité et une gestion plus facile des différents types d'objets.
• Ce modèle est largement utilisé dans les applications du monde réel, en particulier lorsque vous travaillez avec des systèmes complexes où la création d'objets peut dépendre des conditions ou des configurations d'exécution.
• Dans un projet réel, à mesure que votre code évolue et devient plus complexe, l'approche des fonctions d'usine minimise le nombre de modifications que vous devez apporter, rendant votre code plus maintenable et plus facile à refactoriser.

Livre de référence : NodeJs Design pattern par Mario Casciaro

Comme nous l'avons exploré, les modèles de conception jouent un rôle crucial dans la résolution efficace des défis courants en matière de conception de logiciels. Que vous débutiez comme moi ou que vous cherchiez à approfondir votre compréhension, les informations partagées ici peuvent vous aider à créer des systèmes plus adaptables et évolutifs.

Le parcours vers la maîtrise des modèles de conception peut sembler écrasant au début, mais en commençant petit, en expérimentant et en appliquant ces concepts dans des projets du monde réel, vous renforcerez vos compétences en tant que développeur. Maintenant c'est votre tour ! Comment allez-vous appliquer ces idées à votre travail ? Partagez vos réflexions ou vos questions dans les commentaires ci-dessous. J'aimerais avoir de vos nouvelles.

Merci de m'avoir rejoint dans ce voyage d'apprentissage !
✨✨✨✨✨✨

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!