Javascript kapan harus menggunakan prototipe

Saya ingin memahami kapan saat yang tepat untuk menggunakan metode prototipe di js. Haruskah mereka selalu digunakan? Atau adakah kasus di mana menggunakannya tidak disukai dan / atau menimbulkan hukuman kinerja?

Dalam mencari di sekitar situs ini tentang metode umum untuk namespacing di js, tampaknya sebagian besar menggunakan implementasi berbasis non-prototipe: cukup menggunakan objek atau objek fungsi untuk merangkum namespace.

Berasal dari bahasa berbasis kelas, sulit untuk tidak mencoba dan menggambar paralel dan berpikir bahwa prototipe itu seperti "kelas" dan implementasi namespace yang saya sebutkan seperti metode statis.

Prototipe adalah pengoptimalan .

Contoh bagus untuk menggunakannya dengan baik adalah pustaka jQuery. Setiap kali Anda mendapatkan objek jQuery dengan menggunakan $('.someClass'), objek itu memiliki lusinan "metode". Perpustakaan bisa mencapainya dengan mengembalikan objek:

return {
   show: function() { ... },
   hide: function() { ... },
   css: function() { ... },
   animate: function() { ... },
   // etc...
};

Tetapi itu berarti bahwa setiap objek jQuery dalam memori akan memiliki lusinan slot bernama yang berisi metode yang sama, berulang kali.

Sebaliknya, metode tersebut ditentukan pada prototipe dan semua objek jQuery "mewarisi" prototipe itu untuk mendapatkan semua metode tersebut dengan biaya runtime yang sangat sedikit.

Salah satu bagian yang sangat penting tentang bagaimana jQuery melakukannya dengan benar adalah bahwa ini disembunyikan dari programmer. Ini diperlakukan murni sebagai pengoptimalan, bukan sebagai sesuatu yang harus Anda khawatirkan saat menggunakan pustaka.

Masalah dengan JavaScript adalah bahwa fungsi konstruktor polos mengharuskan pemanggil untuk mengingat untuk mengawalnya newatau jika tidak, fungsi tersebut biasanya tidak berfungsi. Tidak ada alasan bagus untuk ini. jQuery melakukannya dengan benar dengan menyembunyikan omong kosong itu di balik fungsi biasa $, jadi Anda tidak perlu peduli bagaimana objek diimplementasikan.

Agar Anda dapat dengan mudah membuat objek dengan prototipe tertentu, ECMAScript 5 menyertakan fungsi standar Object.create. Versi yang sangat disederhanakan akan terlihat seperti ini:

Object.create = function(prototype) {
    var Type = function () {};
    Type.prototype = prototype;
    return new Type();
};

Itu hanya menangani rasa sakit menulis fungsi konstruktor dan kemudian memanggilnya dengan new.

Kapan Anda menghindari prototipe?

Perbandingan yang berguna adalah dengan bahasa OO populer seperti Java dan C #. Ini mendukung dua jenis warisan:

• antarmuka warisan, di mana Anda implementsebuah interfacesehingga kelas menyediakan implementasi sendiri yang unik untuk setiap anggota antarmuka.
• penerapan warisan, di mana Anda extendseorang classyang menyediakan implementasi default dari beberapa metode.

Dalam JavaScript, pewarisan prototipe adalah jenis pewarisan implementasi . Jadi dalam situasi di mana (di C # atau Java) Anda akan diturunkan dari kelas dasar untuk mendapatkan perilaku default, yang kemudian Anda modifikasi kecil melalui penggantian, lalu di JavaScript, pewarisan prototipe masuk akal.

Namun, jika Anda berada dalam situasi di mana Anda akan menggunakan antarmuka di C # atau Java, maka Anda tidak memerlukan fitur bahasa tertentu di JavaScript. Tidak perlu secara eksplisit mendeklarasikan sesuatu yang mewakili antarmuka, dan tidak perlu menandai objek sebagai "mengimplementasikan" antarmuka itu:

var duck = {
    quack: function() { ... }
};

duck.quack(); // we're satisfied it's a duck!

Dengan kata lain, jika setiap "jenis" objek memiliki definisi sendiri dari "metode", maka tidak ada nilai dalam mewarisi dari prototipe. Setelah itu, itu tergantung pada berapa banyak contoh yang Anda alokasikan untuk setiap jenis. Tetapi dalam banyak desain modular, hanya ada satu contoh dari tipe tertentu.

Dan nyatanya, telah dikemukakan oleh banyak orang bahwa pelaksanaan warisan itu jahat . Artinya, jika ada beberapa operasi umum untuk suatu tipe, maka mungkin lebih jelas jika mereka tidak dimasukkan ke dalam kelas dasar / super, tetapi hanya diekspos sebagai fungsi biasa di beberapa modul, yang Anda berikan objeknya Anda ingin mereka mengoperasi.

Anda harus menggunakan prototipe jika Anda ingin mendeklarasikan metode "non-statis" dari objek tersebut.

var myObject = function () {

};

myObject.prototype.getA = function (){
  alert("A");
};

myObject.getB = function (){
  alert("B");
};

myObject.getB();  // This works fine

myObject.getA();  // Error!

var myPrototypeCopy = new myObject();
myPrototypeCopy.getA();  // This works, too.

Salah satu alasan untuk menggunakan prototypeobjek bawaan adalah jika Anda akan menduplikasi objek beberapa kali yang akan berbagi fungsionalitas yang sama. Dengan melampirkan metode ke prototipe, Anda dapat menghemat metode duplikat yang dibuat untuk setiap newinstance. Tetapi ketika Anda melampirkan metode ke prototype, semua instance akan memiliki akses ke metode tersebut.

Katakanlah Anda memiliki Car()kelas / objek dasar.

function Car() {
    // do some car stuff
}

lalu Anda membuat beberapa Car()contoh.

var volvo = new Car(),
    saab = new Car();

Sekarang, Anda tahu bahwa setiap mobil perlu dikendarai, dihidupkan, dll. Alih-alih melampirkan metode langsung ke Car()kelas (yang membutuhkan memori per setiap instance yang dibuat), Anda dapat melampirkan metode ke prototipe sebagai gantinya (hanya membuat metode sekali), oleh karena itu memberikan akses ke metode tersebut untuk yang baru volvodan saab.

// just mapping for less typing
Car.fn = Car.prototype;

Car.fn.drive = function () {
    console.log("they see me rollin'");
};
Car.fn.honk = function () {
    console.log("HONK!!!");
}

volvo.honk();
// => HONK!!!
saab.drive();
// => they see me rollin'

Letakkan fungsi pada objek prototipe saat Anda akan membuat banyak salinan dari jenis objek tertentu dan semuanya perlu berbagi perilaku yang sama. Dengan melakukan itu, Anda akan menghemat sebagian memori dengan hanya memiliki satu salinan dari setiap fungsi, tetapi itu hanya manfaat yang paling sederhana.

Mengubah metode pada objek prototipe, atau menambahkan metode, langsung mengubah sifat semua instance dari tipe yang sesuai.

Sekarang tepatnya mengapa Anda melakukan semua hal ini sebagian besar adalah fungsi dari desain aplikasi Anda sendiri, dan hal-hal yang perlu Anda lakukan dalam kode sisi klien. (Cerita yang sangat berbeda akan menjadi kode di dalam server; jauh lebih mudah membayangkan melakukan lebih banyak kode "OO" berskala besar di sana.)

Jika saya jelaskan dalam istilah berbasis kelas maka Person adalah kelas, walk () adalah metode Prototipe. Jadi walk () hanya akan ada setelah Anda membuat instance objek baru dengan ini.

Jadi jika Anda ingin membuat salinan objek seperti Person u dapat membuat banyak pengguna Prototipe adalah solusi yang baik karena menghemat memori dengan berbagi / mewarisi salinan fungsi yang sama untuk setiap objek dalam memori.

Sedangkan statis tidak terlalu membantu dalam skenario seperti itu.

function Person(){
this.name = "anonymous";
}

// its instance method and can access objects data data 
Person.prototype.walk = function(){
alert("person has started walking.");
}
// its like static method
Person.ProcessPerson = function(Person p){
alert("Persons name is = " + p.name);
}

var userOne = new Person();
var userTwo = new Person();

//Call instance methods
userOne.walk();

//Call static methods
Person.ProcessPerson(userTwo);

Jadi dengan ini lebih seperti metode contoh. Pendekatan objek seperti metode Statis.

https://developer.mozilla.org/en/Introduction_to_Object-Oriented_JavaScript