Veo este patrón en bastantes bibliotecas de Node.js:

Master.prototype.__proto__ = EventEmitter.prototype;

(fuente aquí )

¿Alguien puede explicarme con un ejemplo por qué es un patrón tan común y cuándo es útil?

Como dice el comentario anterior de ese código, hará Master heredará EventEmitter.prototype, por lo que puede usar instancias de esa 'clase' para emitir y escuchar eventos.

Por ejemplo, ahora podría hacer:

masterInstance = new Master();

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

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

Actualización : como señalaron muchos usuarios, la forma 'estándar' de hacerlo en Node sería usar 'util.inherits':

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

2da actualización : con las clases de ES6 sobre nosotros, se recomienda extender la EventEmitterclase ahora:

const EventEmitter = require('events');

class MyEmitter extends EventEmitter {}

const myEmitter = new MyEmitter();

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

myEmitter.emit('event');

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

Herencia de clase de estilo ES6

Los documentos de Node ahora recomiendan usar la herencia de clases para crear su propio emisor de eventos:

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

Nota: Si define una constructor()función en MyEmitter, debe llamar super()desde ella para asegurarse de que también se llame al constructor de la clase principal, a menos que tenga una buena razón para no hacerlo.

Para heredar de otro objeto Javascript, EventEmitter de Node.js en particular, pero realmente cualquier objeto en general, necesita hacer dos cosas:

• proporcione un constructor para su objeto, que inicializa completamente el objeto; en el caso de que esté heredando de algún otro objeto, probablemente desee delegar parte de este trabajo de inicialización al superconstructor.
• proporcione un objeto prototipo que se utilizará como [[proto]]objeto creado a partir de su constructor; en el caso de que esté heredando de algún otro objeto, probablemente quiera usar una instancia del otro objeto como su prototipo.

Esto es más complicado en Javascript de lo que podría parecer en otros idiomas porque

• Javascript separa el comportamiento del objeto en "constructor" y "prototipo". Estos conceptos están pensados ​​para usarse juntos, pero pueden usarse por separado.
• Javascript es un lenguaje muy maleable y la gente lo usa de manera diferente y no existe una única definición verdadera de lo que significa "herencia".
• En muchos casos, puede salirse con la suya haciendo un subconjunto de lo que es correcto, y encontrará toneladas de ejemplos a seguir (incluidas algunas otras respuestas a esta pregunta SO) que parecen funcionar bien para su caso.

Para el caso específico de EventEmitter de Node.js, esto es lo que funciona:

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

Posibles debilidades:

• Si usa, configure el prototipo para su subclase (Master.prototype), con o sin usar util.inherits, pero no llame al superconstructor (EventEmitter ) para instancias de su clase, no se inicializarán correctamente.
• Si llama al superconstructor pero no establece el prototipo, los métodos EventEmitter no funcionarán en su objeto
• Puede intentar usar una instancia inicializada de la superclase ( new EventEmitter) en Master.prototypelugar de que el constructor de la subclase Masterllame al superconstructorEventEmitter ; dependiendo del comportamiento del constructor de la superclase, puede parecer que funciona bien por un tiempo, pero no es lo mismo (y no funcionará para EventEmitter).
• Puede intentar usar el superprototipo directamente ( Master.prototype = EventEmitter.prototype) en lugar de agregar una capa adicional de objeto a través de Object.create; esto puede parecer que está funcionando bien hasta que alguien parchea tu objeto Mastery, sin darse cuenta, también parchea EventEmittery todos sus otros descendientes. Cada "clase" debe tener su propio prototipo.

Nuevamente: para heredar de EventEmitter (o realmente cualquier "clase" de objeto existente), desea definir un constructor que se encadena al superconstructor y proporciona un prototipo que se deriva del superprototipo.

Así es como se realiza la herencia prototípica (¿prototípica?) En JavaScript. De MDN :

Se refiere al prototipo del objeto, que puede ser un objeto o nulo (lo que generalmente significa que el objeto es Object.prototype, que no tiene prototipo). A veces se utiliza para implementar búsquedas de propiedades basadas en herencia de prototipos.

Esto también funciona:

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

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

Comprender JavaScript OOP es uno de los mejores artículos que leí últimamente sobre OOP en ECMAScript 5.

Pensé que este enfoque de http://www.bennadel.com/blog/2187-Extending-EventEmitter-To-Create-An-Evented-Cache-In-Node-js.htm era bastante bueno:

function EventedObject(){

  // Super constructor
  EventEmitter.call( this );

  return( this );

}

Douglas Crockford también tiene algunos patrones de herencia interesantes: http://www.crockford.com/javascript/inheritance.html

Encuentro que la herencia se necesita con menos frecuencia en JavaScript y Node.js. Pero al escribir una aplicación en la que la herencia podría afectar la escalabilidad, consideraría el rendimiento contra el mantenimiento. De lo contrario, solo basaría mi decisión en qué patrones conducen a mejores diseños generales, son más fáciles de mantener y menos propensos a errores.

Pruebe diferentes patrones en jsPerf, usando Google Chrome (V8) para obtener una comparación aproximada. V8 es el motor de JavaScript utilizado por Node.js y Chrome.

Aquí hay algunos jsPerfs para comenzar:

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

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

http://jsperf.com/inheritance-perf

Para agregar a la respuesta de wprl. Se perdió la parte del "prototipo":

function EventedObject(){

   // Super constructor
   EventEmitter.call(this);

   return this;

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