JavaScript design patterns factory pattern and constructor pattern_javascript skills

What is a pattern

I was preparing for the final exam a while ago. It was so tiring and tiring, and I really didn’t have time to update the article. Today I will talk to you about the design patterns in JavaScript.

First of all, what we need to know is: a pattern is a reusable solution, while an anti-pattern is a poor solution to a certain problem.

Common examples of js anti-patterns

1. Pass strings to setTimeout and setInterval instead of functions, which triggers the internal use of eval().
2. Define a large number of variables in the global context to pollute the global namespace
3. Modify the prototype of the Object class
4. Use js in inline form. The js code embedded in the HTML file cannot be included in external unit testing tools.
5. Abusing document.write. If document.write is executed after the page is loaded, it will rewrite the page we are on. If you can use document.creatElement instead, try not to use document.write.

Categories of design patterns

Creative Design Pattern

Creative design patterns focus on handling object creation mechanisms to create objects in a way that is appropriate for a given situation. Properties that fall into this category include:

Constructor, Factory, Abstract, Prototype, Singleton and Builder

Structural Design Pattern

Structural patterns are about object composition and can often be used to find simple ways to establish relationships between different objects.
Patterns that fall into this category include:

Decorator, Facade appearance, Flyweight, Adapter adapter and Proxy agent

Behavioral Design Patterns

Behavioral patterns focus on improving or simplifying communication between different objects in the system.

Behavior patterns include:

Iterator, Mediator, Observer and Visitor

Factory mode

In order to solve the problem of multiple similar object declarations, we can use a method called factory pattern. This method is to solve the problem of a large number of duplications when instantiating objects.

Classification of Factory Pattern

Factory mode is divided into simple factory, abstract factory and smart factory. Factory mode does not require the use of a constructor explicitly.

Simple Factory Pattern: Use a class (usually a singleton) to generate instances.
Complex factory pattern: Use subclasses to determine which specific class instance a member variable should be.

Benefits of Factory Model

The main benefit is that you can eliminate the coupling between objects by using engineering methods instead of the new keyword. Prevent code duplication by centralizing all instantiation code in one location.
Disadvantages of factory model

For most classes, it is best to use the new keyword and constructor, which can make the code simpler and easier to read. Rather than having to look at the factory method to find out. 
The factory pattern solves the problem of repeated instantiation, but there is another problem, that is, the problem of identification, because it is impossible to figure out which object they are instances of.

When to use factory pattern?

Factory mode is mainly used in the following scenarios:

1. When objects or components involve high complexity
2. When you need to easily generate different instances of an object according to different environments
3. When dealing with many small objects or components that share the same properties

Constructor pattern

Constructor (constructor method) can be used in ECMAScript to create specific objects. This mode can just solve the problem that the above factory mode cannot identify object instances.

Using the constructor method not only solves the problem of repeated instantiation, but also solves the problem of object recognition. The difference between this mode and the factory mode is:

1. The constructor method does not create an object explicitly (new Object());
2. Directly assign properties and methods to this object;
3. There is no renturn statement.

There are some specifications for constructor methods:

1. The function name and the instantiation constructor name are the same and capitalized (PS: It is not mandatory, but writing this way helps distinguish the constructor from the ordinary function);
2. To create an object through a constructor, you must use the new operator.
Since objects can be created through constructors, where does this object come from, and where is new Object() executed? The execution process is as follows:

1. When a constructor is used and new constructor() is used, new Object() is executed in the background;
2. Give the scope of the constructor to the new object (that is, the object created by new Object()), and this in the function body represents the object created by new Object().
3. Execute the code within the constructor;
4. Return the new object (return directly in the background).

Constructor with prototype

There is an attribute called prototype in js. After calling the js constructor to create an object, the new object will have all the properties of the constructor prototype. In this way, multiple Car objects can be created and have access to the same prototype.