Because after rewriting the constructor, an object is returned. This object will overwrite the object you generated with the new constructor. I don’t know if I made it clear

@mpccc is right.

If the constructor returns an object, then the new object will be the object.

You can take a look at the constructor section in Secret Garden

I’m a newbie too, so I’ll try to answer it, don’t blame me if I’m wrong

First, does this refer to different objects? When the constructor is called for the first time, an empty object is generated and this inside the function points to the empty object. Then the code is executed, and finally the object is returned, which is
uni.

In the second call, due to the rewriting of the first function, a closure was generated. The internal instance of this closure just pointed to the object generated in the first call

uni. When the second call When you executenew Universe(), you are executing a closure, which will also generate an empty object, but that object does not use it. Instead, it directly returns the instance inside the closure, which isuni.

So

uni2 === uni.

Another question, writing a singleton pattern like this is a bit redundant. To create aunique objectyou don’t have to create a constructor

var single = function(fn){ var instance; return function(){ return instance || (instance = fn .apply(this, arguments)); } };

Didn’t you write the comments and rewrite the constructor? After you create new once, you will no longer have the line of code var instance = this;, and the instance will naturally remain unchanged

//简单打印一下就知道了 console.log(Universe) var uni = new Universe() console.log(Universe)

Whennew Universe()is executed for the first time, a newthisis indeed generated, and theUniverseconstructor is rewritten. When thisnew Universe()is called again later, it will onlyreturn instance, no new objects will be generated.