js object-oriented summary of various methods of creating objects_js object-oriented

Start creating objects:

　1. Object literal.

2. Create Object instance

This shows that attributes can be dynamically added and modified



Object creation mode:

1. Factory mode: It is a function, then puts in parameters, returns the object, and the pipeline works

Advantages: Finally, advantages are an abstract concept. But the type of object cannot be recognized!

2. Constructor pattern

Note: The new keyword is required. If it is not added, clock will not be called as a constructor, but just an ordinary function. At the same time, attributes will be accidentally added to his outer scope, window, because this inside the constructor has been mapped to the outer scope at this time. So to be on the safe side, you can create

Disadvantages of the constructor: Because the this pointer changes when the object instance is used, it points to a new instance. At this time, the methods of the new instance must also be re-created. If there are n instances, the same method must be re-created n times. So let’s uncover the prototype mode

3. Prototype mode

It is important to have a deep understanding of the prototype model.

First of all, each function has a prototype (prototype) attribute, and this pointer points to the clock.prototype object. This prototype object has a property constructor by default, pointing to clock. This property is readable and writable. When we instantiate an object, in addition to the properties and methods defined by the constructor (note, only in the constructor), the instance newClock also has a pointer to the prototype of the constructor, which ECMAScript calls [[ prototype]], when instantiating an object, the methods of the prototype object are not in a specific instance, because the prototype has not been instantiated. (There is a lot of nonsense, I didn’t mislead you. Don’t be confused)

So for the object defined in this mode, when calling the method: call newClock.showTime(); first check whether there is any in the instance, and there is a call Therefore, there is no prototype traced, there is no error, and the call fails.

Of course you can write it like this:

Note: The connection between the instance and the constructor prototype is also through a pointer To contact, so you can dynamically add methods to modify the prototype.

The problem with this pure prototype model is also obvious. All attributes and methods are shared, and objects cannot be made concrete. Often we think of each object as having its own properties. Therefore, combining the first two, a new model is generated

4. Construction-prototype combination mode.

here We put the properties in the constructor to make the object more specific.