Pertanyaan Bagaimana cara kerja JavaScript .prototype?


Saya tidak seperti itu dalam bahasa pemrograman dinamis, tetapi saya telah menulis bagian saya yang adil dari kode JavaScript. Saya tidak pernah benar-benar memahami program berbasis prototipe ini, apakah ada yang tahu cara kerjanya?

var obj = new Object(); // not a functional object
obj.prototype.test = function() { alert('Hello?'); }; // this is wrong!

function MyObject() {} // a first class functional object
MyObject.prototype.test = function() { alert('OK'); } // OK

Saya ingat banyak diskusi yang saya lakukan dengan orang-orang beberapa waktu lalu (saya tidak begitu yakin dengan apa yang saya lakukan) tetapi seperti yang saya pahami, tidak ada konsep kelas. Itu hanya sebuah objek, dan contoh benda-benda itu adalah klon dari aslinya, kan?

Tapi apa tujuan sebenarnya dari ini .prototype properti di JavaScript? Bagaimana ini berhubungan dengan instantiating objek?


Edit

Ini slide sangat membantu banyak untuk memahami topik ini.


1856
2018-02-21 12:31


asal


Jawaban:


Setiap objek JavaScript memiliki properti internal yang disebut [[Prototype]]. Jika Anda mencari properti melalui obj.propName atau obj['propName'] dan objek tidak memiliki properti seperti itu - yang dapat diperiksa melalui obj.hasOwnProperty('propName') - runtime mendongak properti dalam objek yang direferensikan oleh [[Prototipe]] sebagai gantinya. Jika prototipe-objek juga tidak memiliki properti seperti itu, prototipenya akan diperiksa secara bergiliran, sehingga berjalan pada objek aslinya prototipe-rantai sampai kecocokan ditemukan atau akhirnya tercapai.

Beberapa implementasi JavaScript memungkinkan akses langsung ke properti [[Prototipe]], misalnya melalui properti non-standar bernama __proto__. Secara umum, itu hanya mungkin untuk mengatur prototipe objek selama pembuatan objek: Jika Anda membuat objek baru melalui new Func(), properti [[Prototype]] objek akan diatur ke objek yang direferensikan oleh Func.prototype.

Ini memungkinkan untuk mensimulasikan kelas dalam JavaScript, meskipun sistem pewarisan JavaScript - seperti yang telah kita lihat - prototipikal, dan tidak berbasis kelas:

Bayangkan fungsi konstruktor sebagai kelas dan sifat prototipe (yaitu objek yang direferensikan oleh fungsi konstruktor prototype properti) sebagai anggota bersama, yaitu anggota yang sama untuk setiap contoh. Dalam sistem berbasis kelas, metode diimplementasikan dengan cara yang sama untuk setiap contoh, sehingga metode biasanya ditambahkan ke prototipe, sedangkan bidang objek adalah contoh-spesifik dan karena itu ditambahkan ke objek itu sendiri selama konstruksi.


925
2018-02-21 13:33



Dalam bahasa yang menerapkan pewarisan klasik seperti Java, C # atau C ++ Anda mulai dengan membuat kelas - cetak biru untuk objek Anda - dan kemudian Anda dapat membuat objek baru dari kelas tersebut atau Anda dapat memperluas kelas, menentukan kelas baru yang menambah kelas asli.

Dalam JavaScript Anda pertama kali membuat objek (tidak ada konsep kelas), maka Anda dapat menambah objek Anda sendiri atau membuat objek baru darinya. Ini tidak sulit, tetapi sedikit asing dan sulit untuk dimetabolisme bagi seseorang yang terbiasa dengan cara klasik.

Contoh:

//Define a functional object to hold persons in JavaScript
var Person = function(name) {
  this.name = name;
};

//Add dynamically to the already defined object a new getter
Person.prototype.getName = function() {
  return this.name;
};

//Create a new object of type Person
var john = new Person("John");

//Try the getter
alert(john.getName());

//If now I modify person, also John gets the updates
Person.prototype.sayMyName = function() {
  alert('Hello, my name is ' + this.getName());
};

//Call the new method on john
john.sayMyName();

Sampai sekarang saya telah memperluas objek dasar, sekarang saya membuat objek lain dan kemudian mewarisi dari Orang.

//Create a new object of type Customer by defining its constructor. It's not 
//related to Person for now.
var Customer = function(name) {
    this.name = name;
};

//Now I link the objects and to do so, we link the prototype of Customer to 
//a new instance of Person. The prototype is the base that will be used to 
//construct all new instances and also, will modify dynamically all already 
//constructed objects because in JavaScript objects retain a pointer to the 
//prototype
Customer.prototype = new Person();     

//Now I can call the methods of Person on the Customer, let's try, first 
//I need to create a Customer.
var myCustomer = new Customer('Dream Inc.');
myCustomer.sayMyName();

//If I add new methods to Person, they will be added to Customer, but if I
//add new methods to Customer they won't be added to Person. Example:
Customer.prototype.setAmountDue = function(amountDue) {
    this.amountDue = amountDue;
};
Customer.prototype.getAmountDue = function() {
    return this.amountDue;
};

//Let's try:       
myCustomer.setAmountDue(2000);
alert(myCustomer.getAmountDue());

var Person = function (name) {
    this.name = name;
};
Person.prototype.getName = function () {
    return this.name;
};
var john = new Person("John");
alert(john.getName());
Person.prototype.sayMyName = function () {
    alert('Hello, my name is ' + this.getName());
};
john.sayMyName();
var Customer = function (name) {
    this.name = name;
};
Customer.prototype = new Person();

var myCustomer = new Customer('Dream Inc.');
myCustomer.sayMyName();
Customer.prototype.setAmountDue = function (amountDue) {
    this.amountDue = amountDue;
};
Customer.prototype.getAmountDue = function () {
    return this.amountDue;
};
myCustomer.setAmountDue(2000);
alert(myCustomer.getAmountDue());

Sementara seperti yang dikatakan saya tidak bisa memanggil setAmountDue (), getAmountDue () pada Person.

//The following statement generates an error.
john.setAmountDue(1000);

1755
2018-01-24 03:42



Saya memainkan peran sebagai guru JavaScript dan konsep prototipe selalu menjadi topik kontroversial untuk dibahas ketika saya mengajar. Butuh waktu beberapa saat untuk muncul dengan metode yang bagus untuk mengklarifikasi konsep, dan sekarang dalam teks ini saya akan mencoba menjelaskan Bagaimana cara kerja JavaScript .prototype.


Ini adalah model objek berbasis prototipe yang sangat sederhana yang akan dianggap sebagai sampel selama penjelasan, tanpa komentar:

function Person(name){
    this.name = name;
}
Person.prototype.getName = function(){
    console.log(this.name);
}
var person = new Person("George");

Ada beberapa poin penting yang harus kita pertimbangkan sebelum melalui konsep prototipe.

1- Bagaimana fungsi JavaScript benar-benar berfungsi:

Untuk mengambil langkah pertama kita harus mencari tahu, bagaimana fungsi JavaScript benar-benar berfungsi, seperti kelas seperti fungsi menggunakan this kata kunci di dalamnya atau hanya sebagai fungsi biasa dengan argumennya, apa yang dilakukannya dan apa yang dikembalikan.

Katakanlah kita ingin membuat Person model objek. tetapi dalam langkah ini saya akan berusaha lakukan hal yang persis sama tanpa menggunakan prototype dan new kata kunci.

Jadi dalam langkah ini functions, objects dan this kata kunci, semua yang kami miliki.

Pertanyaan pertama adalah bagaimana this kata kunci dapat bermanfaat tanpa menggunakan new kata kunci.

Jadi untuk menjawab itu katakanlah kita memiliki objek kosong, dan dua fungsi seperti:

var person = {};
function Person(name){  this.name = name;  }

function getName(){
    console.log(this.name);
}

dan sekarang tanpa menggunakan new kata kunci bagaimana kita bisa menggunakan fungsi-fungsi ini. Jadi, JavaScript memiliki 3 cara berbeda untuk melakukannya:

Sebuah. Cara pertama hanya memanggil fungsi sebagai fungsi biasa:

Person("George");
getName();//would print the "George" in the console

dalam hal ini, ini akan menjadi objek konteks saat ini, yang biasanya adalah global window objek di browser atau GLOBAL di Node.js. Itu berarti kita akan memiliki, window.name di browser atau GLOBAL.name di Node.js, dengan "George" sebagai nilainya.

b. Kita dapat melampirkan mereka ke objek, sebagai propertinya

-Cara termudah untuk melakukan ini adalah memodifikasi kosong person objek, seperti:

person.Person = Person;
person.getName = getName;

dengan cara ini kita dapat memanggil mereka seperti:

person.Person("George");
person.getName();// -->"George"

dan sekarang person objek seperti:

Object {Person: function, getName: function, name: "George"}

-Cara lain untuk melampirkan properti ke suatu objek menggunakan prototype objek yang dapat ditemukan di objek JavaScript apa pun dengan nama __proto__, dan saya telah mencoba menjelaskannya sedikit pada bagian ringkasan. Jadi kita bisa mendapatkan hasil yang serupa dengan melakukan:

person.__proto__.Person = Person;
person.__proto__.getName = getName;

Tapi cara ini apa yang sebenarnya kita lakukan adalah memodifikasi Object.prototype, karena setiap kali kita membuat objek JavaScript menggunakan literal ({ ... }), itu dibuat berdasarkan Object.prototype, yang berarti melekat pada objek yang baru dibuat sebagai atribut bernama __proto__ , jadi jika kita mengubahnya, seperti yang telah kita lakukan pada cuplikan kode sebelumnya, semua objek JavaScript akan berubah, bukan praktik yang baik. Jadi apa yang bisa menjadi praktik yang lebih baik sekarang:

person.__proto__ = {
    Person: Person,
    getName: getName
};

dan sekarang benda-benda lain berada dalam kedamaian, tetapi tampaknya itu masih bukan praktik yang baik. Jadi kita masih memiliki satu solusi lagi, tetapi untuk menggunakan solusi ini kita harus kembali ke baris kode di mana person objek telah dibuat (var person = {};) kemudian ubah seperti:

var propertiesObject = {
    Person: Person,
    getName: getName
};
var person = Object.create(propertiesObject);

apa yang dilakukannya adalah membuat JavaScript baru Object dan pasang propertiesObject ke __proto__ atribut. Jadi untuk memastikan Anda bisa melakukannya:

console.log(person.__proto__===propertiesObject); //true

Tetapi poin yang rumit di sini adalah Anda memiliki akses ke semua properti yang didefinisikan di dalamnya __proto__ pada tingkat pertama person objek (baca bagian ringkasan untuk lebih detail).


seperti yang Anda lihat menggunakan salah satu dari dua cara ini this akan menunjuk ke person obyek.

c. JavaScript memiliki cara lain untuk menyediakan fungsi this, yang digunakan panggilan atau menerapkan untuk menjalankan fungsi.

Metode apply () memanggil fungsi dengan diberi nilai ini dan   argumen disediakan sebagai larik (atau objek mirip larik).

dan

Panggilan () metode panggilan fungsi dengan diberikan nilai ini dan   argumen disediakan secara individual.

dengan cara inilah yang menjadi favorit saya, kita dapat dengan mudah memanggil fungsi-fungsi kita seperti:

Person.call(person, "George");

atau

//apply is more useful when params count is not fixed
Person.apply(person, ["George"]);

getName.call(person);   
getName.apply(person);

3 metode ini adalah langkah awal yang penting untuk mengetahui fungsi .prototype.


2- Bagaimana caranya new kata kunci berfungsi?

ini adalah langkah kedua untuk memahami .prototype fungsi.ini adalah apa yang saya gunakan untuk mensimulasikan proses:

function Person(name){  this.name = name;  }
my_person_prototype = { getName: function(){ console.log(this.name); } };

di bagian ini saya akan mencoba untuk mengambil semua langkah yang JavaScript ambil, tanpa menggunakan new kata kunci dan prototype, ketika Anda menggunakan new kata kunci. jadi ketika kita melakukannya new Person("George"), Person berfungsi sebagai konstruktor, Ini adalah apa yang JavaScript lakukan, satu per satu:

Sebuah. pertama-tama itu membuat objek kosong, pada dasarnya hash kosong seperti:

var newObject = {};

b. langkah selanjutnya yang diperlukan JavaScript adalah melampirkan semua objek prototipe ke objek yang baru dibuat

kita punya my_person_prototype di sini mirip dengan objek prototipe.

for(var key in my_person_prototype){
    newObject[key] = my_person_prototype[key];
}

Ini bukan cara sebenarnya JavaScript menempelkan properti yang ditentukan dalam prototipe. Cara yang sebenarnya terkait dengan konsep rantai prototipe.


Sebuah. & b. Daripada dua langkah ini Anda dapat memiliki hasil yang sama persis dengan melakukan:

var newObject = Object.create(my_person_prototype);
//here you can check out the __proto__ attribute
console.log(newObject.__proto__ === my_person_prototype); //true
//and also check if you have access to your desired properties
console.log(typeof newObject.getName);//"function"

sekarang kita bisa memanggil getName berfungsi di kami my_person_prototype:

newObject.getName();

c. maka itu memberi objek itu ke konstruktor,

kita bisa melakukan ini dengan sampel kami seperti:

Person.call(newObject, "George");

atau

Person.apply(newObject, ["George"]);

maka konstruktor dapat melakukan apapun yang diinginkannya, karena ini di dalam konstruktor itu adalah objek yang baru saja dibuat.

sekarang hasil akhirnya sebelum mensimulasikan langkah-langkah lain:     Objek {name: "George"}


Ringkasan:

Pada dasarnya, saat Anda menggunakan baru kata kunci pada suatu fungsi, Anda memanggil itu dan fungsi itu berfungsi sebagai konstruktor, jadi ketika Anda mengatakan:

new FunctionName()

JavaScript secara internal membuat objek, sebuah hash kosong dan kemudian memberikan objek tersebut ke konstruktor, maka konstruktor dapat melakukan apa pun yang diinginkannya, karena ini di dalam konstruktor itu adalah objek yang baru saja dibuat dan kemudian memberi Anda objek itu tentu saja jika Anda belum menggunakan pernyataan kembali dalam fungsi Anda atau jika Anda telah menempatkan return undefined; di akhir tubuh fungsi Anda.

Jadi ketika JavaScript pergi untuk mencari properti pada objek, hal pertama yang dilakukan, apakah itu terlihat pada objek itu. Dan kemudian ada properti rahasia [[prototype]] yang biasanya kita suka __proto__ dan properti itu adalah apa yang JavaScript lihat selanjutnya. Dan ketika itu terlihat melalui __proto__, sejauh itu lagi objek JavaScript lain, ia memiliki sendiri __proto__atribut, itu naik dan naik sampai sampai ke titik di mana berikutnya __proto__ adalah null. Intinya adalah satu-satunya objek dalam JavaScript yang __proto__ atribut adalah nol Object.prototype obyek:

console.log(Object.prototype.__proto__===null);//true

dan begitulah cara kerja pewarisan di JavaScript.

The prototype chain

Dengan kata lain, ketika Anda memiliki properti prototipe pada fungsi dan Anda memanggil yang baru itu, setelah JavaScript selesai melihat objek yang baru dibuat untuk properti, itu akan pergi melihat fungsi .prototype dan juga ada kemungkinan bahwa objek ini memiliki prototipe internal sendiri. dan seterusnya.


162
2018-02-13 19:32



prototype memungkinkan Anda membuat kelas. jika Anda tidak menggunakannya prototype maka itu menjadi statis.

Ini adalah contoh singkat.

var obj = new Object();
obj.test = function() { alert('Hello?'); };

Dalam kasus di atas, Anda memiliki tes panggilan funcation statis. Fungsi ini hanya dapat diakses oleh obj.test tempat Anda dapat membayangkan obj untuk menjadi kelas.

dimana seperti pada kode di bawah ini

function obj()
{
}

obj.prototype.test = function() { alert('Hello?'); };
var obj2 = new obj();
obj2.test();

Tujuannya telah menjadi kelas yang sekarang dapat dipakai. Beberapa contoh obj bisa ada dan mereka semua memiliki test fungsi.

Di atas adalah pemahaman saya. Saya menjadikannya wiki komunitas, sehingga orang dapat mengoreksi saya jika saya salah.


66
2017-11-07 09:48



Setelah membaca utas ini, saya merasa bingung dengan Rantai Prototipe JavaScript, lalu saya menemukan bagan ini

http://iwiki.readthedocs.org/en/latest/javascript/js_core.html#inheritance *[[protytype]]* and <code>prototype</code> property of function objects

ini adalah bagan yang jelas untuk menampilkan Penandaan JavaScript oleh Rantai Prototipe

dan

http://www.javascriptbank.com/javascript/article/JavaScript_Classical_Inheritance/

yang satu ini berisi contoh dengan kode dan beberapa diagram bagus.

rantai prototipe akhirnya jatuh kembali ke Object.prototype.

rantai prototipe dapat diperpanjang secara teknis selama yang Anda inginkan, setiap kali dengan menetapkan prototipe subkelas sama dengan objek dari kelas induk.

Semoga bermanfaat juga bagi Anda untuk memahami Rantai Prototipe JavaScript.


59
2018-05-26 20:40



Tujuh Koans dari prototipe

Ketika Ciro San menurunkan Gunung Api Fox setelah meditasi yang mendalam, pikirannya jernih dan damai.

Tangannya bagaimanapun, gelisah, dan dengan sendirinya meraih sikat dan mencatat catatan berikut.


0) Dua hal yang berbeda dapat disebut "prototipe":

  • properti prototipe, seperti pada obj.prototype

  • properti internal prototipe, dilambangkan sebagai [[Prototype]]  di ES5.

    Ini dapat diambil melalui ES5 Object.getPrototypeOf().

    Firefox membuatnya dapat diakses melalui __proto__ properti sebagai ekstensi. ES6 sekarang menyebutkan beberapa persyaratan opsional untuk __proto__.


1) Konsep-konsep itu ada untuk menjawab pertanyaan:

Ketika saya melakukannya obj.property, di mana JS mencari .property?

Secara intuitif, pewarisan klasik akan memengaruhi pencarian properti.


2)

  • __proto__ digunakan untuk titik . pencarian properti seperti pada obj.property.
  • .prototype aku s tidak digunakan untuk pencarian langsung, hanya secara tidak langsung saat menentukan __proto__ pada penciptaan objek dengan new.

Urutan pencarian adalah:

  • obj properti yang ditambahkan dengan obj.p = ... atau Object.defineProperty(obj, ...)
  • properti dari obj.__proto__
  • properti dari obj.__proto__.__proto__, dan seterusnya
  • jika beberapa __proto__ aku s null, kembali undefined.

Ini yang disebut rantai prototipe.

Anda dapat menghindari . mencari dengan obj.hasOwnProperty('key') dan Object.getOwnPropertyNames(f)


3) Ada dua cara utama untuk mengatur obj.__proto__:

  • new:

    var F = function() {}
    var f = new F()
    

    kemudian new telah mengatur:

    f.__proto__ === F.prototype
    

    Ini adalah dimana .prototype digunakan.

  • Object.create:

     f = Object.create(proto)
    

    set:

    f.__proto__ === proto
    

4) Kode:

var F = function() {}
var f = new F()

Sesuai dengan diagram berikut:

(Function)       (  F  )                                      (f)
 |  ^             | | ^                                        |
 |  |             | | |                                        |
 |  |             | | +-------------------------+              |
 |  |constructor  | |                           |              |
 |  |             | +--------------+            |              |
 |  |             |                |            |              |
 |  |             |                |            |              |
 |[[Prototype]]   |[[Prototype]]   |prototype   |constructor   |[[Prototype]]
 |  |             |                |            |              |
 |  |             |                |            |              |
 |  |             |                | +----------+              |
 |  |             |                | |                         |
 |  |             |                | | +-----------------------+
 |  |             |                | | |
 v  |             v                v | v
(Function.prototype)              (F.prototype)
 |                                 |
 |                                 |
 |[[Prototype]]                    |[[Prototype]]
 |                                 |
 |                                 |
 | +-------------------------------+
 | |
 v v
(Object.prototype)
 | | ^
 | | |
 | | +---------------------------+
 | |                             |
 | +--------------+              |
 |                |              |
 |                |              |
 |[[Prototype]]   |constructor   |prototype
 |                |              |
 |                |              |
 |                | -------------+
 |                | |
 v                v |
(null)           (Object)

Diagram ini menunjukkan banyak node objek yang telah ditentukan sebelumnya: null, Object, Object.prototype, Function dan Function.prototype. 2 baris kode kami hanya dibuat f, F dan F.prototype.


5)  .constructor biasanya berasal F.prototype melalui . Lihatlah:

f.constructor === F
!f.hasOwnProperty('constructor')
Object.getPrototypeOf(f) === F.prototype
F.prototype.hasOwnProperty('constructor')
F.prototype.constructor === f.constructor

Ketika kami menulis f.constructor, JavaScript melakukan . pencarian sebagai:

  • f tidak memiliki .constructor
  • f.__proto__ === F.prototype punya .constructor === F, ambillah

Hasil f.constructor == F secara intuitif benar, karena F digunakan untuk membangun f, mis. mengatur bidang, seperti dalam bahasa OOP klasik.


6) Sintaks pewarisan klasik dapat dicapai dengan memanipulasi rantai prototipe.

ES6 menambahkan class dan extends kata kunci, yang hanya sintaks gula untuk kemungkinan manipulasi manipulasi sebelumnya.

class C {
    constructor(i) {
        this.i = i
    }
    inc() {
        return this.i + 1
    }
}

class D extends C {
    constructor(i) {
        super(i)
    }
    inc2() {
        return this.i + 2
    }
}
// Inheritance syntax works as expected.
(new C(1)).inc() === 2
(new D(1)).inc() === 2
(new D(1)).inc2() === 3
// "Classes" are just function objects.
C.constructor === Function
C.__proto__ === Function.prototype
D.constructor === Function
// D is a function "indirectly" through the chain.
D.__proto__ === C
D.__proto__.__proto__ === Function.prototype
// "extends" sets up the prototype chain so that base class
// lookups will work as expected
var d = new D(1)
d.__proto__ === D.prototype
D.prototype.__proto__ === C.prototype
// This is what `d.inc` actually does.
d.__proto__.__proto__.inc === C.prototype.inc
// Class variables
// No ES6 syntax sugar apparently:
// http://stackoverflow.com/questions/22528967/es6-class-variable-alternatives
C.c = 1
C.c === 1
// Because `D.__proto__ === C`.
D.c === 1
// Nothing makes this work.
d.c === undefined

Diagram yang disederhanakan tanpa semua objek yang telah ditentukan:

      __proto__
(C)<---------------(D)         (d)
| |                |           |
| |                |           |
| |prototype       |prototype  |__proto__
| |                |           |
| |                |           |
| |                | +---------+
| |                | |
| |                | |
| |                v v
|__proto__        (D.prototype)
| |                |
| |                |
| |                |__proto__
| |                |
| |                |
| | +--------------+
| | |
| | |
| v v
| (C.prototype)--->(inc)
|
v
Function.prototype

57
2018-06-18 19:48



Setiap objek memiliki properti internal, [[Prototype]], menautkannya ke objek lain:

object [[Prototype]] -> anotherObject

Dalam javascript tradisional, objek yang ditautkan adalah prototype properti dari suatu fungsi:

object [[Prototype]] -> aFunction.prototype

Beberapa lingkungan mengekspos [[Prototype]] sebagai __proto__:

anObject.__proto__ === anotherObject

Anda membuat tautan [[Prototipe]] saat membuat objek.

// (1) Object.create:
var object = Object.create(anotherObject)
// object.__proto__ = anotherObject

// (2) ES6 object initializer:
var object = { __proto__: anotherObject };
// object.__proto__ = anotherObject

// (3) Traditional JavaScript:
var object = new aFunction;
// object.__proto__ = aFunction.prototype

Jadi, pernyataan ini setara:

var object = Object.create(Object.prototype);
var object = { __proto__: Object.prototype }; // ES6 only
var object = new Object;

SEBUAH new pernyataan tidak menunjukkan target tautan (Object.prototype) diri; sebagai gantinya target tersirat oleh konstruktor (Object).

Ingat:

  • Setiap objek memiliki tautan, [[Prototype]], terkadang ditampilkan sebagai __proto__.
  • Setiap fungsi memiliki prototype milik.
  • Objek dibuat dengan new terkait dengan prototype milik konstruktor mereka.
  • Jika suatu fungsi tidak pernah digunakan sebagai konstruktor, itu prototype properti tidak akan digunakan.
  • Jika Anda tidak membutuhkan konstruktor, gunakan Object.create dari pada new.

33
2018-02-21 12:41



Javascript tidak memiliki warisan dalam arti biasa, tetapi memiliki rantai prototipe.

rantai prototipe

Jika anggota suatu objek tidak dapat ditemukan pada objek yang dicari dalam rantai prototipe. Rantai terdiri dari benda-benda lain. Prototipe dari instance yang diberikan dapat diakses dengan __proto__ variabel. Setiap objek memiliki satu, karena tidak ada perbedaan antara kelas dan instance dalam javascript.

Keuntungan menambahkan fungsi / variabel ke prototipe adalah bahwa itu harus dalam memori hanya sekali, bukan untuk setiap contoh.

Ini juga berguna untuk warisan, karena rantai prototipe dapat terdiri dari banyak objek lain.


23
2017-11-04 14:08