Compréhension approfondie de la série JavaScript (25) : Explication détaillée du modèle singleton des modèles de conception_Connaissances de base

Présentation

À partir de ce chapitre, nous présenterons progressivement l'implémentation de divers modèles de conception utilisés en JavaScript. Ici, je ne présenterai pas trop la théorie du modèle lui-même, mais me concentrerai uniquement sur l'implémentation. OK, c'est officiellement commencé.

Aux yeux des ingénieurs de développement traditionnels, un singleton consiste à garantir qu'une classe n'a qu'une seule instance. La méthode d'implémentation consiste généralement à déterminer d'abord si l'instance existe, si elle n'existe pas. , créez-le et renvoyez-le. Cela garantit qu'une classe n'a qu'un seul objet d'instance. En JavaScript, un singleton agit comme un fournisseur d'espace de noms, fournissant un point d'accès unique à l'objet depuis l'espace de noms global.

Texte

En JavaScript, il existe de nombreuses façons d'implémenter des singletons. L'une des méthodes les plus simples consiste à utiliser des littéraux d'objet, qui peuvent contenir un grand nombre de propriétés et de méthodes :

Copier le code Le code est le suivant :

var monSingleton = {
Propriété 1 : "quelque chose",
Propriété2 : "autre chose",
Méthode 1 : fonction () {
console.log('bonjour tout le monde');
>
};

Si vous étendez ultérieurement cet objet, vous pouvez ajouter vos propres membres et méthodes privés, puis utiliser des fermetures pour encapsuler ces déclarations de variables et de fonctions à l'intérieur. Exposez uniquement les membres publics et les méthodes que vous souhaitez exposer. L'exemple de code est le suivant :

Copier le code Le code est le suivant :

var monSingleton = fonction () {

/* Déclarez ici les variables et méthodes privées */
var privateVariable = 'quelque chose de privé';
Fonction showPrivate() {
console.log(privateVariable);
>

/* Variables et méthodes publiques (les variables et méthodes privées sont accessibles) */
Retour {
         publicMethod : fonction () {
              showPrivate();
},
publicVar : 'le public peut voir ça !'
};
};

var single = mySingleton();
single.publicMethod(); // Sortie 'quelque chose de privé'
console.log(single.publicVar); // Sortie 'le public peut voir ça !'

Le code ci-dessus est très bien, mais que se passe-t-il si on veut l'initialiser uniquement lorsqu'il est utilisé ? Afin d'économiser des ressources, nous pouvons initialiser ces codes dans un autre constructeur, de la manière suivante :

Copier le code Le code est le suivant :

var Singleton = (fonction () {
var instancié ;
Fonction init() {
/*Définissez le code singleton ici*/
         revenir {
              publicMethod : fonction () {
console.log('bonjour tout le monde');
            },
             publicProperty : 'test'
        };
>

revenir {
         getInstance : fonction () {
                if (!instancié) {
                         instancié = init();
            }
             retour instancié ;
>
};
})();

/*Appelez des méthodes publiques pour obtenir des instances :*/
Singleton.getInstance().publicMethod();

Nous savons maintenant comment implémenter un singleton, mais dans quels scénarios un singleton est-il préférable d'utiliser ? En fait, les singletons sont généralement utilisés pour coordonner différents modes de communication entre les systèmes. Le code suivant est une bonne pratique pour un singleton :

Copier le code Le code est le suivant :

var SingletonTester = (fonction () {

//Paramètres : un ensemble de paramètres passés au singleton
Fonction Singleton(args) {

//Définissez la variable args sur les paramètres reçus ou vide (si elle n'est pas fournie)
var arguments = arguments || {};
//Définissez le paramètre de nom
This.name = 'SingletonTester';
//Définissez la valeur du pointX
This.pointX = args.pointX || 6; //Récupérez-le à partir des paramètres reçus ou définissez-le sur la valeur par défaut
//Définissez la valeur du pointY
Ce.pointY = args.pointY || 10;

}

//Conteneur d'instance
var instance;

var _static = {
nom : 'SingletonTester',

//Méthode pour obtenir l'instance
//Retourner l'instance Singleton
         getInstance : fonction (arguments) {
Si (instance === non défini) {
                    instance = new Singleton(args);
            }
             renvoyer l'instance ;
>
};
Renvoie _static;
})();

var singletonTest = SingletonTester.getInstance({ pointX: 5 });
console.log(singletonTest.pointX); // Sortie 5

Autres méthodes de mise en œuvre

Méthode 1 :

Copier le code Le code est le suivant :

fonction Univers() {

// Détermine si une instance existe
Si (type d'Univers.instance === 'objet') {
         return Universe.instance;
>

//Autre contenu
This.start_time = 0;
This.bang = "Gros";

//Cache
Univers.instance = ceci;

// Renvoie implicitement ceci
>

//Test
var uni = nouvel Univers();
var uni2 = nouvel Univers();
console.log(uni === uni2); // vrai

Méthode 2 :

Copier le code Le code est le suivant :

fonction Univers() {

// instance mise en cache
var instance = ceci;

//Autre contenu
This.start_time = 0;
This.bang = "Gros";

// Remplacer le constructeur
Univers = fonction () {
         renvoyer l'instance ;
};
>

//Test
var uni = nouvel Univers();
var uni2 = nouvel Univers();
uni.bang = "123";
console.log(uni === uni2); // vrai
console.log(uni2.bang); // 123

Méthode 3 :

Copier le code Le code est le suivant :

fonction Univers() {

// Instance de cache
var instance;

// Fonction reconstructeur
Univers = fonction Univers() {
         renvoyer l'instance ;
};

// Propriétés du prototype post-traitement
Univers.prototype = ceci;

// Exemple
Instance = nouvel Univers();

// Réinitialiser le pointeur du constructeur
Instance.constructor = Univers;

// Autres fonctions
Instance.start_time = 0;
Instance.bang = "Gros";

instance de retour ;
>

//Test
var uni = nouvel Univers();
var uni2 = nouvel Univers();
console.log(uni === uni2); // vrai

//Ajouter des attributs de prototype
Univers.prototype.nothing = true;

var uni = nouvel Univers();

Universe.prototype.everything = true;

var uni2 = nouvel Univers();

console.log(uni.nothing); // vrai
console.log(uni2.nothing); // vrai
console.log(uni.everything); // vrai
console.log(uni2.everything); // vrai
console.log(uni.constructor === Univers); // true

Méthode 4 :

Copier le code Le code est le suivant :

var Univers ;

(fonction () {

instance var ;

Univers = fonction Univers() {

si (instance) {
             renvoyer l'instance ;
>

instance = ceci;

//Autre contenu
This.start_time = 0;
This.bang = "Gros";
};
} ());

//Code de test
var a = nouvel Univers();
var b = nouvel Univers();
alerte(a === b); // vrai
a.bang = "123";
alerte(b.bang); // 123