Contoh objek contoh dan objek prototaip dalam pengetahuan JavaScript_Basic

Pertama sekali, isytiharkan: Setiap objek dalam JavaScript mempunyai atribut pembina dan atribut prototaip. pembina menunjuk ke pembina objek, dan prototaip menunjuk ke objek prototaip contoh objek yang dibuat menggunakan pembina.

function Person(){ 
  
 } 
var person = new Person(); 
 
Person.prototype = { 
 constructor : Person, 
 name : 'zxs', 
 age : 24, 
 sayName : function(){alert(this.name)} 
 } 
  
person.sayName(); 

Ralat akan dilaporkan dalam kod ini, sayName() tidak ditakrifkan. Menurut Pengaturcaraan Lanjutan JavaScript Edisi Kedua, ia adalah kerana prototaip yang ditindih memotong sambungan antara pembina dan prototaip asal. Tetapi mari kita laraskan susunan pernyataan di atas. Seperti berikut:

function Person(){ 
 } 
//var person = new Person(); 
Person.prototype = { 
 constructor : Person, 
 name : 'zxs', 
 age : 24, 
 sayName : function(){alert(this.name)} 
} 
/*===========================================================*/ 
var person = new Person(); 
/*===========================================================*/ 
 person.sayName(); // zxs 
alert(person.constructor) //function Object() { [native code]} or function Person() {} 取决与蓝色的语句是否有效 

Beri perhatian kepada pernyataan antara tanda sama dalam dua keping kod di atas. Jika anda menulis kod dalam susunan perenggan kedua, "zxs" akan dikeluarkan Keputusan ini menunjukkan bahawa ralat yang dilaporkan dalam kes pertama tidak bermakna ia disebabkan oleh memutuskan sambungan antara pembina dan idea asal. .

Person.prototype = ｛｝ 

Ia pada asalnya adalah satu cara untuk mentakrifkan objek, dan sifat pembina setiap objek dalam JavaScript menghala ke pembina Objek secara lalai. Ini tidak sukar untuk menunjukkan bahawa menulis semula objek prototaip memang memutuskan sambungan antara pembina dan prototaip asal, tetapi ini tidak bermakna orang itu tidak boleh mengakses fungsi sayName() selepas sambungan ini terputus.

Sekarang terdapat andaian ini: objek prototaip yang ditunjukkan oleh atribut prototaip fungsi itu tidak betul-betul sama dengan objek prototaip yang kami paparkan untuk mencipta yang baharu. Apabila kita memanggil fungsi, objek prototaip akan dibuat Pada masa ini, kita akan menyemak sama ada objek prototaipnya wujud dalam persekitaran semasa Jika ia tidak wujud dalam program, buat satu. kita akan mencari sifat dan kaedah mereka Akhirnya, Objek prototaip dikembalikan berdasarkan hasil carian Sifat dan kaedah dalam objek ini sentiasa menggunakan sifat dan kaedah dalam prototaip lalai, iaitu sifat dan kaedah yang ditakrifkan dalam. pembina. Apabila kaedah atau sifat yang dipanggil tidak wujud dalam prototaip lalai, sifat dan kaedah yang ditakrifkan dalam Person.prototype = {} digunakan.

Javascript ialah bahasa yang ditafsirkan dan penyataan dilaksanakan secara berurutan Dalam sekeping kod pertama, apabila kita menggunakan kata kunci baharu untuk mencipta objek baharu, Person.prototype = {} tidak dilaksanakan, yang bermaksud Kaedah dan. sifat yang ditakrifkan di dalamnya tidak boleh ditemui dalam persekitaran pelaksanaan semasa, dan kaedah itu tidak wujud dalam pembina, jadi ralat berlaku. Sama seperti pembolehubah, ia tidak boleh digunakan apabila program tidak dilaksanakan apabila memberikan nilai kepadanya. Dalam perenggan kedua, kaedah yang dipanggil sudah wujud dalam persekitaran, dan objek prototaip pembina telah dibuat, jadi hasilnya boleh diperolehi.

Lihat program berikut:

////////////////////////////////////////////////////////////////////////// 
 
function Person(){} 
 
/*===========================================================*/ 
 
 var person = new Person(); 
Person.prototype.name = 'song'; 
 
/*===========================================================*/ 
 
//Person.prototype.sayName = function(){alert(this.name)}; 
Person.prototype = { 
constructor : Person, 
name : 'zxs', 
age : 24, 
sayName : function(){alert(this.name)} 
} 
person.sayName(); // error 
 
////////////////////////////////////////////////////////////////////////// 
 
function Person(){  } 
/*var person = new Person();*/ 
Person.prototype.name = 'song';  
/*Person.prototype.sayName = function(){alert(this.name)};*/ 
Person.prototype = {   
constructor : Person, 
  name : 'zxs', 
  age : 24, 
  sayName : function(){alert(this.name)} 
} 
 
/*===========================================================*/ 
var person = new Person(); 
 
/*===========================================================*/ 
person.sayName(); // zxs 

Ia boleh dilihat dari sini bahawa menggunakan Person.prototype.name = '', objek boleh diakses tidak kira di mana ia dicipta Jika terdapat objek literal dan objek prototaip yang ditakrifkan oleh kaedah ini, yang kemudiannya objek yang ditentukan akan digunakan sebagai nilai akhir. Dan selepas menggunakan definisi literal objek untuk objek prototaip, definisi mesti muncul sebelum pernyataan yang mencipta objek sebelum ia boleh diakses.

Instance tidak boleh mengakses sifat dan kaedah dalam objek prototaip, apatah lagi kerana mengatasi objek prototaip memutuskan sambungan antara pembina dan prototaip asal.

function Person(){  
    
  }  
var person = new Person();  
  
Person.prototype = {  
  //constructor : Person,  
  name : 'zxs',  
  age : 24,  
  sayName : function(){alert(this.name)}  
  }  
    
person.sayName();  

Prototaip pembina dalam kod di atas kosong apabila membuat instantiated objek, dan ia tidak mempunyai sebarang sifat selain daripada sifat lalai. Mengatasi prototaip pembina memang memutuskan sambungan antara pembina dan prototaip asal.

Selepas menggunakan operator baharu, sifat dan kaedah dalam objek prototaip pembina telah ditambahkan pada objek orang. Oleh kerana kaedah di atas tidak dinamik dalam menambah sifat dan kaedah baharu pada prototaip fungsi, orang tidak boleh mengakses sifat dan kaedah yang baru ditambah.

Selepas menulis semula objek prototaip, ia adalah seperti kod berikut:

var o = { 
  name : 'zxs' 
  } 
   
var obj = o; 
o = {} 
console.log(o.name);  

Nilai output pada masa ini tidak ditentukan, kerana objek ialah jenis rujukan, "=" ialah pengendali tugasan dan susunan operasi adalah dari kanan ke kiri. o={} bermakna penunjuk o telah berubah dan merupakan objek kosong.
Perbezaan antara Person.prototype.mothed = function() {} dan Person.prototype={mothed:function(){}} adalah sama seperti arr = [] dan arr.push(). yang terakhir mengubah dirinya sendiri.