Itu melakukan 5 hal:
- Itu menciptakan objek baru. Jenis objek ini hanyalah objek .
- Ini menetapkan objek baru ini internal, tidak dapat diakses, [[prototipe]] (yaitu __proto__ ) properti menjadi fungsi konstruktor eksternal, dapat diakses, prototipe objek (setiap fungsi objek secara otomatis memiliki prototipe properti).
- Itu membuat
thistitik variabel ke objek yang baru dibuat.
- Itu mengeksekusi fungsi konstruktor, menggunakan objek yang baru dibuat setiap kali
thisdisebutkan.
- Ini mengembalikan objek yang baru dibuat, kecuali fungsi konstruktor mengembalikan
nullreferensi non- objek. Dalam hal ini, referensi objek itu dikembalikan sebagai gantinya.
Catatan: fungsi konstruktor merujuk ke fungsi setelah newkata kunci, seperti pada
new ConstructorFunction(arg1, arg2)
Setelah ini selesai, jika properti yang tidak ditentukan dari objek baru diminta, skrip akan memeriksa objek [[prototipe]] objek untuk properti sebagai gantinya. Ini adalah bagaimana Anda bisa mendapatkan sesuatu yang mirip dengan warisan kelas tradisional di JavaScript.
Bagian yang paling sulit tentang ini adalah titik nomor 2. Setiap objek (termasuk fungsi) memiliki properti internal ini disebut [[prototipe]] . Ini hanya dapat diatur pada waktu pembuatan objek, baik dengan yang baru , dengan Object.create , atau berdasarkan literal (fungsi default ke Function.prototype, angka ke Number.prototype, dll.). Itu hanya dapat dibaca dengan Object.getPrototypeOf (someObject) . Tidak ada cara lain untuk mengatur atau membaca nilai ini.
Fungsi, selain properti [[prototipe]] tersembunyi , juga memiliki properti yang disebut prototipe , dan inilah yang dapat Anda akses, dan modifikasi, untuk menyediakan properti dan metode yang diwarisi untuk objek yang Anda buat.
Berikut ini sebuah contoh:
ObjMaker = function() {this.a = 'first';};
// ObjMaker is just a function, there's nothing special about it that makes
// it a constructor.
ObjMaker.prototype.b = 'second';
// like all functions, ObjMaker has an accessible prototype property that
// we can alter. I just added a property called 'b' to it. Like
// all objects, ObjMaker also has an inaccessible [[prototype]] property
// that we can't do anything with
obj1 = new ObjMaker();
// 3 things just happened.
// A new, empty object was created called obj1. At first obj1 was the same
// as {}. The [[prototype]] property of obj1 was then set to the current
// object value of the ObjMaker.prototype (if ObjMaker.prototype is later
// assigned a new object value, obj1's [[prototype]] will not change, but you
// can alter the properties of ObjMaker.prototype to add to both the
// prototype and [[prototype]]). The ObjMaker function was executed, with
// obj1 in place of this... so obj1.a was set to 'first'.
obj1.a;
// returns 'first'
obj1.b;
// obj1 doesn't have a property called 'b', so JavaScript checks
// its [[prototype]]. Its [[prototype]] is the same as ObjMaker.prototype
// ObjMaker.prototype has a property called 'b' with value 'second'
// returns 'second'
Ini seperti warisan kelas karena sekarang, benda apa pun yang Anda buat menggunakan new ObjMaker()juga akan tampak mewarisi properti 'b'.
Jika Anda menginginkan sesuatu seperti subclass, maka Anda melakukan ini:
SubObjMaker = function () {};
SubObjMaker.prototype = new ObjMaker(); // note: this pattern is deprecated!
// Because we used 'new', the [[prototype]] property of SubObjMaker.prototype
// is now set to the object value of ObjMaker.prototype.
// The modern way to do this is with Object.create(), which was added in ECMAScript 5:
// SubObjMaker.prototype = Object.create(ObjMaker.prototype);
SubObjMaker.prototype.c = 'third';
obj2 = new SubObjMaker();
// [[prototype]] property of obj2 is now set to SubObjMaker.prototype
// Remember that the [[prototype]] property of SubObjMaker.prototype
// is ObjMaker.prototype. So now obj2 has a prototype chain!
// obj2 ---> SubObjMaker.prototype ---> ObjMaker.prototype
obj2.c;
// returns 'third', from SubObjMaker.prototype
obj2.b;
// returns 'second', from ObjMaker.prototype
obj2.a;
// returns 'first', from SubObjMaker.prototype, because SubObjMaker.prototype
// was created with the ObjMaker function, which assigned a for us
Saya membaca satu ton sampah tentang hal ini sebelum akhirnya menemukan halaman ini , di mana ini dijelaskan dengan sangat baik dengan diagram yang bagus.