Der Single-Modus ist als Softwareentwicklungsmodell in vielen objektorientierten Sprachen weit verbreitet. Da die JavaScript-Sprache jedoch über einen einzigartigen objektorientierten Ansatz verfügt, führt dies zu Obwohl die Idee des Einzelmodus mit einigen traditionellen objektorientierten Sprachen übereinstimmt, gibt es dennoch Unterschiede in der Implementierung.
Schauen wir uns zunächst die Definition des Singleton-Musters in herkömmlichen objektorientierten Sprachen an: Ein Singleton-Muster ist eine Klasse, die nur einmal instanziiert werden kann und auf die über einen bekannten Zugriffspunkt zugegriffen werden kann. Es gibt zwei Punkte in dieser Definition, die die Merkmale traditioneller objektorientierter Sprachen hervorheben, nämlich Klassen und Instanziierungen. Daher basiert der Singleton-Modus für traditionelle objektorientierte Sprachen auf den natürlichen Merkmalen seiner Klassen und Instanziierungen. Verwenden von Schlüssel Das Wort Klasse definiert eine Klasse, die über das Schlüsselwort new instanziiert werden kann. Es muss jedoch sichergestellt werden, dass bei jeder Instanziierung durch new dieselbe Instanz erhalten wird, da der Konstruktor sonst nur einmal über new aufgerufen werden kann.
Werfen wir einen Blick auf die Definition des Singleton-Modus in JavaScript: Ein Singleton ist ein Objekt, das zum Teilen des Namespace und zum Organisieren einer Gruppe verwandter Methoden und Eigenschaften verwendet wird. Wenn es instanziiert werden kann, kann es nur instanziiert werden einmal. Wenn Sie die obige Definition vergleichen, werden Sie feststellen, dass die einzelne Definition sie im Wesentlichen als Objekt und nicht als Klasse in einer herkömmlichen objektorientierten Sprache definiert. Dies zeigt auch, dass die JavaScript-Sprache auf Objekten basiert. Gleichzeitig wurde später darauf hingewiesen, dass es mehrere Möglichkeiten geben sollte, ein einzelnes Objekt in JavaScript zu definieren, wenn es instanziiert werden kann. Es gibt eine oder mehrere Möglichkeiten, ein einzelnes Objekt mithilfe des neuen Schlüsselworts zu erstellen. Diese Methode ist jedoch keine natürliche Funktion von JavaScript selbst, da Objekte, die mit dem neuen Schlüsselwort erstellt wurden, tatsächlich die Funktion verwenden, um die Definition ihres Konstruktors zu simulieren (obwohl ES6 begonnen hat, das Klassenschlüsselwort zu unterstützen, wurde es noch nicht angezeigt (Weitgehend unterstützt). von allen Browsern)), wie kann man also die natürlichen Funktionen von JavaScript nutzen, um den Singleton-Modus zu implementieren?
var Singleton={
attribute1:true,
attribute2:10,
method1:function(){
},
method2:function(arg){
}
}
Hier wird ein Objekt Singleton definiert, das mehrere Eigenschaften und Methoden enthält. Dieses Objekt wird beim Laden mit Singleton.method1 erstellt Nach dem Laden und dem Abschluss des js-Analyse- und Ausführungsprozesses verwenden wir das neue Schlüsselwort nicht, um dieses Objekt zu instanziieren. Dies ist auch ein großer Unterschied zwischen der Implementierung des Einzelmodus in JavaScript und herkömmlichen objektorientierten Sprachen. Dieser Weg ist einfacher und leichter zu verstehen. Diese Methode weist jedoch mehrere Nachteile auf. Ein offensichtlicher Nachteil besteht darin, dass sie keinen Namespace bereitstellt. Wenn andere Programmierer auch eine Singleton-Variable auf der Seite definieren, ist es leicht, das einzelne Objekt neu zu schreiben und dieses Problem zu lösen es wie folgt:
var mySpace={};
mySpace.Singleton={
attribute1:true,
attribute2:10,
method1:function(){
},
method2:function(arg){
}
}
Hier definieren wir zunächst einen mySpace-Namespace und mounten dann das Singleton-Objekt unter diesem Objekt. Dadurch wird die Möglichkeit von Konflikten und Fehloperationen mit anderen Programmierern erheblich reduziert, selbst wenn sich andere im globalen Bereich befinden Das einzelne Objekt erfüllt die Funktion, den Namespace zu unterteilen und einige verwandte Eigenschaften und Methoden zusammenzufassen, wie in der vorherigen Definition erwähnt.
Diese Methode weist immer noch Mängel auf und kann jederzeit von außen aufgerufen und geändert werden. Daher werden Abschlüsse wie folgt verwendet, um private Eigenschaften und Methoden zu simulieren:
mySpace.Singleton=(function(){
var privateAttribute1=false;
var privateAttribute1=[1,2,3];
function privateMethod1(){
}
function privateMethod2(){
}
return {
publicAttribute1:true,
publicAttribute2:10,
publicMethod1:function(){
privateAttribute1=true;
privateMethod1();
},
publicMethod2:function(arg){
privateAttribute1=[4,5,6];
privateMethod2();
}
}
})();
Hier weisen wir dem einzelnen Objekt direkt eine anonyme selbstausführende Funktion zu. In dieser Funktion verwenden wir die Schlüsselwörter var und function, um ihre privaten Eigenschaften bzw. Methoden zu definieren. Auf diese kann außerhalb der Funktion (außerhalb des einzelnen Objekts) nicht direkt zugegriffen werden. Zugänglich, denn sobald die Funktion ausgeführt wird, wird der Platz in ihrem internen Bereich zurückgewonnen, weshalb Schließungen verwendet werden können, um private Eigenschaften und Methoden zu simulieren. In dieser Funktion (Abschluss) wird schließlich ein Objekt zurückgegeben, das einige öffentliche Methoden und Eigenschaften enthält, die gleichzeitig direkt von außen aufgerufen werden können, da diese öffentlichen Methoden innerhalb der Funktion definiert sind Methoden können aufgerufen werden, die Außenwelt kann jedoch nur bestimmte Vorgänge über die zurückgegebenen öffentlichen Methoden und Eigenschaften abschließen und die Eigenschaften von Singleton.privateMethod1 nicht direkt aufrufen. Dadurch kann das einzelne Objekt nicht nur die Außenwelt vom direkten Zugriff auf seine privaten Eigenschaften und Methoden isolieren, sondern der Außenwelt auch einige gemeinsame Eigenschaften und Methoden zur Verfügung stellen, um bestimmte Vorgänge abzuschließen.
Dieser Singleton-Modus, der durch die Selbstausführung anonymer Funktionen erstellt wird, wird in vielen JS-Bibliotheken häufig verwendet. Es besteht jedoch immer noch ein Problem, wenn wir das Objekt beim Laden der Seite nicht verwenden müssen und das Objekt teuer ist erstellen (z. B. viele Berechnungen oder mehrere Zugriffe auf den DOM-Baum und seine Eigenschaften usw. erfordern), besteht ein vernünftiger Ansatz darin, ihn bei Bedarf zu erstellen, anstatt ihn direkt mit der Analyse und Ausführung von js zu erstellen Dieses Konzept wird als Lazy Loading bezeichnet, daher wird der obige Code wie folgt geändert:
mySpace.Singleton=(function(){
var uniqueInstance;
function constructor(){
var privateAttribute1=false;
var privateAttribute1=[1,2,3];
function privateMethod1(){
}
function privateMethod2(){
}
return {
publicAttribute1:true,
publicAttribute2:10,
publicMethod1:function(){
privateAttribute1=true;
privateMethod1();
},
publicMethod2:function(arg){
privateAttribute1=[4,5,6];
privateMethod2();
}
}
}
return {
getInstance:function(){
if(!uniqueInstance){
uniqueInstance=constructor();
}
return uniqueInstance;
}
}
})();
Hier definieren wir zunächst eine private Variable „uniqueInstance“ in der anonymen Funktion als Handle, um zu bestimmen, ob das einzelne Objekt erstellt wurde, und fügen dann alle Eigenschaften und Methoden, die gerade für das einzelne Objekt definiert wurden, in einen Konstruktor ein. Das einzelne Objekt wird nur erstellt, wenn die Funktion aufgerufen wird, andernfalls wird es nicht direkt erstellt. Anschließend wird ein Objekt zurückgegeben, das eine getInstance-Methode enthält. Wenn Sie diese Methode aufrufen, ermitteln Sie zunächst, ob das einzelne Objekt vorhanden ist. Rufen Sie andernfalls die Konstruktorfunktion auf einzelnes Objekt. Kehren Sie noch einmal dorthin zurück. Wenn wir schließlich eine Methode des einzelnen Objekts aufrufen, müssen wir mySpace.Singleton.getInstance().publicMethod1() verwenden. Hier wird das einzelne Objekt nur erstellt, wenn wir es auf diese Weise aufrufen, andernfalls wird das einzelne Objekt nicht erstellt automatisch erstellt werden, was tatsächlich das Laden bei Bedarf oder das verzögerte Laden implementiert.
