Ringkasan penggunaan warisan dalam kemahiran javascript_javascript

Contoh dalam artikel ini meringkaskan penggunaan warisan dalam JavaScript. Kongsikan dengan semua orang untuk rujukan anda. Butirannya adalah seperti berikut:

Contoh:

Salin kod Kod adalah seperti berikut:

/**
* Laksanakan subkelas untuk diwarisi daripada kelas induk tanpa menghasilkan atribut dan kaedah berlebihan
* @kembali {Fungsi}
*/
define(function(){
fungsi pulangan(subType, superType){
var proto = Objek baharu(superType.prototype);
proto.constructor = subType;
subType.prototype = proto;
};
});
//————————————————————————
define(function(){
fungsi ostring(s)
{
this.str = s;
this.length = this.str.length;
}
ostring.prototype.show = function(){
makluman(this.str);
};
kembalikan ostring;
});
//————————————————————————
define(['inherit', 'ostring'], function(inherit, ostring){
fungsi wstring(s){
//Gunakan panggilan untuk memanggil pembina kelas induk
ostring.call(this, s);
this.chlength = 2 * s.length;
}
//Warisi atribut lain
mewarisi(wstring, ostring);
wstring.prototype.add = function(w)
{
makluman(ini.str w);
};
kembalikan wstring;
});

Lihat contoh sekali lagi
1. Gunakan fungsi untuk melaksanakan:

Salin kod Kod adalah seperti berikut:

fungsi Orang(nama) {
This.name = nama;
}
Person.prototype.getName = function() {
Kembalikan nama ini;
}
fungsi Pengarang(nama, buku) {
This.inherit=person;
This.inherit(nama);
This.books = buku;
 
}
var au=New Author("dororo","Belajar banyak");
au.name

Atau setara:

Salin kod Kod adalah seperti berikut:

fungsi Orang(nama) {
This.name = nama;
}
Person.prototype.getName = function() {
Kembalikan nama ini;
}
fungsi Pengarang(nama, buku) {
Person.call(ini, nama);
This.books = buku;
 
}
var au=New Author("dororo","Belajar banyak");
au.getName

Oleh kerana ini hanya menggunakan ini sebagai parameter, memanggil pembina kelas induk Orang, dan memberikan semua medan yang diberikan kepada kelas induk kepada subkelas Pengarang, mana-mana medan yang ditentukan (prototaip) selain daripada kelas induk Pembina Orang tidak akan digunakan oleh subkelas akan diwarisi. Jadi dalam contoh di atas, au.getName tidak akan ditentukan kerana getName ditakrifkan dalam objek prototaip Person.

Selain itu, pembina subkelas mesti memanggil pembina kelas induk sebelum menentukan domainnya sendiri, untuk mengelakkan definisi subkelas daripada ditimpa oleh kelas induk. Dalam erti kata lain, buku atribut yang ditakrifkan Pengarang mestilah selepas Person.call, jika tidak, ia akan ditimpa oleh atribut dalam Person. Pada masa yang sama, adalah lebih baik untuk tidak menggunakan prototaip untuk menentukan domain fungsi subkelas dalam subkelas, kerana selepas subkelas baharu dan instantiated, prototaip mesti dilaksanakan, dan kemudian pembina kelas induk dipanggil, yang juga mudah untuk menjadi Atribut kelas induk ditimpa.

2. Gunakan prototaip untuk melaksanakan:

Salin kod Kod adalah seperti berikut:

fungsi Orang(nama) {
This.name = nama;
}
Person.prototype.getName = function() {
Kembalikan nama ini;
}
fungsi Pengarang(nama, buku) {
This.books = buku; }
Author.prototype=new Person(name);
Author.prototype.constructor=Author;
Author.prototype.getBooks = function() {
Kembalikan this.books;
}
var au1=Pengarang baharu("dororo1","Ketahui banyak");
var au2=Pengarang baharu("dororo2","Belajar lebih sedikit");
alert(au1.getName());
alert(au2.getName());

Kaedah ini mengelakkan masalah tidak dapat mewarisi prototaip dalam pelaksanaan fungsi. Kerana Author.prototype=new Person(name); new Person() instance akan memanggil Person constructor dan semua sifat prototaip. Tetapi kelemahannya ialah Author.prototype telah pun dibuat instantiated. Oleh itu, apabila subkelas dijadikan instantiated, semua jenis data bukan asas adalah salinan rujukan. Jadi dalam contoh di atas, nilai yang dikembalikan oleh kedua-dua kejadian au1 dan au2 ialah dororo1.

3. Gunakan "pencampuran" untuk mencapai

Salin kod Kod adalah seperti berikut:

fungsi Orang(nama) {
This.name = nama;
}
Person.prototype.getName = function() {
Kembalikan nama ini;
}
fungsi Pengarang(nama, buku) {
This.base = Orang(nama) baharu;
for(var key in this.base){
          jika(!ini [kunci]){
This[key]=this.base[key];
           }
           }
This.book=books;
}
var au1=Pengarang baharu("dororo1","kerja");
var au2=Pengarang baharu("dororo2","main");
alert(au1.getName());
alert(au2.getName());
au1.book;
au2.book;

Ia adalah sambungan dan menyalin semua medan kelas induk ke kelas anak. Tiada masalah dengan kedua-dua aspek di atas sama sekali.
Mod gabungan parasit)

Pewarisan JS termasuk pewarisan atribut dan pewarisan kaedah, yang dilaksanakan melalui kaedah yang berbeza.
1. Pewarisan sifat

Warisan atribut dicapai dengan menukar persekitaran pelaksanaan fungsi. Menukar persekitaran pelaksanaan fungsi boleh dicapai menggunakan kaedah call() dan apply().

Kami mula-mula mencipta "kelas" Haiwan (kerana tiada konsep kelas dalam JS, di sini hanyalah simulasi, ia sebenarnya hanya objek Fungsi).

Salin kod Kod adalah seperti berikut:

fungsi Animal(typeName) {
//Tambahkan atribut typeName
pada persekitaran pelaksanaan (ini) kaedah semasa //Tetapi persekitaran pelaksanaan (ini) hanya boleh ditentukan apabila fungsi ini dilaksanakan
this.typeName = typeName;
this.colors = ["red","while"];
}
//Mahu menambah dua kaedah (yang dikongsi objek) pada prototaip fungsi
Animal.prototype.Shout = function () { alert("Saya: --" this.typeName);};
Animal.prototype.Eat = function () { alert("Saya: --" this.typeName) };
//--Takrifkan singa--"kelas" (sebenarnya fungsi)
fungsi Singa(tn) {
//--Laksanakan kaedah Haiwan, dan ubah suai persekitaran pelaksanaan Animal kepada Lion's this
melalui parameter pertama permohonan //Begitu juga, Lion's ini hanya boleh ditentukan semasa pelaksanaan
Animal.apply(this,["Lion"]);//--Mewarisi atribut pembolehubah kelas induk, ini baharu kerana ia adalah Singa, ini ialah Singa
}
Lion.prototype = Animal.prototype; //Warisi kaedah kelas induk dan selesaikan--tetapi ini tidak ditulis dengan baik Apabila subkelas menambah kaedah, kelas induk juga mempunyai kaedah ini
Lion.prototype.Hunt = fungsi () {
alert("Saya: Singa, saya mahu memburu~~·~");
}
var aminm = Haiwan baharu();
aminm.Hunt(); //---Anda boleh mengakses kaedah subkelas, yang tidak bagus
//----Jadi bagaimana untuk menyelesaikan masalah ini? ? ? ? ? ?
//---Penyelesaian: Apabila mewarisi kaedah, anda boleh menulisnya seperti ini:
Lion.prototype = new Animal();//Warisi kaedah kelas induk dan tetapkan objek Animal kepada prototaip prototaip Malah, ia juga mempunyai atribut
var lion = new Lion(); //Selain mencipta, kata kunci baharu juga mengubah suai persekitaran pelaksanaan objek Singa kepada objek Singa itu sendiri
// ---Dalam erti kata lain, selepas baru selesai, ini dalam fungsi Lion ialah fungsi Lion itu sendiri, dan kemudian fungsi Lion

dipanggil

Analisis kata kunci baharu:

Kata kunci baharu sangat hebat Dalam kod di atas, kata kunci baharu telah menyelesaikan tugasan berikut:
1) Buka ruang timbunan untuk bersedia menyimpan objek Singa
2) Ubah suai persekitaran pelaksanaan objek Lion itu sendiri supaya fungsi Lion ini menghala ke objek fungsi Lion itu sendiri.
3) Panggil "pembina" "kelas" Lion untuk mencipta objek Singa
4) Berikan alamat timbunan objek fungsi Lion kepada pembolehubah l Pada masa ini, l menunjuk ke objek fungsi Lion
singa.Jerit();
singa.Makan();
Tetapi warisan jenis ini mempunyai kelemahan: pembina kelas induk dipanggil dua kali, panggil sekali, dan kemudian baru lagi.

Saya harap artikel ini akan membantu reka bentuk pengaturcaraan JavaScript semua orang.