Artikel ini merangkum penggunaan JavaScript tentang warisan. Bagikan untuk referensi Anda. Dengan rincian sebagai berikut:
contoh:
Salin kode sebagai berikut:/**
* Subkelas implementasi mewarisi kelas induk, tetapi tidak menghasilkan sifat dan metode yang tidak perlu
* @returns {function}
*/
define (function () {
fungsi return (subtipe, supertype) {
var proto = objek baru (supertype.prototype);
proto.constructor = subtipe;
subtype.prototype = proto;
};
});
// ―66 ―6 secara
define (function () {
fungsi ostring
{
this.str = s;
this.length = this.str.length;
}
ostring.prototype.show = function () {
waspada (this.str);
};
mengembalikan ostring;
});
// ―66 ―6 secara
Tentukan (['warisan', 'ostring'], fungsi (waris, ostring) {
fungsi wstring {
// Gunakan panggilan ke konstruktor kelas induk
ostring.call (ini, s);
this.chlength = 2 * s.length;
}
// mewarisi atribut lain
warisan (wstring, ostring);
wstring.prototype.add = fungsi (w)
{
waspada (this.str + w);
};
mengembalikan wstring;
});
Lihatlah contohnya lagi
1. Gunakan fungsi untuk diimplementasikan:
Salin kode sebagai berikut: function person (name) {
this.name = name;
}
Person.prototype.getName = function () {
kembalikan nama ini;
}
Fungsi penulis (nama, buku) {
this.inherit = orang;
this.inherit (nama);
this.books = buku;
}
var au = penulis baru ("dororo", "pelajari banyak");
au.name
Atau setara:
Salin kode sebagai berikut: function person (name) {
this.name = name;
}
Person.prototype.getName = function () {
kembalikan nama ini;
}
Fungsi penulis (nama, buku) {
Person.call (ini, nama);
this.books = buku;
}
var au = penulis baru ("dororo", "pelajari banyak");
au.getname
Karena ini hanya menganggap ini sebagai parameter, memanggil konstruktor orang tua kelas orang tua dan menugaskan semua domain yang ditugaskan ke kelas induk ke subkelas penulis, domain apa pun yang didefinisikan di luar konstruktor orang tua tidak akan diwarisi. Jadi dalam contoh di atas, au.getName tidak akan didefinisikan (tidak ditentukan) karena getName didefinisikan dalam objek prototipe orang.
Selain itu, konstruktor subclass harus memanggil konstruktor kelas induk sebelum mendefinisikan domainnya sendiri, agar tidak menimpa definisi subclass oleh kelas induk. Dengan kata lain, penulis mendefinisikan buku properti setelah orang. Call, jika tidak, itu akan ditimpa oleh properti secara langsung. Pada saat yang sama, yang terbaik adalah tidak menggunakan prototipe untuk menentukan domain fungsi subclass dalam subkelas, karena setelah subclass baru dan instantiated, prototipe harus dieksekusi, dan kemudian konstruktor kelas induk dipanggil, yang juga mudah ditimpa oleh atribut kelas orang tua.
2. Gunakan prototipe untuk mengimplementasikan:
Salin kode sebagai berikut: function person (name) {
this.name = name;
}
Person.prototype.getName = function () {
kembalikan nama ini;
}
Fungsi penulis (nama, buku) {
this.books = buku;
}
OUTHOR.PROTOTYPE = orang baru (nama);
Woriter.prototype.constructor = penulis;
OUTHOR.PROTOTYPE.GetBooks = function () {
kembalikan buku ini;
}
var au1 = penulis baru ("dororo1", "pelajari banyak");
var au2 = penulis baru ("dororo2", "pelajari lebih sedikit");
alert (au1.getName ());
alert (au2.getname ());
Metode ini menghindari masalah bahwa prototipe tidak dapat diwariskan dalam implementasi fungsi. Karena wornor.prototype = orang baru (nama); instance orang baru () akan memanggil semua properti orang konstruksi dan prototipe. Tetapi kerugiannya adalah bahwa penulis.prototype telah dipakai. Jadi ketika subclass dipakai, semua tipe data non-base adalah salinan referensi. Jadi dalam contoh di atas, nilai yang dikembalikan dengan contoh au1 atau au2 adalah dororo1.
3. Gunakan "hibrida" untuk mencapai
Salin kode sebagai berikut: function person (name) {
this.name = name;
}
Person.prototype.getName = function () {
kembalikan nama ini;
}
Fungsi penulis (nama, buku) {
this.base = orang baru (nama);
untuk (tombol var di this.base) {
if (! This [key]) {
ini [key] = this.base [key];
}
}
this.book = buku;
}
var au1 = penulis baru ("dororo1", "work");
var au2 = penulis baru ("dororo2", "play");
alert (au1.getName ());
alert (au2.getname ());
au1.book;
au2.book;
Itu milik ekstensi, salin semua domain kelas induk ke subclass. Tidak ada masalah dalam dua aspek di atas sama sekali.
Mode Kombinasi Parasit)
JS Warisan mencakup warisan atribut dan warisan metode, yang diimplementasikan melalui metode yang berbeda.
1. Warisan atribut
Warisan atribut dicapai dengan mengubah lingkungan eksekusi fungsi. Lingkungan eksekusi mengubah fungsi dapat diimplementasikan menggunakan dua metode: call () dan apply ().
Kami pertama -tama membuat "kelas" hewan (karena tidak ada konsep kelas di JS, di sini hanya tiruan, sebenarnya hanya objek fungsi fungsi).
Salin kode sebagai berikut: Function Animal (Typename) {
// Tambahkan nama tipe properti untuk lingkungan eksekusi metode saat ini (ini)
// tetapi lingkungan eksekusi (ini) harus dieksekusi sebelum dapat ditentukan
this.typeName = typename;
this.colors = ["merah", "while"];
}
// Saya ingin menambahkan dua metode (objek dibagikan) ke prototipe fungsi
Animal.prototype.shout = function () {alert ("I Am: -" + this.typeName);};
Animal.prototype.eat = function () {alert ("I Am: -" + this.typeName)};
//-Tentukan singa-"kelas" (sebenarnya fungsi)
fungsi singa (tn) {
//-Jalankan metode hewan dan memodifikasi lingkungan eksekusi hewan ke singa ini melalui parameter pertama Apply
// Demikian pula, singa ini harus dieksekusi untuk menentukan siapa itu
Hewan.
}
Lion.prototype = Animal.prototype; // mewarisi metode kelas induk dan menyelesaikannya-tetapi ini tidak ditulis dengan baik. Ketika kelas anak menambahkan metode, kelas induk juga memiliki metode ini. Ini adalah referensi pointer
Lion.prototype.hunt = function () {
waspada ("Saya: singa, saya ingin berburu ~~ ・ ~");
}
var aminm = hewan baru ();
aminm.hunt (); // --- Anda dapat mengakses metode subkelas, yang tidak bagus
// ---- jadi bagaimana menyelesaikan masalah ini? ? ? ? ? ?
// --- Solusi: Anda dapat menulis ini saat mewarisi metode:
Lion.prototype = hewan baru (); // mewarisi metode kelas induk dan menetapkan objek hewan ke prototipe prototipe. Bahkan, ia juga memiliki atribut di dalamnya.
var Lion = new Lion (); // Selain membuat kata kunci baru, itu juga akan memodifikasi lingkungan eksekusi objek singa ke objek singa itu sendiri
// --- Dengan kata lain, setelah baru selesai, ini dalam fungsi singa adalah fungsi singa itu sendiri, dan kemudian fungsi singa disebut
Menganalisis kata kunci baru:
Kata kunci baru sangat bagus. Dalam kode sebelumnya, kata kunci baru menyelesaikan tugas -tugas berikut:
1) Buka ruang tumpukan untuk bersiap menyimpan benda singa
2) Ubah lingkungan eksekusi objek singa itu sendiri sehingga fungsi singa ini menunjuk ke objek fungsi singa itu sendiri.
3) Hubungi "Konstruktor" dari kelas singa "dan buat objek singa
4) Tetapkan alamat heap objek fungsi singa ke variabel l, dan pada saat ini L menunjuk ke objek fungsi singa
Lion.shout ();
Lion.eat ();
Namun, warisan ini memiliki kelemahan: konstruktor kelas induk disebut dua kali, hubungi sekali, dan kemudian baru lagi.
Saya harap artikel ini akan membantu pemrograman JavaScript semua orang.