Nota kajian warisan JavaScript [mesti dibaca untuk pemula]_kemahiran javascript

Sebagai bahasa berorientasikan objek (JS berdasarkan objek), JavaScript adalah penting untuk merealisasikan pewarisan Walau bagaimanapun, kerana ia tidak mempunyai konsep kelas, ia tidak akan merealisasikan pewarisan melalui kelas seperti pengaturcaraan berorientasikan objek sebenar. bahasa. Tetapi pewarisan boleh dicapai dengan cara lain. Terdapat banyak cara untuk melaksanakan pewarisan, berikut adalah beberapa daripadanya.

1. Prototaip rantaian warisan

function Person() {  //被继承的函数叫做超类型（父类，基类）
      this.name='mumu';
      this.age='18';
    }
    
    Person.prototype.name='susu';//当属性名相同时需就近原则，先在实例里面查找，没找到再到原型里找
       
    function Worker(){ //继承的函数叫做子类型（子类，派生类）
      this.job='student';
    }

    Worker.prototype=new Person();//通过原型链继承，超类型实例化后的对象实例，赋值给子类的原型属性
    var p2=new Worker(); 

    console.log(p2.name);
    console.log(p2 instanceof Object);//ture 所有的构造函数都继承自Object

Kunci untuk merealisasikan warisan di atas ialah: Worker.prototype=new Person(); Tukar prototaip Pekerja menjadi contoh Orang dan warisi melalui rantai prototaip.

Nota: Apabila menggunakan rantai prototaip untuk melaksanakan pewarisan, anda tidak boleh menggunakan literal objek untuk mencipta kaedah prototaip, kerana ini akan memutuskan hubungan dan menulis semula rantai prototaip.

Masalah pewarisan rantai prototaip:

1. Terdapat masalah perkongsian rujukan Mereka masih berkongsi ruang yang sama, dan subkelas akan mempengaruhi kelas induk

function Person() {  
      this.bodys=['eye','foot'];
    }
    
    function Worker(){ 
    }

    Worker.prototype=new Person();
    var p1=new Worker();
    p1.bodys.push('hand');
    var p2=new Worker(); 
    console.log(p1.bodys);
    console.log(p2.bodys);

2 Apabila mencipta contoh subjenis, parameter tidak boleh dihantar dalam pembina superjenis.

Jadi bagaimana untuk menyelesaikan dua masalah rantai prototaip? Lepas tu terus tengok kaedah pewarisan di bawah~

2. Meminjam warisan pembina (juga dipanggil penyamaran objek, objek palsu atau warisan klasik)

function Person(name,age){
    this.name=name;
    this.age=age;
    this.bodys=['eye','foot'];
  }

  Person.prototype.showName=function(){
    console.log(this.name);
  }

  function Worker(name,age,job){
    Person.call(this,name,age);
    this.job=job;//子类添加属性
  }

  var p1=new Worker('mumu','18','学生'); 
  p1.bodys.push('hand') ;
  var p2=new Worker();

  console.log(p1.name);
  console.log(p2.bodys);
  console.log(p1.showName());

Analisis ringkas prinsip di atas menggunakan pembina yang dipinjam: Person.call(this,name,age); masa pelaksanaan fungsi Ini, di sini ini-> objek Pekerja daripada kaedah penyamaran Pembina baharu: serahkan Pekerja kepada Orang di atas.

Apabila jenis rujukan diletakkan dalam pembina, ia tidak akan dikongsi, jadi p2 tidak terjejas.

Kaedah pewarisan pembina digunakan di sini untuk menyelesaikan masalah bahawa rantaian prototaip tidak boleh melepasi parameter dan jenis rujukan dikongsi.

Petua: Kaedah panggilan() dan apply() boleh menukar skop pelaksanaan fungsi Secara ringkasnya, mereka menukar kandungan yang ditunjukkan oleh ini dalam fungsi.

Kedua-dua call() dan apply() menerima dua parameter: yang pertama ialah skop di mana fungsi dijalankan dan satu lagi ialah parameter yang diluluskan.

Perbezaan antara panggilan dan pakai ialah perbezaan dalam parameter.
Parameter dalam panggilan mesti dihitung satu persatu.
Parameter yang digunakan mestilah objek tatasusunan atau argumen

Maka persoalannya ialah: mengapa keputusan p1.showName() salah? ----Oleh kerana kaedah pewarisan pembina yang dipinjam hanya boleh mewarisi sifat dan kaedah dalam pembina. Masalah dengan meminjam pembina juga ditemui di sini.

Nota: Memandangkan semua kaedah diletakkan dalam pembina, setiap kali kita membuat instantiat, ruang memori akan diperuntukkan kepadanya, menyebabkan pembaziran sumber Oleh itu, secara amnya kita meletakkan kaedah dalam prototaip dan atribut dalam pembina .

Masalah pewarisan pembina pinjaman:

Oleh kerana pembina yang dipinjam hanya boleh mewarisi sifat dan kaedah dalam pembina, kaedah yang ditakrifkan dalam prototaip jenis super tidak dapat dilihat oleh subkelas, jadi ia adalah bersamaan dengan tidak mempunyai prototaip. Akibatnya, semua kaedah hanya boleh ditakrifkan dalam pembina, jadi tiada fungsi guna semula.

Jadi bagaimana untuk menyelesaikan masalah yang disebabkan oleh meminjam pembina? Kemudian kita perlu melihat kaedah pewarisan berikut

3. Warisan gabungan (warisan pseudo-klasik)

function Person(name,age){
    this.name=name;
    this.age=age;
  }

  Person.prototype.showName=function(){
    console.log(this.name);
  }

  function Worker(name,age,job){
    Person.call(this,name,age);//借用构造函数
    this.job=job;
  }
  
  Worker.prototype=new Person();//原型链继承
  var p1=new Worker('mumu','18','学生'); 

  console.log(p1.age);
  p1.showName();

Warisan gabungan: gabungkan rantai prototaip dengan pembina yang dipinjam.

Idea: merealisasikan pewarisan atribut dan kaedah pada prototaip dengan menggunakan rantai prototaip, dan gunakan pembina untuk merealisasikan pewarisan atribut contoh

Contoh Person.call (ini, nama, umur); meminjam pembina untuk mewarisi sifat

Worker.prototype=new Person(); Rantaian prototaip mewarisi kaedah, mengelakkan kelemahan kedua-duanya, menyepadukan kelebihannya dan menjadi corak warisan yang paling biasa digunakan.

Masalah dengan gabungan warisan:

Pembina superjenis dipanggil dua kali, sekali apabila mencipta prototaip subjenis dan sekali di dalam pembina subjenis.

Untuk menyelesaikan masalah ini, kita perlu menggunakan warisan gabungan parasit.

4. Warisan prototaip

function object(proto) {
    function F() {}
    F.prototype = proto;
    return new F();
  }

  var person = {
    name: 'mumu',
    friends: ['xiaxia', 'susu']
  };

  var anotherPerson = object(person);
  anotherPerson.friends.push('wen');
  var yetAnotherPerson = object(person);
  anotherPerson.friends.push('tian');
  console.log(person.friends);//["xiaxia", "susu", "wen", "tian"]
console.log(anotherPerson.__proto__)//Object {name: "mumu", friends: Array[4]}

Analisis ringkas: objek fungsi (proto) ialah fungsi transit sementara Parameter proto di dalam mewakili objek yang akan dihantar. Pembina F() ialah objek yang baru dibuat buat sementara yang digunakan untuk menyimpan objek yang diluluskan. prototaip = proto; berikan contoh objek kepada objek prototaip pembina F, dan akhirnya mengembalikan contoh objek objek yang diluluskan. Warisan prototaip masih berkongsi sifat jenis rujukan.

5. Warisan Parasit

//临时中转函数  
function object(proto) {
    function F() {}
    F.prototype = proto;
    return new F();
  }

  //寄生函数
  function create(proto){
    var f=object(proto);
    f.love=function(){
      return this.name;
    }
    return f;
  }

  var person = {
    name: 'mumu',
    friends: ['xiaxia', 'susu']
  };

  var anotherPerson = create(person);
  console.log(anotherPerson.love());寄生组合式继承

6. Warisan gabungan Parasit

function object(proto) {
    function F() {}
    F.prototype = proto;
    return new F();
  }

  //寄生函数
  function create(Person,Worker){
    var f=object(Person.prototype);//创建对象
    f.constructor=Worker;//调整原型构造指针，增强对象
    Worker.prototype=f;//指定对象
  }
  
  function Person(name,age){
    this.name=name;
    this.age=age;
  }
  Person.prototype.showName=function(){
    console.log(this.name);
  }
  function Worker(name,age,job){
    Person.call(this,name,age);
    this.job=job;
  }
  
  create(Person,Worker);//寄生组合式继承
  var p1=new Person('mumu','18','学生');
p1.showName();

Cette méthode est également la plus parfaite et la plus idéale parmi les méthodes d'héritage actuelles.

Les notes d'apprentissage sur l'héritage JavaScript ci-dessus [à lire absolument pour les débutants] sont tout le contenu partagé par l'éditeur. J'espère qu'elles pourront vous donner une référence et j'espère que vous soutiendrez Script Home.