Warisan berbasis rantai prototipe JavaScript

JavaScript bukan bahasa yang berorientasi objek dan tidak memberikan metode warisan tradisional, tetapi memberikan cara prototipe warisan, menggunakan properti prototipe yang disediakan untuk mencapai pewarisan.

Rantai prototipe adalah metode utama warisan dalam JavaScript.

Ide dasar rantai prototipe adalah: Gunakan prototipe untuk memungkinkan satu jenis referensi mewarisi sifat dan metode jenis referensi lain.

Hubungan antara konstruktor, prototipe dan instance: Setiap konstruktor memiliki objek prototipe, objek prototipe berisi pointer ke konstruktor, dan instance berisi pointer internal ke objek prototipe.

Jika objek prototipe sama dengan contoh objek lain, objek prototipe akan berisi pointer ke prototipe lain, dan karenanya, prototipe lain juga berisi pointer ke konstruktor lain.

Mode Dasar Menerapkan Rantai Prototipe:

 function supertype () {this.property = true;} supertype.prototype.getSupervalue = function () {return this.property;}; function subtipe () {this.subpropery = false;} // whertypeSubType.prototype = new supertype (); functipe ()ProType () (); functipe. )EnprotypeType. {return this.subproperty;}; var instance = new subtipe (); waspada (instance.getSupervalue ()); // BENAR

Subtipe mewarisi supertype, yang dicapai dengan membuat instance supertype dan menetapkan instance ke subtype.prototype. Inti dari implementasi adalah untuk menulis ulang objek prototipe dan menggantinya dengan instance jenis baru. Dengan cara ini, sifat dan metode yang awalnya ada dalam instance supertype juga ada di subtype.prototype. Kemudian tambahkan metode ke subtipe.prototype, yang menambahkan metode lain berdasarkan mewarisi properti dan metode supertype.

Hubungan instan dalam contoh di atas dinyatakan sebagai berikut:

Di atas tidak menggunakan prototipe yang disediakan oleh subtipe secara default, tetapi gantinya menggantinya dengan prototipe baru; Prototipe baru ini adalah contoh supertype. Ada juga pointer untuk prototipe yang mengeksekusi supertype di dalam prototipe baru. Akibatnya, instance menunjuk ke prototipe subtipe, yang menunjuk ke prototipe supertype. Metode getValue () masih di supertype.prototype, tetapi prototipe ada di subtype.prototype. Ini karena properti adalah properti instan, dan getSupervalue () adalah metode prototipe. Karena subtype.prototype sekarang menjadi contoh supertype, properti secara alami terletak dalam contoh itu.

Catatan: Instance.Constructor sekarang menunjuk ke SuperType, karena prototipe titik subtipe ke objek lain - prototipe SuperType, dan atribut konstruktor dari objek prototipe ini ke supertype.

Saat mengakses atribut dalam mode baca, instance pertama kali mencari atribut itu. Jika properti tidak ditemukan. Kemudian pencarian prototipe instance akan berlanjut. Ketika warisan dicapai melalui rantai prototipe, proses pencarian dapat terus bergerak ke atas di sepanjang rantai prototipe.

Prototipe default

Semua jenis referensi mewarisi objek secara default, dan warisan ini juga diimplementasikan melalui rantai prototipe. Prototipe default dari semua fungsi adalah instance dari objek. Oleh karena itu, prototipe default akan berisi pointer internal ke objek.prototype. Inilah sebabnya mengapa tipe kustom akan mewarisi metode seperti tostring (), valueOf (), dll.

Rantai prototipe lengkap:

Dalam sistem warisan di atas, subtipe mewarisi supertype, dan supertype mewarisi objek. Ketika instance.toString () dipanggil, metode yang disimpan di objek.Prototype sebenarnya dipanggil.

Tentukan hubungan antara instance dan prototipe

Ada dua cara untuk menentukan hubungan antara prototipe dan contoh:

Gunakan contoh operator

 waspada (instance dari objek); peringatan (instance dari supertype); peringatan (instance dari subtipe);

Karena hubungan antara rantai prototipe, semua pengembalian di atas benar.

Gunakan metode isPrototypeOf ()

 alert (object.prototype.isprototypeOf (instance)); alert (supertype.prototype.isprototypeOf (instance)); alert (subtype.prototype.isprototypeOf (instance)); alert (subtype.prototype.isprototypeOf (instance));

Tentukan metode dengan cermat

Kode untuk menambahkan metode ke prototipe harus ditempatkan setelah pernyataan yang menggantikan prototipe.

 function supertype () {this.property = true;} supertype.prototype.getSuperValue = function () {return this.property;}; function subType () {this.subpropery = false;} supertype.prototype = new superType ();// funche {{{new funche.prototype = new superType () (// {{{new functipe. this.subproperty;}; // menimpa metode subtipe.prototype.getSuperValue = function () {return this.subproperty;}; // implite metode subtype.prototype.getSupervalue = function () {return false;}; var instance = subtype. // PALSU

Dalam contoh di atas, harus dicatat bahwa setelah mengganti prototipe dengan contoh supertype, kemudian tentukan kedua metode tersebut.

Selain itu, saat mewarisi melalui rantai prototipe, Anda tidak dapat menggunakan objek secara literal untuk membuat metode prototipe. Karena hal itu akan menulis ulang rantai prototipe:

 function SuperType() {this.property = true;}SuperType.prototype.getSuperValue = function () {return this.property;};function SubType() {this.subproperty = false;}// Inherit SuperTypeSubType.prototype = new SuperType();// Add a new method using literals, resulting in the previous line of code invalid SubType.prototype = {getSubValue: function () {return this.subproperty;}, someothermethod: function () {return false;}}; var instance = new subtipe (); waspada (instance.getSupervalue ()); // kesalahan

Contoh di atas memberikan instance supertype ke prototipe, dan kemudian menggantikan prototipe dengan objek literal. Prototipe saat ini berisi instance objek, bukan contoh supertype, dan tidak ada hubungan antara subtipe dan supertype.

Masalah rantai prototipe

Seperti disebutkan sebelumnya, atribut prototipe yang berisi jenis referensi dibagikan oleh semua contoh; Inilah sebabnya mengapa atribut harus didefinisikan dalam konstruktor daripada pada objek prototipe.

 fungsi supertype () {this.colors = ["red", "blue", "green"];} function subtipe () {} subtipe.prototype = supertype baru (); var instance1 = new subtipe (); instance1.colors.push ("black"); waspada (instance1.colors); // "merah", "biru", "hijau", "hitam" var instance2 = subtipe baru (); peringatan (instance2.colors); // "merah", "biru", "hijau", "hitam"

Dalam contoh di atas, properti warna didefinisikan dalam konstruktor supertype, yang berisi array, dan setiap contoh supertype akan memiliki properti warna yang berisi arraynya sendiri. Setelah subtipe mewarisi supertype melalui rantai prototipe, subtipe.prototype menjadi instance supertype, sehingga juga memiliki atribut warnanya sendiri. Namun, semua contoh subtipe berbagi properti yang satu ini.

Masalah lain adalah bahwa tidak ada cara untuk meneruskan parameter ke konstruktor superclass tanpa mempengaruhi semua instance objek.

Di atas adalah pengetahuan yang relevan dari JavaScript berdasarkan warisan rantai prototipe yang diperkenalkan oleh editor kepada Anda. Saya harap ini akan membantu Anda. Jika Anda memiliki pertanyaan, silakan tinggalkan saya pesan dan editor akan membalas Anda tepat waktu. Terima kasih banyak atas dukungan Anda ke situs web Wulin.com!