Kedua contoh kode anda ditunjukkan dalam pertanyaan anda membuat penggunaan prototypal warisan. Pada kenyataannya setiap berorientasi obyek kode yang anda tulis di JavaScript adalah sebuah paradigma prototypal warisan. JavaScript hanya doesn't memiliki klasik warisan. Ini harus membersihkan hal-hal sedikit:

                                   Inheritance
                                        |
                         +-----------------------------+
                         |                             |
                         v                             v
                    Prototypal                     Classical
                         |
         +------------------------------+
         |                              |
         v                              v
Prototypal Pattern             Constructor Pattern

Seperti yang anda lihat prototypal warisan klasik dan warisan adalah dua paradigma yang berbeda dari warisan. Beberapa bahasa seperti Mandiri, Lua dan dukungan JavaScript prototypal warisan. Namun sebagian bahasa seperti C++, Java dan C# dukungan klasik warisan.

Gambaran singkat dari Pemrograman Berorientasi Objek #

Kedua prototypal warisan klasik dan warisan pemrograman berorientasi objek paradigma (yaitu mereka berurusan dengan benda-benda). Benda-benda yang hanya abstraksi yang merangkum sifat-sifat dunia nyata entitas (yaitu mereka mewakili kata nyata hal-hal dalam program). Hal ini dikenal sebagai abstraksi. Abstraksi: representasi dari dunia nyata hal-hal dalam program komputer. Theoretically abstraksi didefinisikan sebagai "konsep umum yang dibentuk dengan mengekstraksi fitur-fitur umum dari contoh-contoh spesifik". Namun demi penjelasan ini kami're akan menggunakan definisi tersebut sebagai gantinya. Sekarang beberapa benda-benda yang memiliki banyak kesamaan. Misalnya lumpur dan sepeda motor Harley Davidson memiliki banyak kesamaan. Lumpur sepeda: Harley Davidson: Lumpur dan sepeda motor Harley Davidson yang kedua sepeda. Oleh karena itu sepeda adalah generalisasi dari kedua lumpur sepeda dan motor Harley Davidson.

                   Bike
                     |
    +---------------------------------+
    |                                 |
    v                                 v
Mud Bike                       Harley Davidson

Dalam contoh di atas sepeda, lumpur sepeda dan motor Harley Davidson adalah semua abstraksi. Namun sepeda yang lebih umum abstraksi dari lumpur sepeda dan motor Harley Davidson (yaitu kedua lumpur sepeda dan motor Harley Davidson tipe tertentu dari sepeda). Generalisasi: abstraksi yang lebih spesifik abstraksi. Dalam pemrograman berorientasi objek yang kita buat benda-benda (yang merupakan abstraksi dari dunia nyata entitas) dan kami menggunakan salah satu kelas atau prototipe untuk membuat generalisasi dari benda tersebut. Generalisasi yang dibuat melalui warisan. Sepeda adalah generalisasi dari lumpur sepeda. Oleh karena itu lumpur sepeda mewarisi dari sepeda.

Klasik Pemrograman Berorientasi Objek #

Dalam bahasa pemrograman berorientasi objek, kita memiliki dua jenis abstraksi: kelas-kelas dan objek. Sebuah objek, seperti yang disebutkan sebelumnya, adalah sebuah abstraksi dari dunia nyata entitas. Kelas di sisi lain adalah sebuah abstraksi dari sebuah objek atau class lain (yaitu's generalisasi). Misalnya, mempertimbangkan:

+----------------------+----------------+---------------------------------------+
| Level of Abstraction | Name of Entity |                Comments               |
+----------------------+----------------+---------------------------------------+
| 0                    | John Doe       | Real World Entity.                    |
| 1                    | johnDoe        | Variable holding object.              |
| 2                    | Man            | Class of object johnDoe.              |
| 3                    | Human          | Superclass of class Man.              |
+----------------------+----------------+---------------------------------------+

Seperti yang anda lihat di klasik objek bahasa pemrograman berorientasi objek adalah abstraksi (yaitu semua benda-benda yang memiliki abstraksi tingkat 1) dan kelas hanya generalisasi (yaitu, semua kelas memiliki sebuah abstraksi tingkat yang lebih besar dari 1). Benda-benda klasik berorientasi objek bahasa pemrograman yang hanya dapat dibuat oleh instantiating kelas:

class Human {
    // ...
}

class Man extends Human {
    // ...
}

Man johnDoe = new Man();

Dalam penjumlahan di klasik objek bahasa pemrograman berorientasi objek adalah abstraksi dari dunia nyata dan entitas kelas generalisasi (yaitu abstraksi dari benda-benda atau kelas-kelas lain). Oleh karena itu sebagai tingkat abstraksi meningkatkan badan menjadi lebih umum dan sebagai tingkat abstraksi menurunkan badan menjadi lebih spesifik. Dalam hal ini tingkat abstraksi adalah analog dengan skala mulai dari yang lebih spesifik entitas yang lebih umum untuk entitas.

Prototypal Pemrograman Berorientasi Objek #

Prototypal pemrograman berorientasi objek bahasa yang jauh lebih sederhana dari yang klasik berorientasi objek bahasa pemrograman karena di prototypal pemrograman berorientasi objek, kita hanya memiliki satu jenis abstraksi (yaitu benda-benda). Misalnya, mempertimbangkan:

+----------------------+----------------+---------------------------------------+
| Level of Abstraction | Name of Entity |                Comments               |
+----------------------+----------------+---------------------------------------+
| 0                    | John Doe       | Real World Entity.                    |
| 1                    | johnDoe        | Variable holding object.              |
| 2                    | man            | Prototype of object johnDoe.          |
| 3                    | human          | Prototype of object man.              |
+----------------------+----------------+---------------------------------------+

Seperti yang anda lihat di prototypal objek bahasa pemrograman berorientasi objek adalah abstraksi dari dunia nyata entitas (dalam hal ini mereka hanya disebut object) atau benda-benda lain (dalam hal ini mereka disebut prototipe benda-benda yang mereka abstrak). Oleh karena itu sebuah prototipe adalah generalisasi. Benda-benda di prototypal berorientasi objek bahasa pemrograman yang akan dibuat baik secara ex-nihilo (yaitu keluar dari apa-apa) atau dari benda lain (yang menjadi prototype dari objek yang baru dibuat):

var human = {};
var man = Object.create(human);
var johnDoe = Object.create(man);

Dalam pendapat sederhana saya prototypal berorientasi objek bahasa pemrograman yang lebih kuat dari yang klasik pemrograman berorientasi objek bahasa karena:

1. Hanya ada satu jenis abstraksi.

2. Generalisasi adalah hanya benda-benda. Dengan sekarang anda harus menyadari perbedaan antara klasik warisan dan prototypal warisan. Klasik warisan terbatas untuk kelas mewarisi dari kelas-kelas lain. Namun prototypal warisan tidak hanya mencakup prototipe mewarisi dari prototipe lainnya, tetapi juga benda-benda yang mewarisi dari prototipe.

   Prototipe Kelas Isomorphism

   Anda harus menyadari bahwa prototipe dan kelas yang sangat mirip. Yang's benar. Mereka. Bahkan mereka begitu mirip bahwa anda benar-benar dapat menggunakan prototipe untuk model kelas:

function CLASS(base, body) {
    if (arguments.length < 2) body = base, base = Object.prototype;
    var prototype = Object.create(base, {new: {value: create}});
    return body.call(prototype, base), prototype;

    function create() {
        var self = Object.create(prototype);
        return prototype.hasOwnProperty("constructor") &&
            prototype.constructor.apply(self, arguments), self;
    }
}

Di atas menggunakan KELAS fungsi anda dapat membuat prototipe yang terlihat seperti kelas-kelas:

var Human = CLASS(function () {
    var milliseconds = 1
      , seconds      = 1000 * milliseconds
      , minutes      = 60 * seconds
      , hours        = 60 * minutes
      , days         = 24 * hours
      , years        = 365.2425 * days;

    this.constructor = function (name, sex, dob) {
        this.name = name;
        this.sex = sex;
        this.dob = dob;
    };

    this.age = function () {
        return Math.floor((new Date - this.dob) / years);
    };
});

var Man = CLASS(Human, function (Human) {
    this.constructor = function (name, dob) {
        Human.constructor.call(this, name, "male", dob);
        if (this.age() < 18) throw new Error(name + " is a boy, not a man!");
    };
});

var johnDoe = Man.new("John Doe", new Date(1970, 0, 1));

Sebaliknya adalah tidak benar namun (yaitu anda dapat't menggunakan kelas untuk model prototipe). Hal ini karena prototipe benda tetapi kelas yang bukan benda. Mereka adalah jenis yang sama sekali berbeda dari abstraksi.

Kesimpulan #

Dalam penjumlahan kita belajar bahwa sebuah abstraksi adalah "konsep umum yang dibentuk dengan mengekstraksi fitur-fitur umum dari contoh-contoh spesifik" dan bahwa generalisasi adalah "sebuah abstraksi yang lebih spesifik abstraksi". Kami juga belajar tentang perbedaan antara prototypal dan klasik warisan dan bagaimana keduanya adalah dua sisi dari koin yang sama. Pada catatan perpisahan saya ingin berkomentar bahwa ada dua pola prototypal warisan: prototypal pola dan pembuat pola. Yang prototypal pola kanonik pola prototypal warisan sedangkan konstruktor pola ini digunakan untuk membuat prototypal warisan terlihat lebih seperti klasik warisan. Secara pribadi saya lebih suka prototypal pola. P. S. I'm orang yang menulis posting blog "Mengapa Prototypal Warisan Penting" dan menjawab pertanyaan "https://stackoverflow.com/questions/2800964/benefits-of-prototypal-inheritance-over-classical". Jawaban saya adalah jawaban yang diterima.

Sebelum melompat ke dalam warisan, kita akan melihat pada dua primer model untuk membuat contoh (benda-benda) dalam javascript:

Model klasik: Objek dibuat dari cetak biru (kelas)

class Person {
  fn() {...}
} // or constructor function say, function Person() {}

// create instance
let person = new Person();

Prototypal model: Objek dibuat langsung dari objek lain.

// base object
let Person = { fn(){...} }

// instance
let person = Object.create(Person);

Dalam kedua kasus, Warisan* ini dicapai dengan menghubungkan benda dengan menggunakan prototipe objek.

(*kelas dasar metode ini adalah dapat diakses melalui. kelas yang diturunkan melalui prototipe objek dan tidak diperlukan untuk secara eksplisit hadir dalam class turunan.)

Berikut ini adalah penjelasan yang baik untuk memahami lebih baik (http://www.objectplayground.com/)