Penjelasan Model Reka Bentuk Singleton untuk Pengaturcaraan JavaScript_Pengetahuan Asas

Dalam Javascript, corak tunggal adalah salah satu corak reka bentuk yang paling asas dan kerap digunakan Anda boleh menggunakan corak tunggal secara tidak sengaja.
Artikel ini akan bermula dengan teori yang paling asas, menerangkan konsep asas dan pelaksanaan corak tunggal, dan akhirnya menggunakan contoh untuk menerangkan aplikasi corak tunggal.

Asas teori

Konsep

Mod tunggal, seperti namanya, bermakna hanya satu tika wujud. Mod tunggal boleh memastikan bahawa hanya terdapat satu contoh kelas dalam sistem dan contoh itu mudah diakses dari dunia luar, dengan itu memudahkan kawalan bilangan kejadian dan menjimatkan sumber sistem. Jika anda mahu hanya satu objek kelas tertentu wujud dalam sistem, corak tunggal adalah penyelesaian terbaik.

Struktur asas

Corak tunggal yang paling mudah bermula dengan literal objek, yang menyusun sifat dan kaedah yang berkaitan bersama-sama.

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

Dalam bentuk mod singleton ini, semua ahli adalah awam dan boleh diakses melalui singleton. Kelemahan ini ialah terdapat beberapa kaedah tambahan dalam singleton yang tidak dijangka akan didedahkan kepada pengguna Jika pengguna menggunakan kaedah ini, dan kemudian beberapa kaedah tambahan dipadamkan semasa penyelenggaraan berikutnya, ini akan menyebabkan ralat program.
Bagaimana untuk mengelakkan kesilapan sedemikian?

Corak singleton dengan ahli persendirian

Bagaimana untuk membuat ahli persendirian dalam kelas? Ini dicapai dengan memerlukan penutupan, artikel ini tidak akan dijelaskan secara terperinci.
Bentuk asasnya adalah seperti berikut:

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

Yang pertama ialah fungsi tanpa nama yang melaksanakan sendiri Dalam fungsi tanpa nama, pembolehubah privateVar diisytiharkan dan objek dikembalikan dan diberikan kepada objek tunggal. Pembolehubah privateVar tidak boleh diakses di luar fungsi tanpa nama Ia adalah pembolehubah peribadi objek tunggal ini hanya boleh diakses di dalam fungsi atau melalui kaedah terdedah. Borang ini juga dipanggil corak modul.

Pemalasan instan

Sama ada mod tunggal secara literal langsung atau ahli persendirian, kedua-duanya adalah tunggal yang dibuat apabila skrip dimuatkan Namun, kadangkala, halaman itu tidak boleh menggunakan objek tunggal ini, yang akan menyebabkan pembaziran sumber. Untuk situasi ini, cara terbaik untuk menanganinya ialah pemuatan malas, yang bermaksud bahawa objek tunggal sebenarnya tidak dibuat seketika sehingga diperlukan Bagaimana untuk mencapai ini?

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;
        }
      }
    })();

Mula-mula merangkum kod untuk mencipta objek tunggal ke dalam fungsi init, kemudian mengisytiharkan tika pembolehubah persendirian untuk mewakili tika objek tunggal, dan mendedahkan kaedah getInstance untuk mendapatkan objek tunggal.
Apabila memanggil, ia dipanggil melalui singleton.getInstance(). Objek tunggal sebenarnya dicipta apabila getInstance dipanggil.

Majlis yang berkenaan

Corak singleton ialah corak reka bentuk yang paling biasa digunakan dalam JS Daripada aspek mempertingkatkan modulariti dan organisasi kod, corak singleton harus digunakan sebaik mungkin. Ia boleh menyusun kod berkaitan bersama-sama untuk penyelenggaraan yang mudah Untuk projek besar, pemuatan malas setiap modul boleh meningkatkan prestasi, menyembunyikan butiran pelaksanaan dan mendedahkan API yang biasa digunakan. Pustaka kelas biasa seperti garis bawah dan jQuery boleh difahami sebagai aplikasi mod tunggal.

Digabungkan dengan pertempuran sebenar

Seperti yang dinyatakan sebelum ini, corak tunggal adalah salah satu corak reka bentuk yang paling biasa digunakan. Mari kita berikan contoh untuk menggambarkan,
Kod berikut terutamanya melaksanakan kelas pembantu tarikh ringkas, dilaksanakan melalui mod tunggal:

Struktur corak singleton asas

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

Kod ini melaksanakan mod tunggal melalui literal objek, dan anda boleh terus memanggil kaedah apabila menggunakannya.

Pemuatan malas melaksanakan corak tunggal

 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())

Ini adalah corak singleton yang malas memuatkan.

Mari kita lihat beberapa lagi contoh:
Pelaksanaan 1: Objek termudah secara literal

var singleton = {

    attr : 1,

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

  }



var t1 = singleton ;

var t2 = singleton ;

Jelas sekali, t1 === t2.

Ia sangat mudah dan sangat mudah digunakan. Kelemahannya ialah tiada enkapsulasi dan semua kaedah atribut terdedah. Untuk sesetengah situasi di mana pembolehubah persendirian perlu digunakan, ia nampaknya tidak mencukupi. Sudah tentu, terdapat juga kelemahan tertentu dalam hal ini.

Pelaksanaan 2: Pertimbangan dalaman pembina

Sebenarnya, ia agak serupa dengan pelaksanaan JS yang asal, kecuali pertimbangan sama ada suatu contoh kelas sudah wujud diletakkan di dalam pembina.

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 中判断单例是否存在 等等。 各种方式在各个不同情况做好选着即可。

总结

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