Saya melihat pola ini di beberapa perpustakaan Node.js:

Master.prototype.__proto__ = EventEmitter.prototype;

(sumber di sini )

Bisakah seseorang menjelaskan kepada saya dengan sebuah contoh, mengapa ini adalah pola yang umum dan kapan itu berguna?

Seperti komentar di atas yang dikatakan kode itu, itu akan membuat Masterwarisan dari EventEmitter.prototype, sehingga Anda dapat menggunakan contoh dari 'kelas' itu untuk memancarkan dan mendengarkan acara.

Misalnya sekarang Anda dapat melakukan:

masterInstance = new Master();

masterInstance.on('an_event', function () {
  console.log('an event has happened');
});

// trigger the event
masterInstance.emit('an_event');

Pembaruan : seperti yang ditunjukkan oleh banyak pengguna, cara 'standar' untuk melakukan itu di Node adalah menggunakan 'util.inherits':

var EventEmitter = require('events').EventEmitter;
util.inherits(Master, EventEmitter);

Pembaruan ke-2 : dengan kelas ES6 pada kami, disarankan untuk memperluas EventEmitterkelas sekarang:

const EventEmitter = require('events');

class MyEmitter extends EventEmitter {}

const myEmitter = new MyEmitter();

myEmitter.on('event', () => {
  console.log('an event occurred!');
});

myEmitter.emit('event');

Lihat https://nodejs.org/api/events.html#events_events

Pewarisan Kelas Gaya ES6

Dokumen Node sekarang merekomendasikan penggunaan class inheritence untuk membuat event emitter Anda sendiri:

const EventEmitter = require('events');

class MyEmitter extends EventEmitter {
  // Add any custom methods here
}

const myEmitter = new MyEmitter();
myEmitter.on('event', () => {
  console.log('an event occurred!');
});
myEmitter.emit('event');

Catatan: Jika Anda mendefinisikan sebuah constructor()fungsi di MyEmitter, Anda harus memanggilnya super()untuk memastikan konstruktor kelas induk juga dipanggil, kecuali Anda punya alasan kuat untuk tidak melakukannya.

Untuk mewarisi dari objek Javascript lain, EventEmitter Node.js secara khusus tetapi sebenarnya objek apa pun secara umum, Anda perlu melakukan dua hal:

• menyediakan konstruktor untuk objek Anda, yang menginisialisasi objek sepenuhnya; jika Anda mewarisi dari beberapa objek lain, Anda mungkin ingin mendelegasikan beberapa pekerjaan inisialisasi ini ke konstruktor super.
• menyediakan objek prototipe yang akan digunakan sebagai [[proto]]untuk objek yang dibuat dari konstruktor Anda; dalam hal Anda mewarisi dari beberapa objek lain, Anda mungkin ingin menggunakan instance dari objek lain sebagai prototipe Anda.

Ini lebih rumit di Javascript daripada yang terlihat di bahasa lain karena

• Javascript memisahkan perilaku objek menjadi "konstruktor" dan "prototipe". Konsep ini dimaksudkan untuk digunakan bersama, tetapi dapat digunakan secara terpisah.
• Javascript adalah bahasa yang sangat mudah dibentuk dan orang menggunakannya secara berbeda dan tidak ada definisi tunggal yang sebenarnya tentang apa arti "warisan".
• Dalam banyak kasus, Anda dapat lolos dengan melakukan subset dari apa yang benar, dan Anda akan menemukan banyak contoh untuk diikuti (termasuk beberapa jawaban lain untuk pertanyaan SO ini) yang tampaknya berfungsi dengan baik untuk kasus Anda.

Untuk kasus spesifik EventEmitter Node.js, inilah yang berhasil:

var EventEmitter = require('events').EventEmitter;
var util = require('util');

// Define the constructor for your derived "class"
function Master(arg1, arg2) {
   // call the super constructor to initialize `this`
   EventEmitter.call(this);
   // your own initialization of `this` follows here
};

// Declare that your class should use EventEmitter as its prototype.
// This is roughly equivalent to: Master.prototype = Object.create(EventEmitter.prototype)
util.inherits(Master, EventEmitter);

Kelemahan yang mungkin:

• Jika Anda menggunakan set prototipe untuk subclass Anda (Master.prototype), dengan atau tanpa menggunakan util.inherits, tetapi tidak memanggil super constructor ( EventEmitter) untuk instance kelas Anda, mereka tidak akan diinisialisasi dengan benar.
• Jika Anda memanggil konstruktor super tetapi tidak menyetel prototipe, metode EventEmitter tidak akan berfungsi pada objek Anda
• Anda bisa mencoba menggunakan instance yang diinisialisasi dari superclass ( new EventEmitter) sebagai Master.prototypeganti meminta konstruktor subclass Mastermemanggil super konstruktor EventEmitter; tergantung pada perilaku konstruktor superclass yang mungkin tampak berfungsi dengan baik untuk sementara waktu, tetapi bukan hal yang sama (dan tidak akan berfungsi untuk EventEmitter).
• Anda bisa mencoba menggunakan super prototipe secara langsung ( Master.prototype = EventEmitter.prototype) daripada menambahkan lapisan objek tambahan melalui Object.create; ini mungkin tampak berfungsi dengan baik sampai seseorang mencocokkan objek Anda Masterdan secara tidak sengaja juga mencocokkan monkeypatch EventEmitterdan semua turunan lainnya. Setiap "kelas" harus memiliki prototipe sendiri.

Sekali lagi: untuk mewarisi dari EventEmitter (atau objek "kelas" yang sebenarnya), Anda ingin menentukan konstruktor yang terhubung ke konstruktor super dan menyediakan prototipe yang diturunkan dari super prototipe.

Beginilah cara pewarisan prototipe (prototypal?) Dilakukan di JavaScript. Dari MDN :

Mengacu pada prototipe objek, yang mungkin berupa objek atau null (yang biasanya berarti objek tersebut adalah Object.prototype, yang tidak memiliki prototipe). Terkadang digunakan untuk mengimplementasikan pencarian properti berbasis prototipe-inheritance.

Ini bekerja juga:

var Emitter = function(obj) {
    this.obj = obj;
}

// DON'T Emitter.prototype = new require('events').EventEmitter();
Emitter.prototype = Object.create(require('events').EventEmitter.prototype);

Memahami JavaScript OOP adalah salah satu artikel terbaik yang saya baca akhir-akhir ini di OOP di ECMAScript 5.

Saya pikir pendekatan dari http://www.bennadel.com/blog/2187-Extending-EventEmitter-To-Create-An-Evented-Cache-In-Node-js.htm ini cukup rapi:

function EventedObject(){

  // Super constructor
  EventEmitter.call( this );

  return( this );

}

Douglas Crockford juga memiliki beberapa pola pewarisan yang menarik: http://www.crockford.com/javascript/inheritance.html

Saya menemukan bahwa inheritence jarang dibutuhkan di JavaScript dan Node.js. Namun dalam menulis aplikasi yang pewarisannya dapat memengaruhi skalabilitas, saya akan mempertimbangkan performa yang dibandingkan dengan pemeliharaan. Jika tidak, saya hanya akan mendasarkan keputusan saya pada pola mana yang mengarah pada desain keseluruhan yang lebih baik, lebih mudah dirawat, dan tidak terlalu rentan terhadap kesalahan.

Uji pola yang berbeda di jsPerf, menggunakan Google Chrome (V8) untuk mendapatkan perbandingan kasar. V8 adalah mesin JavaScript yang digunakan oleh Node.js dan Chrome.

Berikut ini beberapa jsPerf untuk Anda mulai:

http://jsperf.com/prototypes-vs-functions/4

http://jsperf.com/inheritance-proto-vs-object-create

http://jsperf.com/inheritance-perf

Untuk menambah respon wprl. Dia melewatkan bagian "prototipe":

function EventedObject(){

   // Super constructor
   EventEmitter.call(this);

   return this;

}
EventObject.prototype = new EventEmitter(); //<-- you're missing this part