Javascript design pattern theory and programming practice simple factory pattern_javascript skills

Reading Directory

Basic introduction
Give examples
Summary

The simple factory pattern uses a method to determine which class instance to create, and these instances often have the same interface. This pattern is mainly used when the type being instantiated cannot be determined at compile time, but situations decided during the execution period. To put it simply, it's like the beverage machine in the company's pantry. You want coffee or milk depending on which button you press.

The simple factory pattern is also very useful when creating ajax objects.

Usually the most common way for us to create objects is to use the new keyword to call the constructor, which will lead to dependencies between objects. Factory pattern is a design pattern that helps eliminate dependencies between classes by using a method to decide which class to instantiate. This article introduces the theory of the simple factory pattern in detail and illustrates the specific application of the simple factory pattern.

Basic introduction

The simple factory pattern is the most basic one of the factory patterns. By defining a factory class, a specific product class is instantiated based on parameters.

Examples

Let’s take an example to illustrate: Suppose we develop a tourism industry website that sells air tickets, hotels and other products. A user is ready to purchase a ticket. We can define related classes as follows:

 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);

This code defines three classes: user class User, ticket class Flight, and hotel class Hotel, where User contains the booking method. The user can directly enter the product type when making a reservation. There is nothing wrong with this code at first glance, but needs and business changes at any time. If the company's business expands and visa services are added, we will need to modify the User class to ensure that it supports visas. Of course we can do this, but what's wrong with modifying the User class directly? Is there a better way?

The first thing I want to talk about is the User class. This class represents the user class, and the user class is essentially irrelevant to a specific type of business. That is to say, the business may increase at any time, but the user has nothing to do with the business. The code is what creates the product order. The new visa business is essentially no different from the existing air tickets and hotels. If you have to modify the User class every time you add a business, this will greatly affect the stability and maintainability of the code. A better solution The method is to have a dedicated order creation class to manage different businesses. This class is a simple factory.

We modify the code as follows:

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));
   }
 }

There are two main modifications to this code:

(1) Added a product factory to return different objects according to different product types

(2) Modify the order method of the User class to call the create product method in the factory class.

The benefits of doing this are:

(1) Make the User's order method more focused, only doing the function of booking products, and extracting and creating product orders into a dedicated factory class, making the code more concise and clear

(2) A factory dedicated to managing products. It is easy to add new products without modifying the User class

Summary

The main feature of the simple factory pattern is to separate the creation and use of objects. It mainly consists of 3 parts:

1. The object uses a class, which is a user created by the factory and has nothing to do with the type and creation process of the object

2. Factory class. The factory class creates different objects based on the parameters passed in and returns them to the object using class. It includes the creation process of different objects. If there are different objects, the class must be modified

3. Object classes, different classes generated by different businesses, are the products produced by the factory

Advantages of simple factory model

1. The factory class centralizes the creation of all objects, facilitating unified management of object creation

2. The user of the object only uses the product and realizes a single responsibility

3. Easy to expand. If a new business is added, you only need to add the relevant business object class and the method of producing the business object in the factory class, and there is no need to modify other places.

Applicable scenarios

1. Different instances need to be generated according to different parameters, and these instances have some common scenarios

2. Users only need to use the product and do not need to know the details of product creation

Note: Unless it is applicable to the scenario, the factory pattern cannot be abused, which will cause code complexity.