memperkenalkan
Mulai dari bab ini, kami secara bertahap akan memperkenalkan berbagai implementasi pola desain yang digunakan dalam JavaScript. Di sini saya tidak akan memperkenalkan terlalu banyak teori pola itu sendiri, tetapi hanya akan fokus pada implementasi. Oke, mulailah secara resmi.
Di mata insinyur pengembangan tradisional, singleton adalah untuk memastikan bahwa hanya ada satu contoh kelas. Metode implementasi umumnya untuk terlebih dahulu menentukan apakah instance ada atau tidak. Jika ada, itu akan dikembalikan secara langsung, dan jika tidak ada, itu akan dibuat dan kemudian dikembalikan, yang memastikan bahwa hanya ada satu objek contoh dari suatu kelas. Dalam JavaScript, Singleton bertindak sebagai penyedia namespace, memberikan titik akses unik dari namespace global untuk mengakses objek.
teks
Dalam JavaScript, ada banyak cara untuk mengimplementasikan singleton. Cara termudah adalah dengan menggunakan objek literal, yang dapat berisi sejumlah besar sifat dan metode:
Salinan kode adalah sebagai berikut:
var mysingleton = {
properti1: "sesuatu",
properti2: "sesuatu yang lain",
method1: function () {
Console.log ('Hello World');
}
};
Jika Anda ingin memperluas objek nanti, Anda dapat menambahkan anggota dan metode pribadi Anda sendiri, dan kemudian menggunakan penutupan untuk merangkum variabel -variabel ini dan deklarasi fungsi di dalamnya. Hanya anggota publik dan metode yang ingin Anda ungkapkan yang terpapar. Kode sampel adalah sebagai berikut:
Salinan kode adalah sebagai berikut:
var mysingleton = function () {
/* Mendeklarasikan variabel dan metode pribadi di sini*/
var privatevariable = 'sesuatu pribadi';
fungsi showprivate () {
console.log (privatevariable);
}
/ * Variabel dan metode publik (variabel dan metode pribadi dapat diakses) */
kembali {
publicMethod: function () {
showprivate ();
},
PublicVar: 'Publik bisa melihat ini!'
};
};
var single = mysingleton ();
single.publicmethod (); // output 'sesuatu yang pribadi'
console.log (single.publicvar); // output 'Publik bisa melihat ini!'
Kode di atas cukup bagus, tetapi bagaimana jika kita ingin melakukannya hanya menginisialisasi ketika kita menggunakannya? Untuk tujuan menghemat sumber daya, kami dapat menginisialisasi kode -kode ini di konstruktor lain, sebagai berikut:
Salinan kode adalah sebagai berikut:
var singleton = (function () {
var instantiated;
fungsi init () {
/*Tentukan kode singleton di sini*/
kembali {
publicMethod: function () {
Console.log ('Hello World');
},
PublicProperty: 'Tes'
};
}
kembali {
getInstance: function () {
if (! instantiated) {
instantiated = init ();
}
Return Instantiated;
}
};
}) ();
/*Memanggil metode publik untuk mendapatkan contoh:*/
Singleton.getInstance (). PublicMethod ();
Saya tahu bagaimana menerapkan singleton, tetapi skenario macam apa yang merupakan skenario terbaik untuk singleton yang akan digunakan? Faktanya, singleton umumnya digunakan untuk koordinasi komunikasi antara berbagai mode antara sistem. Kode berikut adalah praktik terbaik untuk singleton:
Salinan kode adalah sebagai berikut:
var singletontester = (function () {
// Parameter: Satu set parameter yang diteruskan ke singleton
fungsi singleton (args) {
// Atur variabel ARGS ke parameter yang diterima atau kosong (jika tidak disediakan)
var args = args || {};
// Atur parameter nama
this.name = 'singletontester';
// Atur nilai pointx
this.pointx = args.pointx || 6; // Dapatkan dari parameter yang diterima, atau diatur ke nilai default
// Tetapkan nilai runcing
this.pointy = args.pointy || 10;
}
// Contoh wadah
var instance;
var _static = {
Nama: 'Singletontester',
// metode untuk mendapatkan contoh
// kembalikan contoh singleton
getInstance: function (args) {
if (instance === tidak terdefinisi) {
instance = singleton baru (args);
}
instance return;
}
};
mengembalikan _static;
}) ();
var singletontest = singletontester.getInstance ({pointx: 5});
console.log (singletontest.pointx); // output 5
Metode implementasi lainnya
Metode 1:
Salinan kode adalah sebagai berikut:
fungsi universe () {
// Tentukan apakah ada contoh
if (typeof Universe.Instance === 'objek') {
Return Universe.Instance;
}
// konten lainnya
this.start_time = 0;
this.bang = "besar";
// cache
Universe.instance = ini;
// Kembalikan secara implisit ini
}
// tes
var uni = alam semesta baru ();
var uni2 = alam semesta baru ();
console.log (uni === uni2); // BENAR
Metode 2:
Salinan kode adalah sebagai berikut:
fungsi universe () {
// contoh cache
var instance = this;
// konten lainnya
this.start_time = 0;
this.bang = "besar";
// Tulis ulang konstruktor
Universe = function () {
instance return;
};
}
// tes
var uni = alam semesta baru ();
var uni2 = alam semesta baru ();
uni.bang = "123";
console.log (uni === uni2); // BENAR
console.log (uni2.bang); // 123
Metode 3:
Salinan kode adalah sebagai berikut:
fungsi universe () {
// contoh cache
var instance;
// merekonstruksi fungsi
Universe = function universe () {
instance return;
};
// pasca pemrosesan properti prototipe
Universe.prototype = ini;
// Contoh
instance = New Universe ();
// Setel ulang penunjuk konstruktor
instance.constructor = Universe;
// Fungsi lain
instance.start_time = 0;
instance.bang = "Big";
instance return;
}
// tes
var uni = alam semesta baru ();
var uni2 = alam semesta baru ();
console.log (uni === uni2); // BENAR
// Tambahkan Properti Prototipe
Universe.prototype.nothing = true;
var uni = alam semesta baru ();
Universe.prototype.everything = true;
var uni2 = alam semesta baru ();
console.log (uni.nothing); // BENAR
console.log (uni2.nothing); // BENAR
console.log (uni.everything); // BENAR
console.log (uni2.seveling); // BENAR
console.log (uni.constructor === Universe); // BENAR
Metode 4:
Salinan kode adalah sebagai berikut:
Var Universe;
(fungsi () {
var instance;
Universe = function universe () {
if (instance) {
instance return;
}
instance = ini;
// konten lainnya
this.start_time = 0;
this.bang = "besar";
};
} ());
// Kode uji
var a = alam semesta baru ();
var b = alam semesta baru ();
peringatan (a === b); // BENAR
A.bang = "123";
peringatan (b.bang); // 123