Apakah perbezaan antara menulis definisi prototaip (lokasi) di dalam atau di luar pembina?

Cara penulisan kedua akan melaksanakan operasi pada prototaip setiap kali kejadian dibuat! Intinya ialah operasi ini tidak bermakna, dan kaedah ini adalah sama untuk setiap kejadian.
Dalam kaedah pertama, apabila prototaip ditulis di luar pembina, masalah definisi berulang atau peruntukan memori boleh diselesaikan secara formal dan melalui peruntukan memori.
Sepadan dengan cara penulisan pertama dalam ingatan Tidak kira berapa banyak kejadian yang anda buat, setiap kejadian hanya menduduki nama, umur, pekerjaan dan pelajaran. Hanya terdapat satu salinan getName dalam ingatan, dikongsi oleh semua kejadian; cara kedua penulisan, Setiap contoh yang baru dibuat akan memperuntukkan ruang tambahan (tindanan) untuk melaksanakan definisi prototaip.

Apakah perbezaan antara cara prototaip diberikan nilai dalam kaedah pertama dan kaedah kedua?

Perbezaan adalah sangat besar Setelah kelas fungsi ditakrifkan, sifat pembina lalainya adalah dirinya sendiri, dan contohnya akan mengembalikan nilai ini apabila mengakses sifat pembina.

function Person() {};
console.log(Person.prototype.constructor);  // Person

var p = new Person();
console.log(p.constructor);   // Person    表示p的构造函数是Person类

Mengapa anda perlu mentakrifkan pembina dalam kaedah 1 Kerana ia menetapkan semula prototaip Jika anda tidak mentakrifkan pembina (Person.prototype = {getName: function() {}}) , maka di atas Dalam contoh, nilai pulangan p.constructor akan menjadi Object, iaitu, pembina p ialah Object, yang jelas tidak konsisten dengan fakta . Person.prototype = {getName: function() {}}），那么上例中p.constructor返回值将是 Object, 即p的构造函数是Object，显然与事实不符。

方法1更明智的做法是不要重新给prototype赋值，只为prototype添加我们需要的属性getName, 改为 Person.prototype.getName = function() {return this.name;}

首先，你应该搞清楚js中的原型，在js中，原型指的是构造函数的prototype属性的值，由构造函数创建出来的实例会自动链接到原型对象也就是其构造函数的prototype属性上。
    function Person(name,age,job){
    this.name = name;
    this.age = age;
    this.job = job;
    this.lessons = ['Math','Physics'];
}
Person.prototype = {
    constructor: Person,
    getName: function(){
        return this.name;
    }
}
这个写法中，Person为构造函数,可以创建出一个实例对象，
var p=new Person();
然后p可以继承原型中的属性，在原型中constructor指向的是当前的构造函数
你的写法可以理解为在构造函数中给原型的getname属性赋值了一个函数

Cara penulisan dahulu menulis semula prototaip, dan cara penulisan anda hanya menambah kaedah pada prototaip. Kedua-duanya adalah cara yang berbeza

Mengikut cara anda menulisnya, ruang storan akan diperuntukkan semula kepada contoh semasa setiap proses instantiasi Salah satu maksud corak prototaip ialah semua kejadian boleh berkongsi atribut dan kaedah pada prototaip, walaupun berbuat demikian sahaja mempunyai kelemahan. . Perkara kedua ialah saya masih lebih suka menulis objek objek prototaip secara literal Saya secara peribadi berpendapat bahawa satu lebih intuitif, dan yang kedua adalah kondusif untuk penyelenggaraan. Seperti berikut:

    Person.prototype = {
        constructor: Person,
        getName: function(){
            return this.name;
        }
    }

Pastikan anda menulis atribut pembina, jika tidak, ralat penunjuk akan berlaku Pada masa ini, objek prototaip ditulis semula Jika atribut ini tidak dinyatakan, rantai prototaip tidak akan dapat memainkan peranannya.

Terdapat banyak perbezaan antara warisan prototaip dan pembina.

Rantai prototaip tidak sempurna, ia mengandungi dua masalah berikut.

Soalan 1: Apabila rantai prototaip mengandungi prototaip nilai jenis rujukan, nilai jenis rujukan akan dikongsi oleh semua kejadian;

Masalah 2: Apabila mencipta subjenis (seperti mencipta instance Son), parameter tidak boleh dihantar kepada pembina supertype (seperti Father).

Memandangkan perkara ini, pada praktiknya rantai prototaip jarang digunakan secara bersendirian.

Untuk tujuan ini, akan ada beberapa percubaan di bawah untuk mengimbangi kekurangan rantaian prototaip.

Meminjam pembina

Untuk menyelesaikan dua masalah di atas dalam rantai prototaip, kami mula menggunakan teknologi yang dipanggil meminjam pembina (pembina mencuri) (juga dipanggil warisan klasik).

Idea asas: panggil pembina supertype di dalam pembina subjenis.

function Father(){
    this.colors = ["red","blue","green"];
}
function Son(){
    Father.call(this);//继承了Father,且向父类型传递参数
}
var instance1 = new Son();
instance1.colors.push("black");
console.log(instance1.colors);//"red,blue,green,black"

var instance2 = new Son();
console.log(instance2.colors);//"red,blue,green" 可见引用类型值是独立的

Jelas sekali, meminjam pembina menyelesaikan dua masalah utama rantaian prototaip dalam satu kejadian:

Pertama, ia memastikan kebebasan nilai jenis rujukan dalam rantaian prototaip dan tidak lagi dikongsi oleh semua keadaan;

Kedua, semasa membuat subjenis, anda juga boleh menghantar parameter kepada jenis induk.

Berikutan ini, jika anda hanya meminjam pembina, anda tidak akan dapat mengelakkan masalah corak pembina - kaedah semuanya ditakrifkan dalam pembina, jadi penggunaan semula fungsi tidak tersedia dan Kaedah jenis super ditakrifkan dalam (seperti Bapa) juga tidak dapat dilihat oleh subjenis. Memandangkan ini, teknik peminjaman pembina jarang digunakan.
Untuk maklumat lanjut, sila rujuk rantai prototaip dan warisan JS anda menyukainya, sila berikan ibu jari dan sokongnya, terima kasih!