Penjelasan terperinci tentang penggunaan prototaip dalam javascript

JavaScript ialah bahasa pengaturcaraan yang sangat popular. Kuasa JavaScript terletak pada prototaipnya.

Prototaip ialah konsep dalam Model Objek JavaScript. Ia membolehkan kita membina objek dengan mewarisi sifat dan kaedah daripada objek lain. Beginilah cara warisan berfungsi dalam JavaScript.

Artikel ini akan memperkenalkan penggunaan prototaip dalam JavaScript secara terperinci.

1. Apakah itu prototaip

Setiap objek dalam JavaScript diperoleh daripada prototaipnya. Prototaip objek ialah objek lain, yang mempunyai rantai prototaip. Setiap objek pada rantai prototaip ini diperolehi langkah demi langkah daripada objek asal sehingga objek nenek moyang - prototaip Objek.

Contohnya:

//创建一个对象
var obj = {};

Kod di atas mencipta objek kosong, dan rantai prototaipnya adalah seperti ini:

obj -> Object.prototype -> 🎜>

Obj objek diperoleh daripada objek Object.prototype. Object.prototype ialah nenek moyang semua objek dalam JavaScript.

2. Prototaip dan Pembina

Terdapat dua konsep yang berkait rapat dengan prototaip dalam JavaScript: pembina dan contoh.

Pembina

Pembina ialah fungsi yang digunakan untuk mencipta objek daripada jenis tertentu. Pembina boleh menggunakan prototaip untuk menentukan sifat dan fungsi. Contohnya:

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

Kod di atas mentakrifkan Orang pembina, yang mempunyai dua parameter: nama dan umur. Dalam pembina, kami menggunakan kata kunci ini untuk menetapkan sifat untuk contoh objek. Sekarang mari kita cipta objek Orang:

var person1 = new Person('Tom', 20);

Objek person1 ini dicipta oleh pembina Orang dan mempunyai dua atribut: nama dan umur.

Instance

Instance ialah objek yang dicipta oleh pembina. Kejadian boleh mengakses sifat dan kaedah yang ditakrifkan dalam prototaip pembina. Contohnya:

//定义Person的原型方法
Person.prototype.sayHello = function() {
  console.log('Hello, my name is ' + this.name);
}
//调用对象方法
person1.sayHello();

mentakrifkan kaedah sayHello pada prototaip Person, yang boleh diakses oleh semua kejadian Person. Oleh itu, apabila kita memanggil kaedah person1.sayHello(), ia mengeluarkan: Hello, nama saya Tom.

3. Warisan prototaip

Warisan prototaip ialah kaedah pewarisan utama dalam JavaScript. Ia dilaksanakan melalui rantaian prototaip.

Warisan bermaksud satu objek boleh mengakses sifat dan kaedah objek lain. Contohnya, objek anak boleh mewarisi sifat dan kaedah objek induknya. Dalam JavaScript, objek boleh memiliki sifat dan kaedah objek lain melalui pewarisan.

Kita boleh menambah sifat dan kaedah pada objek prototaip, dan sifat serta kaedah ini akan diwarisi oleh contoh yang dicipta oleh pembina. Contohnya:

//定义一个Animal对象
function Animal(name) {
  this.name = name;
}
//在Animal的原型上定义一个属性
Animal.prototype.color = 'red';
//创建一个实例
var cat = new Animal('Tom');

Dalam kod di atas, kami mentakrifkan objek Haiwan, yang mempunyai atribut nama dan warna atribut prototaip. Kemudian kami mencipta contoh kucing, yang mewarisi warna atribut prototaip Haiwan.

Anda boleh menggunakan kaedah hasOwnProperty() untuk menentukan sama ada sesuatu kejadian mengandungi sifat khususnya sendiri. Contohnya:

console.log(cat.hasOwnProperty('name')); // true
console.log(cat.hasOwnProperty('color')); // false

4. Kaedah dan atribut statik prototaip

Kaedah dan atribut statik kepunyaan pembina itu sendiri, ia bukan milik contoh. Sebelum ES5, JavaScript tidak mempunyai mekanisme rasmi untuk menyediakan kaedah dan sifat statik, jadi pembangun biasanya menambahkannya secara manual kepada pembina.

Contohnya:

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

Dalam kod di atas, kami mentakrifkan kaedah statik create(). Kaedah ini boleh dipanggil dari pembina itu sendiri, bukan dari contoh.

Dalam ES6, anda boleh menggunakan sintaks kelas untuk menentukan kaedah dan sifat statik. Contohnya:

class Person {
  constructor(name, age) {
    this.name = name;
    this.age = age;
  }
  static create(name, age) {
    return new Person(name, age);
  }
}

Dalam kod di atas, kami menggunakan sintaks kelas untuk mentakrifkan kaedah statik create().

5. Kelemahan pewarisan prototaip

Pewarisan prototaip sangat berkuasa dan fleksibel kerana kita boleh mewarisi sifat dan kaedah mana-mana objek. Tetapi ia juga mempunyai beberapa kelemahan.

Semua kejadian berkongsi prototaip

Memandangkan prototaip dikongsi, semua kejadian yang dibuat daripada pembina yang sama akan berkongsi prototaip yang sama. Jika satu kejadian mengubah suai sifat atau kaedah pada prototaip, semua kejadian akan terjejas.

Tidak boleh mengakses pembolehubah persendirian tika itu

Kaedah prototaip tidak boleh mengakses pembolehubah persendirian tika itu (iaitu pembolehubah yang ditakrifkan di dalam pembina). Kerana pembolehubah persendirian ini hanya boleh digunakan di dalam pembina.

6. Ringkasan

Prototaip ialah konsep yang sangat berkuasa dalam JavaScript, yang boleh digunakan untuk melaksanakan pewarisan, kod kongsi, dsb. Dalam pembangunan sebenar, jika digunakan dengan betul, warisan prototaip boleh membantu kami meningkatkan kecekapan pembangunan dan mengurangkan jumlah kod. Walau bagaimanapun, kita juga perlu jelas tentang kelemahan warisan prototaip, terutamanya isu seperti perkongsian prototaip dan ketidakupayaan untuk mengakses pembolehubah persendirian.

Atas ialah kandungan terperinci Penjelasan terperinci tentang penggunaan prototaip dalam javascript. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!