memperkenalkan
Pemrograman apa pun mengusulkan penggunaan kembali kode. Jika tidak, jika Anda perlu menulis program baru setiap kali Anda mengembangkan program baru atau menulis fungsi baru, maka itu akan menjadi sia -sia. Namun, penggunaan kembali kode juga baik atau buruk. Dalam dua artikel berikutnya, kita akan membahas penggunaan kembali kode. Artikel pertama menghindari penggunaan pola -pola ini sebanyak mungkin, karena membawa beberapa masalah pada tingkat yang lebih besar atau lebih kecil; Baris kedua adalah rekomendasi, yang mengacu pada pola yang disarankan yang digunakan semua orang, dan umumnya tidak akan ada masalah.
Mode 1: Mode Default
Seringkali ada masalah dengan penggunaan kembali kode dari mode default yang biasa digunakan oleh semua orang. Mode ini menggunakan konstruktor Parent () untuk membuat objek dan menetapkan objek ke prototipe anak (). Mari kita lihat kodenya:
Salinan kode adalah sebagai berikut:
fungsi warisan (c, p) {
C.prototype = p baru ();
}
// konstruktor induk
Function Parent (Name) {
this.name = name || 'Adam';
}
// tambahkan fungsi ke prototipe
Parent.prototype.say = function () {
kembalikan nama ini;
};
// Konstruktor anak kosong
function child (name) {
}
// Jalankan warisan
warisan (anak, orang tua);
var anak = anak baru ();
console.log (kid.say ()); // "Adam"
var kiddo = anak baru ();
kiddo.name = "Patrick";
console.log (kiddo.say ()); // "Patrick"
// Kekurangan: Anda tidak dapat meneruskan parameter ke dalam konstruktor anak
var s = anak baru ('seth');
console.log (s.say ()); // "Adam"
Kerugian dari mode ini adalah bahwa anak tidak dapat melewati parameter, yang pada dasarnya tidak berguna.
Pola 2: Pinjaman Konstruktor
Pola ini adalah bahwa anak meminjam konstruktor orang tua untuk diterapkan, dan kemudian meneruskan ini anak -anak dan parameter ke metode Apply:
Salinan kode adalah sebagai berikut:
// konstruktor induk
Function Parent (Name) {
this.name = name || 'Adam';
}
// tambahkan fungsi ke prototipe
Parent.prototype.say = function () {
kembalikan nama ini;
};
// Konstruktor Anak
function child (name) {
Parent.Apply (ini, argumen);
}
var kid = anak baru ("Patrick");
console.log (kid.name); // "Patrick"
// Kekurangan: Metode Say tidak diwarisi dari konstruktor
console.log (typeof kid.say); // "belum diartikan"
Kerugiannya juga jelas, dan metode mengatakan tidak tersedia karena belum diwariskan.
Pola 3: Pinjam konstruktor dan atur prototipe
Dua mode di atas memiliki kekurangannya sendiri, jadi bagaimana cara menghapus kekurangan keduanya? Ayo coba:
Salinan kode adalah sebagai berikut:
// konstruktor induk
Function Parent (Name) {
this.name = name || 'Adam';
}
// tambahkan fungsi ke prototipe
Parent.prototype.say = function () {
kembalikan nama ini;
};
// Konstruktor Anak
function child (name) {
Parent.Apply (ini, argumen);
}
Child.prototype = new Parent ();
var kid = anak baru ("Patrick");
console.log (kid.name); // "Patrick"
console.log (typeof kid.say); // fungsi
console.log (kid.say ()); // Patrick
Console.dir (anak);
hapus anak -anak.
console.log (kid.say ()); // "Adam"
Ketika berjalan, semuanya normal, tetapi apakah Anda memperhatikan bahwa konstruktor induk dieksekusi dua kali, jadi meskipun programnya tersedia, itu sangat tidak efisien.
Mode 4: Prototipe Bersama
Prototipe yang dibagikan berarti bahwa anak dan orang tua menggunakan prototipe yang sama, kode ini adalah sebagai berikut:
Salinan kode adalah sebagai berikut:
fungsi warisan (c, p) {
C.prototype = p.prototype;
}
// konstruktor induk
Function Parent (Name) {
this.name = name || 'Adam';
}
// tambahkan fungsi ke prototipe
Parent.prototype.say = function () {
kembalikan nama ini;
};
// Konstruktor Anak
function child (name) {
}
warisan (anak, orang tua);
var kid = anak baru ('Patrick');
console.log (kid.name); // belum diartikan
console.log (typeof kid.say); // fungsi
kid.name = 'Patrick';
console.log (kid.say ()); // Patrick
Console.dir (anak);
Sudah pasti bahwa hal yang sama benar, parameter anak tidak diterima dengan benar.
Pola 5: Konstruktor sementara
Pertama, pinjam konstruktor, lalu atur prototipe anak ke contoh konstruktor yang dipinjam, dan akhirnya mengembalikan konstruktor prototipe anak. Kodenya adalah sebagai berikut:
Salinan kode adalah sebagai berikut:
/* Penutup*/
var wherit = (function () {
var f = function () {
};
fungsi pengembalian (c, p) {
F.prototype = p.prototype;
C.prototype = f () baru;
C.uber = p.prototype;
C.prototype.constructor = C;
}
} ());
Function Parent (Name) {
this.name = name || 'Adam';
}
// tambahkan fungsi ke prototipe
Parent.prototype.say = function () {
kembalikan nama ini;
};
// Konstruktor Anak
function child (name) {
}
warisan (anak, orang tua);
var anak = anak baru ();
console.log (kid.name); // belum diartikan
console.log (typeof kid.say); // fungsi
kid.name = 'Patrick';
console.log (kid.say ()); // Patrick
var kid2 = anak baru ("tom");
console.log (kid.say ());
console.log (kid.constructor.name); // Anak
console.log (kid.constructor === induk); // PALSU
Masalahnya masih sama, anak tidak dapat menerima parameter secara normal.
Mode 6: Klass
Mari kita mulai dengan kode untuk pola ini:
Salinan kode adalah sebagai berikut:
var klass = fungsi (induk, props) {
Var Child, F, I;
// 1.
// konstruktor baru
Anak = fungsi () {
if (child.uber && child.uber.hasownproperty ("__ construct")) {
Child.uber .__ Construct.Apply (ini, argumen);
}
if (child.prototype.hasownproperty ("__ construct")) {
Child.prototype .__ construct.Apply (ini, argumen);
}
};
// 2.
// Warisan
Parent = Parent || Obyek;
F = function () {
};
F.prototype = parent.prototype;
Child.prototype = baru f ();
Child.uber = Parent.prototype;
Child.prototype.constructor = anak;
// 3.
// Tambahkan metode implementasi
untuk (i in props) {
if (props.hasownproperty (i)) {
Child.prototype [i] = props [i];
}
}
// kembalikan "kelas"
anak kembali;
};
var man = klass (null, {
__construct: function (apa) {
Console.log ("Konstruktor Manusia");
this.name = apa;
},
getName: function () {
kembalikan nama ini;
}
});
var first = new man ('adam'); // log "konstruktor pria"
first.getName (); // "Adam"
var superman = klass (man, {
__construct: function (apa) {
Console.log ("Konstruktor Superman");
},
getName: function () {
var name = superman.uber.getname.call (ini);
mengembalikan "I Am" + nama;
}
});
var clark = superman baru ('clark kent');
clark.getname (); // "Saya Clark Kent"
console.log (instance clark man); // BENAR
console.log (instance Clark dari Superman); // BENAR
Bagaimana dengan itu? Apakah sedikit pusing untuk dilihat? Agar baik, tata bahasa dan spesifikasi pola ini sama dengan bahasa lain. Apakah Anda bersedia menggunakannya? batuk. . .
Meringkaskan
Meskipun enam mode di atas menerapkan fungsi -fungsi tertentu dalam keadaan khusus tertentu, mereka semua memiliki kekurangannya sendiri, jadi secara umum, semua orang harus menghindari menggunakannya.