Penjelasan terperinci prototaip dan rantaian prototaip dalam pengetahuan JavaScript_Basic

Setiap objek dalam JavaScript mempunyai prototaip atribut terbina dalam Penjelasan atribut prototaip objek dalam Javascript ialah: mengembalikan rujukan kepada prototaip jenis objek. Maksudnya ialah atribut prototaip memegang rujukan kepada objek JavaScript lain yang berfungsi sebagai objek induk objek semasa.

Salin kod Kod adalah seperti berikut: A.prototaip = baru B(); Untuk memahami prototaip, anda tidak seharusnya mengelirukannya dengan warisan. Prototaip A ialah contoh B. Dapat difahami bahawa A telah mengklon semua kaedah dan sifat dalam B. A boleh menggunakan kaedah dan sifat B. Penekanan di sini adalah pada pengklonan dan bukannya warisan. Situasi ini boleh berlaku: Prototaip A ialah contoh B, dan prototaip B juga merupakan contoh A. Teruskan membaca analisis di bawah:

Pembolehubah dan fungsi peribadi

Pembolehubah dan fungsi yang ditakrifkan di dalam fungsi tidak boleh diakses oleh dunia luar jika tiada antara muka disediakan kepada dunia luar, iaitu pembolehubah dan fungsi adalah peribadi kepada fungsi tersebut.

Salin kod Kod adalah seperti berikut: Kotak Fungsi(){ var color = "biru";//Pembolehubah peribadi var fn = function() //Fungsi peribadi { } }

Dengan cara ini, pembolehubah warna dan fn tidak boleh diakses di luar Kotak objek fungsi, dan ia menjadi peribadi: Salin kod Kod adalah seperti berikut: var obj = Kotak baharu(); alert(obj.color);//pop up undefined alert(obj.fn);//Sama seperti di atas Pembolehubah statik dan fungsi

Apabila fungsi ditakrifkan dan atribut dan fungsi yang ditambahkan oleh titik "." masih boleh diakses melalui objek itu sendiri, tetapi kejadiannya tidak boleh diakses, pembolehubah dan fungsi tersebut masing-masing dipanggil pembolehubah dan fungsi statik.

Salin kod Kod adalah seperti berikut: Fungsi Obj(){}; Obj.num = 72;//Pembolehubah statik Obj.fn = function() //Fungsi statik {

}

makluman(Obj.num);//72 makluman(jenis Obj.fn)//fungsi

var t = new Obj(); alert(t.name);//undefined makluman(jenis t.fn);//undefined

Pembolehubah dan fungsi instance

Dalam pengaturcaraan berorientasikan objek, sebagai tambahan kepada beberapa fungsi perpustakaan, kami masih berharap untuk menentukan beberapa sifat dan kaedah pada masa yang sama apabila objek ditakrifkan, yang boleh diakses selepas instantiasi juga boleh melakukan ini

Salin kod Kod adalah seperti berikut: fungsi Kotak(){ This.a=[]; //Pembolehubah instance This.fn=function(){ //Kaedah contoh } }

console.log(typeof Box.a); //undefined console.log(typeof Box.fn); //undefined

var box=new Box(); console.log(typeof box.a); //objek console.log(typeof box.fn); //fungsi

Tambah kaedah dan sifat baharu contohnya pembolehubah dan kaedah

Salin kod Kod adalah seperti berikut: kotak fungsi(){ This.a=[]; //Pembolehubah instance This.fn=function(){ //Kaedah contoh } }

var box1=kotak baharu(); kotak1.a.push(1); box1.fn={}; console.log(box1.a); //[1] console.log(typeof box1.fn); //objek

var box2=New Box(); console.log(box2.a); //[] console.log(typeof box2.fn); //fungsi

A dan fn diubah suai dalam kotak1, tetapi tidak diubah dalam kotak2 Memandangkan tatasusunan dan fungsi adalah kedua-dua objek dan jenis rujukan, ini bermakna walaupun sifat dan kaedah dalam kotak1 mempunyai nama yang sama seperti dalam kotak2, ia mempunyai nama yang sama. Tetapi ia bukan rujukan, tetapi salinan sifat dan kaedah yang ditakrifkan oleh objek Kotak.

Ini bukan masalah untuk atribut, tetapi ia adalah masalah besar untuk kaedah, kerana kaedah melakukan fungsi yang sama, tetapi ia disalin dua kali Jika objek fungsi mempunyai kaedah beribu-ribu, maka setiap contoh ia mesti mengekalkan salinan beribu-ribu kaedah, yang jelas tidak saintifik Apa yang boleh kita lakukan?

Konsep asas

Setiap fungsi yang kami cipta mempunyai atribut prototaip, iaitu penunjuk kepada objek Tujuan objek ini adalah untuk mengandungi sifat dan kaedah yang boleh dikongsi oleh semua kejadian jenis tertentu. Kemudian, prototaip ialah objek prototaip contoh objek yang dibuat dengan memanggil pembina.

Kelebihan menggunakan prototaip ialah tika objek boleh berkongsi sifat dan kaedah yang terkandung di dalamnya. Iaitu, daripada menambah maklumat objek yang menentukan dalam pembina, anda boleh menambah maklumat ini terus ke prototaip. Masalah utama dengan menggunakan pembina ialah setiap kaedah mesti dibuat dalam setiap contoh.

Dalam JavaScript, terdapat dua jenis nilai, nilai primitif dan nilai objek. Setiap objek mempunyai prototaip harta dalaman, yang biasanya kita panggil prototaip. Nilai prototaip boleh menjadi objek atau nol. Jika nilainya ialah objek, objek itu juga mesti mempunyai prototaip sendiri. Ini membentuk rantai linear, yang kita panggil rantai prototaip.

Maksud

Fungsi boleh digunakan sebagai pembina. Di samping itu, hanya fungsi yang mempunyai atribut prototaip dan boleh diakses, tetapi contoh objek tidak mempunyai atribut ini, hanya atribut __proto__ dalaman yang tidak boleh diakses. __proto__ ialah pautan samar dalam objek kepada prototaip yang berkaitan. Mengikut piawaian, __proto__ tidak terbuka kepada orang ramai, yang bermaksud ia adalah milik persendirian, tetapi enjin Firefox mendedahkannya dan menjadikannya harta awam yang boleh kami akses dan tetapkan secara luaran.

Salin kod Kod adalah seperti berikut: var Pelayar = function(){}; Browser.prototype.run = function(){ alert("Saya Gecko, kernel firefox"); } var Bro = Pelayar baharu(); Bro.run();

Apabila kita memanggil kaedah Bro.run(), kerana tiada kaedah sedemikian dalam Bro, dia akan pergi ke __proto__nya untuk mencarinya, iaitu Browser.prototype, jadi kaedah run() akhirnya dilaksanakan. (Di sini, huruf pertama fungsi dalam huruf besar mewakili pembina untuk membezakannya daripada fungsi biasa)

Apabila pembina dipanggil untuk mencipta contoh, contoh akan mengandungi penunjuk dalaman (__proto__) yang menunjuk kepada prototaip pembina. Sambungan ini wujud antara contoh dan prototaip pembina, bukan antara contoh dan pembina.

Salin kod Kod adalah seperti berikut: fungsi Orang(nama){ This.name=name; } Person.prototype.printName=function() //Prototype object { makluman(nama.ini); }

var person1=new Person('Byron');//instantiate object console.log(person1.__proto__);//Orang console.log(person1.constructor);//Cuba sendiri dan lihat apa yang berlaku console.log(Person.prototype);//Menunjuk kepada objek prototaip Orang var person2=Orang baharu('Frank');

Person instance person1 mengandungi atribut nama dan secara automatik menjana atribut __proto__, yang menghala ke prototaip Person Anda boleh mengakses kaedah printName yang ditakrifkan dalam prototaip, yang mungkin kelihatan seperti ini:

Setiap fungsi JavaScript mempunyai atribut prototaip Atribut ini merujuk kepada objek, iaitu objek prototaip. Objek prototaip kosong apabila dimulakan Kita boleh menyesuaikan sebarang sifat dan kaedah di dalamnya, dan kaedah dan sifat ini akan diwarisi oleh objek yang dicipta oleh pembina.

Jadi, sekarang datang masalah. Apakah hubungan antara pembina, contoh dan objek prototaip?

Perbezaan antara pembina, kejadian dan objek prototaip

Instance dibuat melalui pembina. Sebaik sahaja contoh dibuat, ia mempunyai atribut pembina (menunjuk kepada pembina) dan atribut __proto__ (menunjuk ke objek prototaip),

Terdapat atribut prototaip dalam pembina, iaitu penunjuk yang menunjuk ke objek prototaipnya.

Terdapat juga penunjuk (atribut pembina) di dalam objek prototaip yang menunjuk kepada pembina: Person.prototype.constructor = Person;

Instance boleh mengakses sifat dan kaedah yang ditakrifkan pada objek prototaip.

Di sini orang1 dan orang2 ialah kejadian, prototaip ialah objek prototaip mereka.

Contoh lain:

Salin kod Kod adalah seperti berikut: Function Animal(nama) //Mengumpul pembina { This.name = name;//Tetapkan sifat objek } Animal.prototype.behavior = function() //Tambah kaedah tingkah laku pada prototaip pembina kelas asas { alert("ini ialah " this.name); }

var Anjing = Haiwan baharu("anjing");//Buat objek Anjing var Cat = Haiwan baharu("kucing");//Buat objek Kucing

Dog.behavior();//Panggil secara langsung kaedah tingkah laku melalui objek Dog Cat.behavior();//output "ini ialah kucing"

makluman(Kelakuan Anjing==Kelakuan Kucing);//output benar;

Ia boleh dilihat daripada program menjalankan hasil bahawa kaedah yang ditakrifkan pada prototaip pembina memang boleh dipanggil terus melalui objek, dan kod itu dikongsi. (Anda boleh cuba mengalih keluar atribut prototaip dalam Animal.prototype.behavior dan lihat jika ia masih berfungsi.) Di sini, atribut prototaip menghala ke objek Animal.

Instance objek tatasusunan

Lihat contoh lain objek tatasusunan. Apabila kita mencipta tatasusunan objek1, model objek sebenar tatasusunan1 dalam enjin Javascript adalah seperti berikut:

Salin kod Kod adalah seperti berikut: var array1 = [1,2,3];

Objek tatasusunan1 mempunyai nilai atribut panjang 3, tetapi kita boleh menambah elemen pada tatasusunan1 melalui kaedah berikut:

Salin kod Kod adalah seperti berikut: array1.push(4); Kaedah tolak datang daripada kaedah (Array.prototye.push()) yang ditunjuk oleh __proto__ ahli tatasusunan1. Ia adalah tepat kerana semua objek tatasusunan (dicipta melalui []) mengandungi ahli __proto__ yang menunjuk ke objek yang sama (Array.prototype) dengan kaedah tolak, terbalik dan lain-lain yang objek tatasusunan ini boleh menggunakan kaedah tolak, songsang dan lain-lain. Contoh objek fungsi

Salin kod Kod adalah seperti berikut: fungsi Base() { This.id = "base" }

Salin kod Kod adalah seperti berikut: var obj = new Base();

Apakah hasil kod ini? Model objek yang kita lihat dalam enjin Javascript ialah:

Apa sebenarnya yang dilakukan oleh pengendali baharu Ia sebenarnya sangat mudah, ia melakukan tiga perkara.

Salin kod Kod adalah seperti berikut: var obj = {}; obj.__proto__ = Pangkalan.prototaip; Base.call(obj);

Rantai Prototaip

Rantai prototaip: Apabila memanggil sifat atau kaedah daripada objek, jika objek itu sendiri tidak mempunyai sifat atau kaedah sedemikian, ia akan pergi ke objek prototaip yang berkaitan untuk mencarinya Jika prototaip itu tidak wujud, ia akan pergi ke persatuan prototaip. Cari prototaip pendahulu, dan jika tiada lagi, teruskan mencari objek yang dirujuk oleh Prototaip.Prototaip, dan seterusnya, sehingga Prototaip...Prototaip tidak ditentukan (Prototaip Objek tidak ditentukan) , dengan itu membentuk apa yang dipanggil "rantai prototaip".

Salin kod Kod adalah seperti berikut: Bentuk Fungsi(){ This.name = "shape"; This.toString = function(){ kembalikan this.name; } } Fungsi TwoShape(){ This.name = "2 bentuk"; } Segitiga Fungsi(sisi,tinggi){ This.name = "Segitiga"; This.side = sebelah; This.height = ketinggian; This.getArea = function(){ kembalikan this.side*this.height/2; } } TwoShape.prototype = new Shape(); Triangle.prototype = TwoShape();

Di sini, entiti baharu dicipta menggunakan Shape() pembina, dan kemudian digunakan untuk mengatasi prototaip objek.

Salin kod Kod adalah seperti berikut: Bentuk Fungsi(){ This.name = "shape"; This.toString = function(){ kembalikan this.name; } } Fungsi TwoShape(){ This.name = "2 bentuk"; } Segitiga Fungsi(sisi,tinggi){ This.name = "Segitiga"; This.side = sebelah; This.height = ketinggian; This.getArea = function(){ kembalikan this.side*this.height/2; } } TwoShape.prototype = new Shape(); Triangle.prototype = TwoShape();

TwoShape.prototype.constructor = TwoShape; Triangle.prototype.constructor = Segitiga;

var my = Segitiga baharu(5,10); My.getArea(); My.toString();//Triangle My.constructor;//Triangle(sisi,tinggi)

Warisan prototaip

Warisan prototaip: Pada penghujung rantai prototaip, ia ialah objek prototaip yang ditunjuk oleh atribut prototaip pembina Objek. Objek prototaip ini ialah moyang kepada semua objek. Moyang ini melaksanakan kaedah seperti toString yang sepatutnya dimiliki oleh semua objek. Prototaip pembina terbina dalam yang lain, seperti Function, Boolean, String, Date dan RegExp, semuanya diwarisi daripada nenek moyang ini, tetapi mereka masing-masing menentukan sifat dan kaedah mereka sendiri, supaya keturunan mereka menunjukkan ciri-ciri puak masing-masing. Ciri-ciri tersebut.

Dalam ECMAScript, cara untuk melaksanakan pewarisan adalah dengan bergantung pada rantai prototaip.

Salin kod Kod adalah seperti berikut: Kotak Fungsi(){ //Fungsi yang diwarisi dipanggil jenis super (kelas induk, kelas asas) This.name = "Jack"; } function Tree(){ //Fungsi yang diwarisi dipanggil subjenis (subkelas, kelas terbitan) Umur ini = 300; } //Melalui pewarisan rantaian prototaip, tetapkan nilai pada sifat prototaip subjenis //new Box() akan menyerahkan maklumat dalam struktur kotak dan prototaip kepada Tree Tree.prototype = new Box();//Tree mewarisi Kotak dan membentuk rantai melalui prototaip

var tree = new Tree(); alert(tree.name);//Pop up Jack

Masalah dengan rantai prototaip: Walaupun rantai prototaip sangat berkuasa dan boleh digunakan untuk melaksanakan pewarisan, ia juga mempunyai beberapa masalah. Ketua antara masalah ini timbul daripada prototaip nilai yang mengandungi jenis rujukan. Sifat prototaip yang mengandungi jenis rujukan dikongsi oleh semua keadaan; inilah sebabnya sifat ditakrifkan dalam pembina dan bukannya dalam objek prototaip. Apabila pewarisan dilaksanakan melalui prototaip, prototaip sebenarnya bertukar kembali menjadi contoh jenis lain. Akibatnya, sifat contoh asal menjadi sifat prototaip.

Apabila mencipta contoh subjenis, parameter tidak boleh dihantar kepada pembina superjenis. Malah, harus dikatakan bahawa tidak ada cara untuk menghantar parameter kepada pembina supertype tanpa menjejaskan semua contoh objek. Ditambah dengan masalah yang baru dibincangkan kerana kemasukan nilai jenis rujukan dalam prototaip, rantai prototaip sahaja jarang digunakan dalam amalan.

Contoh lain:

Salin kod Kod adalah seperti berikut: Orang Berfungsi(nama) { This.name = name;//Tetapkan sifat objek }; Person.prototype.company = "Microsoft";//Tetapkan sifat prototaip Person.prototype.SayHello = function() //Kaedah prototaip { alert("Hello, saya " this.name " of " this.company); };

var BillGates = Orang baru("BillGates");//Buat objek orang BillGates.SayHello();//Mewarisi kandungan prototaip dan output "Hello, saya BillGates of Microsoft"

var Jobs = new Person("Jobs"); Jobs.company = "Apple";//Tetapkan atribut syarikat anda sendiri, menutup atribut syarikat prototaip Jobs.SayHello = function() { alert("Hai," this.name " seperti " this.company); }; Jobs.SayHello();//Atribut dan kaedah ditindih oleh anda sendiri, keluarkan "Hai, Pekerjaan seperti Apple" BillGates.SayHello();//Liputan Jobs tidak menjejaskan prototaip, BillGates masih mengeluarkan

Lihat contoh rantai prototaip berikut:

Salin kod Kod adalah seperti berikut: Tahun Fungsi(){ This.value = 21; } Tahun.prototaip = { Kaedah:function(){ } };

fungsi Hi(){

}; //Tetapkan atribut prototaip Hi kepada objek contoh Tahun Hai.prototaip = Tahun baru(); Hi.prototype.year = 'Hello World';

Hi.prototype.constructor = Hai;

var test = new Hi();//Buat contoh baharu Hi

//Rantai prototaip Uji [Hi instance] Hai.prototaip [Tahun contoh] {year:'Hello World'} Tahun.prototaip kepada objek.prototaip kepada

Daripada contoh di atas, objek ujian mewarisi daripada Hi.prototype dan Year.prototype; oleh itu dia boleh mengakses kaedah kaedah prototaip Tahun, dan dia boleh mengakses nilai atribut contoh

__ptoto__ atribut Atribut __ptoto__ (tidak disokong oleh penyemak imbas IE) ialah penunjuk dari contoh ke objek prototaip Fungsinya adalah untuk menunjuk kepada pembina atribut prototaip pembina ini, anda boleh mengakses atribut dan kaedah dalam prototaip.

Instance objek dalam Javascript pada asasnya terdiri daripada satu siri atribut ini, terdapat atribut khas tidak kelihatan dalaman - __proto__ Nilai atribut ini menunjuk kepada prototaip contoh objek, objek sahaja prototaip yang unik.

Salin kod Kod adalah seperti berikut: Kotak Fungsi(){ //Huruf besar, mewakili pembina Box.prototype.name = "trigkit4";//Atribut prototaip Box.prototype.age = "21"; Box.prototype.run = function()//Kaedah prototaip kembalikan this.name this.age 'belajar'; } } var box1 = new Box(); var box2 = new Box(); alert(box1.constructor); // Atribut pembinaan, anda boleh mendapatkan pembina itu sendiri, //Fungsi ini terletak oleh penunjuk prototaip, dan kemudian dapatkan pembina itu sendiri

Perbezaan antara atribut __proto__ dan atribut prototaip Prototaip ialah atribut proprietari dalam objek fungsi.

__proto__ ialah atribut tersirat objek biasa Apabila baru digunakan, ia akan menunjuk ke objek yang ditunjuk oleh prototaip; __ptoto__ sebenarnya merupakan atribut objek entiti, manakala prototaip ialah atribut kepunyaan pembina. __ptoto__ hanya boleh digunakan dalam persekitaran pembelajaran atau penyahpepijatan.

Proses pelaksanaan mod prototaip

1. Mula-mula cari atribut atau kaedah dalam contoh pembina, dan jika ada, kembalikannya dengan segera. 2. Jika tiada contoh pembina, cari dalam objek prototaipnya Jika ada, kembalikan segera

objek prototaip

Salin kod Kod adalah seperti berikut: Kotak Fungsi(){ //Huruf besar, mewakili pembina Box.prototype.name = "trigkit4";//Atribut prototaip Box.prototype.age = "21"; Box.prototype.run = function()//Kaedah prototaip kembalikan this.name this.age 'belajar'; } }

var box1 = new Box(); alert(box1.name);//trigkit4, nilai dalam prototaip box1.name = "Lee"; alert(box1.name);//Lee, masukkan sahaja prinsip var box2 = new Box(); alert(box2.name);//trigkit4, nilai prototaip belum diubah suai oleh box1

Pembina

Salin kod

Kod adalah seperti berikut: Kotak fungsi(){ This.name = "Bill"; } Box.prototype.name = "trigkit4";//Atribut prototaip Box.prototype.age = "21"; Box.prototype.run = function()//Kaedah prototaip { kembalikan this.name this.age 'belajar'; }

var box1 = new Box(); alert(box1.name);//Bill, nilai dalam prototaip box1.name = "Lee"; alert(box1.name);//Lee, masukkan sahaja prinsip

Ringkasnya, mari kita selesaikan:

Salin kod

Kod adalah seperti berikut: Orang Berfungsi(){}; Person.prototype.name = "trigkit4"; Person.prototype.say = function(){ makluman("Hai"); }

var p1 = new Person();//prototaip ialah objek prototaip p1 dan p2 var p2 = new Person();//p2 ialah objek instantiated, yang mempunyai atribut __proto__ dalaman, menunjuk kepada prototaip Person

console.log(p1.prototype);//undefined, sifat ini ialah objek dan tidak boleh diakses console.log(Person.prototype);//Person console.log(Person.prototype.constructor);//Terdapat juga penunjuk (atribut pembina) di dalam objek prototaip yang menunjuk kepada pembina console.log(p1.__proto__);//Atribut ini ialah penunjuk kepada objek prototaip prototaip p1.say();//Instance boleh mengakses sifat dan kaedah yang ditakrifkan pada objek prototaip

Mod Kilang

Salin kod Kod adalah seperti berikut: fungsi createObject(nama,umur){ var obj = Objek baharu(); Obj.name = nama; Obj.umur = umur; Kembalikan obj; } Corak kilang menyelesaikan masalah pertindihan sejumlah besar objek yang di instantiated, tetapi terdapat masalah lain, iaitu, adalah mustahil untuk mengetahui objek mana objek tersebut. Menggunakan kaedah pembina bukan sahaja menyelesaikan masalah instantiasi berulang, tetapi juga menyelesaikan masalah pengenalan objek.

Perbezaan antara menggunakan kaedah pembina dan corak kilang ialah:

1. Kaedah pembina tidak memaparkan objek yang dicipta (Objek baharu()); 2. Tetapkan sifat dan kaedah secara langsung kepada objek ini 3. Tiada penyata pengembalian

Apabila pembina digunakan dan pembina baru () digunakan, Objek baru () dilaksanakan di latar belakang; Ini dalam badan fungsi mewakili objek yang dihasilkan oleh Object() baru

1. Untuk menentukan sama ada harta itu berada dalam contoh pembina atau dalam prototaip, anda boleh menggunakan fungsi `hasOwnProperty()` 2. Cara literal dicipta menggunakan atribut pembina tidak akan menunjuk kepada contoh, tetapi kepada Objek Cara pembina dicipta adalah sebaliknya Mengapa menunjuk ke Objek? Kerana Box.prototype = {}; cara penulisan ini sebenarnya mencipta objek baharu. Setiap kali fungsi dicipta, prototaipnya akan dibuat pada masa yang sama, dan objek ini juga secara automatik akan memperoleh atribut pembina 3. Jika ia adalah kaedah contoh, instantiasi berbeza mempunyai alamat kaedah berbeza dan unik 4. Jika ia adalah kaedah prototaip, maka alamat mereka dikongsi