Я вижу этот паттерн во многих библиотеках Node.js:

Master.prototype.__proto__ = EventEmitter.prototype;

(источник здесь )

Может кто-нибудь объяснить мне на примере, почему это такой распространенный шаблон и когда он удобен?

Как говорится в комментарии к этому коду, он будет Masterнаследовать от EventEmitter.prototype, поэтому вы можете использовать экземпляры этого «класса» для генерации и прослушивания событий.

Например, теперь вы можете:

masterInstance = new Master();

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

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

Обновление : как отметили многие пользователи, «стандартным» способом сделать это в Node было бы использование «util.inherits»:

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

2-е обновление : с классами ES6 мы рекомендуем расширить EventEmitterкласс сейчас:

const EventEmitter = require('events');

class MyEmitter extends EventEmitter {}

const myEmitter = new MyEmitter();

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

myEmitter.emit('event');

См. Https://nodejs.org/api/events.html#events_events.

Наследование класса стиля ES6

В документации по Node теперь рекомендуется использовать наследование классов для создания собственного эмиттера событий:

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');

Примечание. Если вы определяете constructor()функцию в MyEmitter, вы должны вызывать super()из нее, чтобы убедиться, что конструктор родительского класса также вызывается, если у вас нет веской причины не делать этого.

Чтобы наследовать от другого объекта Javascript, в частности от EventEmitter Node.js, но на самом деле от любого объекта в целом, вам необходимо сделать две вещи:

• предоставьте конструктор для вашего объекта, который полностью инициализирует объект; в случае, если вы наследуете от какого-то другого объекта, вы, вероятно, захотите делегировать часть этой работы по инициализации суперконструктору.
• предоставить объект-прототип, который будет использоваться в качестве [[proto]]объекта for, созданного из вашего конструктора; в случае, если вы наследуете от какого-то другого объекта, вы, вероятно, захотите использовать экземпляр другого объекта в качестве своего прототипа.

В Javascript это сложнее, чем может показаться на других языках, потому что

• Javascript разделяет поведение объекта на «конструктор» и «прототип». Эти концепции предназначены для использования вместе, но могут использоваться по отдельности.
• Javascript - очень гибкий язык, люди используют его по-разному, и нет единого истинного определения того, что означает «наследование».
• Во многих случаях вам может сойти с рук выполнение части того, что является правильным, и вы найдете множество примеров для подражания (включая некоторые другие ответы на этот вопрос SO), которые, похоже, подходят для вашего случая.

Для конкретного случая EventEmitter Node.js вот что работает:

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);

Возможные недостатки:

• Если вы используете set прототип для вашего подкласса (Master.prototype) с использованием или без использования util.inherits, но не вызываете суперконструктор ( EventEmitter) для экземпляров вашего класса, они не будут правильно инициализированы.
• Если вы вызываете суперконструктор, но не устанавливаете прототип, методы EventEmitter не будут работать с вашим объектом.
• Вы можете попробовать использовать инициализированный экземпляр суперкласса ( new EventEmitter) Master.prototypeвместо того, чтобы конструктор подкласса Masterвызывал суперконструктор EventEmitter; в зависимости от поведения конструктора суперкласса, который может показаться, что какое-то время он работает нормально, но это не одно и то же (и не будет работать для EventEmitter).
• Вы можете попробовать использовать суперпрототип напрямую ( Master.prototype = EventEmitter.prototype) вместо добавления дополнительного уровня объекта через Object.create; может показаться, что он работает нормально, пока кто-то не исправит ваш объект Masterи по неосторожности не исправит его EventEmitterи всех его потомков. У каждого «класса» должен быть свой прототип.

Опять же: чтобы наследовать от EventEmitter (или действительно от любого существующего «класса» объекта), вы хотите определить конструктор, который привязывается к суперконструктору и предоставляет прототип, производный от суперпрототипа.

Вот как в JavaScript выполняется прототипное (прототипное?) Наследование. Из MDN :

Относится к прототипу объекта, который может быть объектом или нулевым значением (что обычно означает, что объект - это Object.prototype, у которого нет прототипа). Иногда он используется для реализации поиска свойств на основе наследования прототипов.

Это тоже работает:

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

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

Понимание ООП в JavaScript - одна из лучших статей, которые я читал за последнее время по ООП в ECMAScript 5.

Я думал, что этот подход из http://www.bennadel.com/blog/2187-Exnding-EventEmitter-To-Create-An-Evented-Cache-In-Node-js.htm был довольно аккуратным:

function EventedObject(){

  // Super constructor
  EventEmitter.call( this );

  return( this );

}

У Дугласа Крокфорда тоже есть несколько интересных паттернов наследования: http://www.crockford.com/javascript/inheritance.html

Я считаю, что наследование реже требуется в JavaScript и Node.js. Но при написании приложения, в котором наследование может повлиять на масштабируемость, я бы считал производительность сопоставимой с удобством обслуживания. В противном случае я бы основывал свое решение только на том, какие шаблоны приводят к лучшему общему дизайну, более удобны в обслуживании и менее подвержены ошибкам.

Протестируйте различные шаблоны в jsPerf, используя Google Chrome (V8), чтобы получить приблизительное сравнение. V8 - это движок JavaScript, используемый как Node.js, так и Chrome.

Вот несколько jsPerf для начала:

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

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

http://jsperf.com/inheritance-perf

Чтобы добавить к ответу wprl. Он пропустил «прототипную» часть:

function EventedObject(){

   // Super constructor
   EventEmitter.call(this);

   return this;

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