Explication du modèle de conception Singleton pour la programmation JavaScript_Connaissances de base

En Javascript, le modèle singleton est l'un des modèles de conception les plus basiques et les plus fréquemment utilisés. Vous pouvez utiliser le modèle singleton par inadvertance.
Cet article commencera par la théorie la plus élémentaire, décrira les concepts de base et la mise en œuvre du modèle singleton, et enfin utilisera un exemple pour décrire l'application du modèle singleton.

Base théorique

Concept

Le mode Singleton, comme son nom l'indique, signifie qu'une seule instance existe. Le mode singleton peut garantir qu'il n'y a qu'une seule instance d'une classe dans le système et que l'instance est facilement accessible depuis le monde extérieur, facilitant ainsi le contrôle du nombre d'instances et économisant les ressources du système. Si vous souhaitez qu'un seul objet d'une certaine classe existe dans le système, le modèle singleton est la meilleure solution.

Structure de base

Le modèle singleton le plus simple commence par un littéral d'objet, qui organise ensemble les propriétés et les méthodes associées.

var singleton = {
  prop:"value",
  method:function(){
  }
}

Dans cette forme de mode singleton, tous les membres sont publics et accessibles via singleton. L'inconvénient est qu'il existe certaines méthodes auxiliaires dans le singleton qui ne devraient pas être exposées aux utilisateurs. Si l'utilisateur utilise ces méthodes et que certaines méthodes auxiliaires sont ensuite supprimées lors d'une maintenance ultérieure, cela entraînera des erreurs de programme.
Comment éviter de telles erreurs ?

Modèle Singleton avec membres privés

Comment créer des membres privés dans une classe ? Ceci est réalisé en exigeant des fermetures. Concernant la connaissance des fermetures, cet article n'entrera pas dans les détails. Vous pouvez le rechercher vous-même.
Le formulaire de base est le suivant :

var singleton = (function () {
      var privateVar = "private";
      return {
        prop: "value",
        method: function () {
          console.log(privateVar);
        }
      }
    })();

La première est une fonction anonyme auto-exécutable. Dans la fonction anonyme, une variable privateVar est déclarée et un objet est renvoyé et affecté à l'objet singleton. La variable privateVar n'est pas accessible en dehors de la fonction anonyme. C'est la variable privée de l'objet singleton. Cette variable privée n'est accessible qu'à l'intérieur de la fonction ou via des méthodes exposées. Cette forme est également appelée modèle de module.

Instanciation paresseuse

Qu'il s'agisse d'un mode littéral direct ou d'un mode singleton membre privé, les deux sont des singletons créés lors du chargement du script. Cependant, parfois, la page peut ne jamais utiliser cet objet singleton, ce qui entraînera un gaspillage de ressources. Dans cette situation, la meilleure façon de résoudre ce problème est le chargement paresseux, ce qui signifie que l'objet singleton n'est réellement instancié que lorsque cela est nécessaire. Comment y parvenir ?

var singleton = (function () {
      function init() {
        var privateVar = "private";
        return {
          prop: "value",
          method: function () {
            console.log(privateVar);
          }
        }
      }
      var instance = null;
      return {
        getInstance: function () {
          if (!instance) {
            instance = init();
          }
          return instance;
        }
      }
    })();

Encapsulez d'abord le code de création d'un objet singleton dans la fonction init, puis déclarez une instance de variable privée pour représenter l'instance de l'objet singleton et exposez une méthode getInstance pour obtenir l'objet singleton.
Lors de l'appel, il est appelé via singleton.getInstance(). L'objet singleton est réellement créé lorsque getInstance est appelé.

Occasions applicables

Le modèle singleton est le modèle de conception le plus couramment utilisé dans JS Du point de vue de l'amélioration de la modularité et de l'organisation du code, le modèle singleton doit être utilisé autant que possible. Il peut organiser les codes associés pour faciliter la maintenance. Pour les grands projets, le chargement paresseux de chaque module peut améliorer les performances, masquer les détails d'implémentation et exposer les API couramment utilisées. Les bibliothèques de classes courantes telles que le trait de soulignement et jQuery peuvent être considérées comme des applications en mode singleton.

Combiné avec un combat réel

Comme mentionné précédemment, le modèle singleton est l'un des modèles de conception les plus couramment utilisés. Donnons un exemple pour illustrer,
Le code suivant implémente principalement une classe d'assistance de date simple, implémentée via le mode singleton :

Structure de base du modèle singleton

var dateTimeHelper = {
      now: function () {
        return new Date();
      },
      format: function (date) {
        return date.getFullYear() + "-" + (date.getMonth() + 1) + "-" + date.getDate();
      }
    }; 
console.log(dateTimeHelper.now());<br />

Ce code implémente le mode singleton via des littéraux d'objet, et vous pouvez appeler directement la méthode lorsque vous l'utilisez.

Le chargement paresseux implémente le modèle singleton

 var dateTimeHelper = (function () {
      function init() {
        return {
          now: function () {
            return new Date();
          },
          format: function (date) {
            return date.getFullYear() + "-" + (date.getMonth() + 1) + "-" + date.getDate();
          }
        }
      }
      var instance = null;
      return {
        getInstance: function () {
          if (!instance) {
            instance = init();
          }
          return instance;
        }
      }
    })(); 
console.log(dateTimeHelper.getInstance().now())

Il s'agit du modèle singleton à chargement paresseux.

Regardons quelques exemples supplémentaires :
Implémentation 1 : Le littéral d'objet le plus simple

var singleton = {

    attr : 1,

    method : function(){ return this.attr; }

  }



var t1 = singleton ;

var t2 = singleton ;

Alors évidemment, t1 === t2.

C'est très simple et très facile à utiliser. L'inconvénient est qu'il n'y a pas d'encapsulation et que toutes les méthodes d'attributs sont exposées. Pour certaines situations où des variables privées doivent être utilisées, cela semble insuffisant. Bien entendu, cela présente également certains inconvénients.

Implémentation 2 : Jugement interne du constructeur

En fait, elle est quelque peu similaire à l'implémentation JS originale, sauf que le jugement quant à savoir si une instance de la classe existe déjà est placé à l'intérieur du constructeur.

function Construct(){

  // 确保只有单例

  if( Construct.unique !== undefined ){

    return Construct.unique; 

  }

  // 其他代码

  this.name = "NYF";

  this.age="24";

  Construct.unique = this;

}



var t1 = new Construct() ;

var t2 = new Construct() ;

那么也有的， t1 === t2 。

也是非常简单，无非就是提出一个属性来做判断，但是该方式也没有安全性，一旦我在外部修改了Construct的unique属性，那么单例模式也就被破坏了。

实现3 : 闭包方式

对于大着 灵活 牌子的JS来说，任何问题都能找到 n 种答案，只不过让我自己去掂量孰优孰劣而已，下面就简单的举几个使用闭包实现单例模式的方法，无非也就是将创建了的单例缓存而已。

var single = (function(){

  var unique;

  function Construct(){

    // ... 生成单例的构造函数的代码

  }



  unique = new Constuct();



  return unique;

})();

只要 每次讲 var t1 = single; var t2 = single;即可。 与对象字面量方式类似。不过相对而言更安全一点，当然也不是绝对安全。

如果希望会用调用 single() 方式来使用，那么也只需要将内部的 return 改为

  return function(){

    return unique;

  } 

    以上方式也可以使用 new 的方式来进行（形式主义的赶脚）。当然这边只是给了闭包的一种例子而已，也可以在 Construct 中判断单例是否存在 等等。 各种方式在各个不同情况做好选着即可。

总结

单例模式的好处在于对代码的组织作用，将相关的属性和方法封装在一个不会被多次实例化的对象中，让代码的维护和调试更加轻松。隐藏了实现细节，可以防止被错误修改，还防止了全局命名空间的污染。另外可以通过惰性加载提高性能，减少不必要的内存消耗。