introduire
À partir de ce chapitre, nous présenterons progressivement les différentes implémentations de modèles de conception utilisées dans JavaScript. Ici, je ne présenterai pas trop de théories du modèle lui-même, mais je me concentrerai uniquement sur la mise en œuvre. Ok, commencez officiellement.
Aux yeux des ingénieurs de développement traditionnels, un singleton doit s'assurer qu'il n'y a qu'un seul cas d'une classe. La méthode d'implémentation vise généralement à déterminer d'abord si l'instance existe ou non. S'il existe, il sera directement retourné, et s'il n'existe pas, il sera créé puis renvoyé, ce qui garantit qu'il n'y a qu'un seul objet d'instance d'une classe. Dans JavaScript, Singleton agit comme un fournisseur d'espace de noms, fournissant un point d'accès unique de l'espace de noms global pour accéder à l'objet.
texte
Dans JavaScript, il existe de nombreuses façons d'implémenter les singletons. Le moyen le plus simple consiste à utiliser l'objet littéral, qui peut contenir un grand nombre de propriétés et de méthodes:
La copie de code est la suivante:
var mysingleton = {
Property1: "quelque chose",
Property2: "autre chose",
Méthode 1: fonction () {
Console.log («Hello World»);
}
};
Si vous souhaitez prolonger l'objet plus tard, vous pouvez ajouter vos propres membres et méthodes privés, puis utiliser une fermeture pour encapsuler ces variables et déclarations de fonction à l'intérieur. Seuls les membres du public et les méthodes que vous souhaitez exposer sont exposés. L'exemple de code est le suivant:
La copie de code est la suivante:
var mysingleton = function () {
/ * Déclarer les variables et méthodes privées ici * /
var privatevariable = 'quelque chose privé';
fonction showprivate () {
console.log (privateVariable);
}
/ * Variables et méthodes publiques (les variables et méthodes privées sont accessibles) * /
retour {
publicMethod: function () {
showprivate ();
},
PublicVar: "Le public peut voir cela!"
};
};
var single = mysingleton ();
single.publicMethod (); // Sortie «quelque chose de privé»
console.log (single.publicvar); // Sortie «Le public peut voir cela!
Le code ci-dessus est assez bon, mais que se passe-t-il si nous voulons le faire uniquement initialiser lorsque nous l'utilisons? Dans le but d'économiser des ressources, nous pouvons initialiser ces codes dans un autre constructeur, comme suit:
La copie de code est la suivante:
var singleton = (function () {
var instancié;
fonction init () {
/ * Définir le code singleton ici * /
retour {
publicMethod: function () {
Console.log («Hello World»);
},
PublicProperty: «Test»
};
}
retour {
getInstance: function () {
if (! instancié) {
instancié = init ();
}
retour instancié;
}
};
}) ();
/ * Appeler une méthode publique pour obtenir l'instance: * /
Singleton.getInstance (). PublicMethod ();
Je sais comment implémenter des singletons, mais quel type de scénario est le meilleur scénario pour les singletons à utiliser? En fait, les singletons sont généralement utilisés pour la coordination de la communication entre divers modes entre les systèmes. Le code suivant est la meilleure pratique pour un singleton:
La copie de code est la suivante:
var singletonteter = (function () {
// Paramètre: un ensemble de paramètres passés à un singleton
fonction singleton (args) {
// Définissez la variable Args sur le paramètre reçu ou soyez vide (si ce n'est pas fourni)
var args = args || {};
// définir les paramètres du nom
this.name = 'singletontester';
// Définit la valeur de PointX
this.pointx = args.pointx || 6; // tire des paramètres reçus, ou défini sur la valeur par défaut
// définir la valeur de pointu
this.poity = args.poity || 10;
}
// Conteneur d'instance
instance var;
var _static = {
Nom: «Singletontester»,
// Méthode pour obtenir l'instance
// Renvoie l'instance singleton
getInstance: function (args) {
if (instance === Undefined) {
instance = new singleton (args);
}
retour d'instance;
}
};
return _static;
}) ();
var singletontest = singletonteter.getInstance ({pointx: 5});
console.log (singletontest.pointx); // Sortie 5
Autres méthodes de mise en œuvre
Méthode 1:
La copie de code est la suivante:
Univers de fonction () {
// déterminer s'il y a une instance
if (typeof univers.instance === 'objet') {
RETOUR Universe.Instance;
}
// Autre contenu
this.start_time = 0;
this.bang = "big";
// cache
Universe.instance = this;
// retourne implicitement ceci
}
// test
var Uni = New Universe ();
var Uni2 = New Universe ();
console.log (Uni === Uni2); // vrai
Méthode 2:
La copie de code est la suivante:
Univers de fonction () {
// Instance de cache
var instance = this;
// Autre contenu
this.start_time = 0;
this.bang = "big";
// Réécrivez le constructeur
Univers = fonction () {
retour d'instance;
};
}
// test
var Uni = New Universe ();
var Uni2 = New Universe ();
Uni.Bang = "123";
console.log (Uni === Uni2); // vrai
Console.log (Uni2.Bang); // 123
Méthode 3:
La copie de code est la suivante:
Univers de fonction () {
// Instance de cache
instance var;
// reconstruire la fonction
Universe = fonction Universe () {
retour d'instance;
};
// post-traitement des propriétés prototypes
Universe.prototype = this;
// Exemple
instance = nouvel univers ();
// Réinitialiser le pointeur du constructeur
instance.constructor = univers;
// Autres fonctions
instance.start_time = 0;
instance.bang = "big";
retour d'instance;
}
// test
var Uni = New Universe ();
var Uni2 = New Universe ();
console.log (Uni === Uni2); // vrai
// ajouter des propriétés prototypes
Universe.prototype.nothing = true;
var Uni = New Universe ();
Universe.prototype.Everything = true;
var Uni2 = New Universe ();
console.log (Uni.Nothing); // vrai
console.log (Uni2.Nothing); // vrai
Console.log (Uni.Everything); // vrai
Console.log (Uni2, tout); // vrai
Console.log (Uni.Constructor === Universe); // vrai
Méthode 4:
La copie de code est la suivante:
Var Universe;
(fonction () {
instance var;
Universe = fonction Universe () {
if (instance) {
retour d'instance;
}
instance = this;
// Autre contenu
this.start_time = 0;
this.bang = "big";
};
} ());
// Code de test
var a = nouvel univers ();
var b = nouvel univers ();
alerte (a === b); // vrai
a.bang = "123";
alerte (B.Bang); // 123