javascript - Doutes sur le mode singleton en js

Question

Le code suivant

function Universe() {

    // 缓存的实例
    var instance = this;

    // 其它内容
    this.start_time = 0;
    this.bang = "Big";

    // 重写构造函数
    Universe = function () {
        return instance;
    };
}

// 测试
var uni = new Universe();
var uni2 = new Universe();
uni.bang = "123";
console.log(uni === uni2); // true
console.log(uni2.bang); // 123

Cliquez pour voir le texte original

Question :

new Universe()的过程是：
var o = {};
Universe.call(o);//这一步是将Universe中this对应的属性赋值给o;
o.__proto__ = Universe.prototype;//将Universe原型上的方法赋值到o的__proto__属性上;

Donc dans var instance = this;, est-ce que cela fait référence à un objet différent o ? Ainsi, après avoir réécrit le constructeur, l'instance renvoyée n'est-elle pas un objet différent ? Pourquoi sont-ils égaux à la fin

Answer 1

Parce qu'après avoir réécrit le constructeur, un objet est renvoyé. Cet objet écrasera l'objet que vous avez généré avec le nouveau constructeur, je ne sais pas si j'ai été clair

.

Answer 2

@mpccc a raison.

Si le constructeur renvoie un objet, alors le nouvel objet sera l'objet.

Vous pouvez jeter un œil à la section constructeur dans Secret Garden

Answer 3

Je suis aussi un débutant, alors je vais essayer d'y répondre, ne me blâmez pas si je me trompe

Tout d'abord, est-ce que cela fait référence à un objet différent
Lorsque le constructeur est appelé pour la première fois, un objet vide est généré, et cela à l'intérieur de la fonction pointe vers cet objet vide, puis le code est exécuté, et enfin cet objet est renvoyé , qui est uni.

Lors du deuxième appel, en raison de la réécriture de la première fonction, une fermeture a été générée. L'instance interne de cette fermeture vient de pointer vers l'objet généré lors du premier appeluni,当第二次执行new Universe()的时候你执行的是一个闭包，也会产生一个空的对象，但那个对象并没有用到它，反而是直接返回了闭包内部的instance也就是uni Lors de la deuxième exécution < When code>new Universe(). , vous exécutez une fermeture, qui générera également un objet vide, mais cet objet ne l'utilise pas, il renvoie directement l'instance à l'intérieur de la fermeture, qui est

.

uni2 === uniAlors

.🎜

Answer 4

Une autre question, écrire un modèle singleton comme celui-ci est un peu redondant. Pour créer un objet uniquevous n'avez pas besoin de créer un constructeur

.

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

Answer 5

N'avez-vous pas écrit les commentaires et réécrit le constructeur ? Après avoir créé un nouveau une fois, vous n'aurez plus la ligne de code var instance = this;, et l'instance restera naturellement inchangée

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

Answer 6

Exécuté pour la première foisnew Universe()的时候，确实产生了一个新的this，并且将Universe构造函数改写了，之后再次调用这个new Universe()的时候，就只会return instance, aucun nouvel objet ne sera généré.