Théorie des modèles de conception Javascript et pratique de la programmation Compétences simples en matière de modèle d'usine_javascript

Annuaire de lecture

Introduction de base
Donnez des exemples
Résumé

Le modèle de fabrique simple utilise une méthode pour déterminer quelle instance de classe créer, et ces instances ont souvent la même interface. Ce modèle est principalement utilisé lorsque le type instancié ne peut pas être déterminé au moment de la compilation, mais que des situations sont décidées lors de l'exécution. période. Pour faire simple, c'est comme la machine à boissons dans le garde-manger de l'entreprise. Vous voulez du café ou du lait selon le bouton sur lequel vous appuyez.

Le modèle d'usine simple est également très utile lors de la création d'objets ajax.

Habituellement, la manière la plus courante pour nous de créer des objets est d'utiliser le mot-clé new pour appeler le constructeur, ce qui entraînera des dépendances entre les objets. Le modèle d'usine est un modèle de conception qui permet d'éliminer les dépendances entre les classes en utilisant une méthode pour décider quelle classe instancier. Cet article présente en détail la théorie du modèle d’usine simple et illustre l’application spécifique du modèle d’usine simple.

Introduction de base

Le modèle d'usine simple est le plus basique des modèles d'usine. En définissant une classe d'usine, une classe de produit spécifique est instanciée en fonction de paramètres.

Exemples

Prenons un exemple pour illustrer : supposons que nous développions un site Web pour l’industrie du tourisme qui vend des billets d’avion, des hôtels et d’autres produits. Un utilisateur est prêt à acheter un billet. Nous pouvons définir les classes associées comme suit :

 var productEnums = {
   flight: "flight",
   hotel: "hotel"
 };
 function Flight() {
   console.log("This is Flight");
 }
 function Hotel() {
   console.log("This is Hotel");
 }
 function User() {
   this.shopCart = [];
 }
 User.prototype = {
   constructor: User,
   order: function (productType) {
     var product = null;
     switch (productType) {
       case productEnums.flight:
         product = new Flight();
       case productEnums.hotel:
         product = new Hotel();
       default:
     }
     this.shopCart.push(product);
   }
 }
 var user = new User();
 user.order(productEnums.flight);

Ce code définit trois classes : la classe d'utilisateur Utilisateur, la classe de billet Vol et la classe d'hôtel Hôtel, où Utilisateur contient la méthode de réservation. L'utilisateur peut saisir directement le type de produit lors de la réservation. Il n'y a rien de mal avec ce code à première vue, mais les besoins et l'activité changent à tout moment. Si l'activité de l'entreprise se développe et que des services de visa sont ajoutés, nous devrons modifier la classe User pour nous assurer qu'elle prend en charge les visas. Bien sûr, nous pouvons le faire, mais quel est le problème avec la modification directe de la classe User ? Existe-t-il une meilleure façon ?

La première chose dont je veux parler est la classe Utilisateur. Cette classe représente la classe utilisateur, et la classe utilisateur n'est essentiellement pas pertinente pour un type d'entreprise spécifique, c'est-à-dire que l'activité peut augmenter à tout moment. mais l'utilisateur n'a rien à voir avec l'entreprise. Le code est ce qui crée la commande du produit. La nouvelle entreprise de visa n'est essentiellement pas différente des billets d'avion et des hôtels existants. Si vous devez modifier la classe d'utilisateur à chaque fois que vous ajoutez une entreprise, cela affectera grandement la stabilité et la maintenabilité du code. Une meilleure solution La méthode consiste à. avoir une classe de création de commandes dédiée pour gérer différentes entreprises. Cette classe est une simple usine.

Nous modifions le code comme suit :

var productFactory = (function () {
   var productFactories = {
     "flight": function () {
       return new Flight();
     },
     "hotel": function () {
       return new Hotel();
     }
   };
   return {
     createProduct: function (productType) {
       return productFactories[productType]();
     }
   }
 })();
 User.prototype = {
   constructor: User,
   order: function (productType) {
     this.shopCart.push(productFactory.createProduct(productType));
   }
 }

Il y a deux modifications principales à ce code :

(1) Ajout d'une usine de produits pour retourner différents objets selon différents types de produits

(2) Modifiez la méthode order de la classe User pour appeler la méthode create product dans la classe factory.

Les avantages de cette opération sont :

(1) Rendre la méthode de commande de l'utilisateur plus ciblée, en remplissant uniquement la fonction de réservation de produits, et en extrayant et en créant des commandes de produits dans une classe d'usine dédiée, rendant le code plus concis et clair

(2) Une usine dédiée à la gestion des produits Il est facile d'ajouter de nouveaux produits sans modifier la classe User

Résumé

La principale caractéristique du patron d'usine simple est de séparer la création et l'utilisation des objets. Il se compose principalement de 3 parties :

1. L'objet utilise une classe, qui est un utilisateur créé par l'usine et n'a rien à voir avec le type et le processus de création de l'objet

2. Classe Factory. La classe Factory crée différents objets en fonction des paramètres transmis et les renvoie à l'objet en utilisant la classe. Elle inclut le processus de création de différents objets, la classe doit être modifiée <.>

Avantages du modèle d'usine simple

Scénarios applicables