Node.js dersleri 2 - EventEmitters, kendi EventEmitter'ınızı nasıl yaratırsınız?

3  - Using EventEmitters -1

http://nodeguide.com/beginner.html

Explanation 1 :

Node.js implements the observer pattern using a class called EventEmitter. You can listen to a specific event by calling the on() function on your object, providing the name of the event, as well as a callback closure as the parameters. ( Node.js, EventEmitter class'ını kullanarak observer pattern'ı implement eder. Specific bir event'i dinlemek için EventEmitter class'ının on() method'unu çağırırız, bu method'a verdiğimiz ilk parametre dinleyeceğimiz event ismidir. )

For example:

var data = '';

req

  .on('data', function(chunk) {

    data += chunk;

  })

  .on('end', function() {

    console.log('POST data: %s', data);

  })

As you can see, the on() function also returns a reference to the object it belongs to, allowing you to chain several of such event listeners.(on() fonksiyonu ait olduğu object'e reference return eder, dolayısıyla request.on().on().on().on() diye birden fazla on() fonksiyonunu art arda yazabiliriz.  )

If you're only interested in the first occurrence of an event, you can use the once() function instead. ( Eğer bir event'in sadece bir kez trigger edilebilmesini istiyorsak on() değil once() method'unu kullanmalıyız. once() method'u kullanılarak register edilen bir event yalnızca bir defa çağırılabilir, bir kez çağırıldıktan sonra otomatik olarak unregister edilir artık böyle bir event yoktur. )

Finally, you can remove event listeners by using the removeListener function. Please note that the argument to this function is a reference to the callback you are trying to remove, not the name of the event (Bir event'i remove etmek(unregister etmek) için removeListener() method'unu çağırırız. removeListener method argument olarak unregister edilecek event ismini değil, bu event'in callback fonksiyonunu yani anonymous fonksiyonunu alır.

Aşağıdaki örnekte, önce onData isimli bir fonksiyon tanımlıyoruz. Bu fonksiyonda EventEmitter object'in removeListener() method'unu çağırıyoruz. Aşağıdaki örnekte bu fonksiyon(onData) argument olarak kendisini almıştır, diğer bir deyişle kendisine refer eden variable'ı alır. Sonra data isimli bir event dinleyebilmek için EventEmitter object'in on method'unu çağırırız, bu method'a verdiğimiz 1.parametre dinleyeceğimiz event ismi'dir yani data'dır, 2.parametre ismi ise bu event gerçekleştiğinde yan emit edildiğinde çalıştırılacak olan fonksiyondur. data event'i emit edildiğinde(tetiklendiginde) onData fonksiyonu çalıştırılır, onData() fonksiyonun body'sinde data event'i unregister edilir. Dolayısıyla artık data event'ini dinlemiyoruz. Aslında bu once() method'unun implementation'ı gibi düşünebiliriz, çünkü once method'u kullanılarak bir event'in callback(anonymous) fonksiyonu bir kez çağırıldıktan sonra bu event unregister edilir, aynen bu örnekteki gibi. ) :

var onData = function(chunk) {

  console.log(chunk);

  req.removeListener(onData);

}

req.on('data', onData);

The example above is essentially identical to the once() function.

Explanation2(http://www.hacksparrow.com/node-js-eventemitter-tutorial.html):

All the event-based Node.js libraries are EventEmitters! In OOP lingo, you might say those Node libraries extend EventEmitter. The power of EventEmitter need not be limited to the built-in Node libraries anymore - now it can be yours too! Take a look at the following example. ( Event'e dayalı tüm built-in Node.js library'leri EventEmitter'dan extend eder. Ayrıca EventEmitter'ı kullanarak kendi event'lerimizi de yazabiliriz. Aşağıdaki örneğe bakalım. ) :

var EventEmitter = require('events').EventEmitter;
var radium = new EventEmitter();

radium.on('radiation', function(ray) {
    console.log(ray);
});

setInterval(function() {
    radium.emit('radiation', 'GAMMA');
}, 1000);

Notice how easy it is to create custom events, add event listeners, emit events, and pass messages via events. EventEmitter is what makes it possible to write amazing libraries for Node.js. ( EventEmitter kullanarak muhteşem library'ler yazabiliriz. Yukarıdaki örnekte custom bir event yarattık, bu event'e listener ekledik, sonra bu event'i emit ettik(tetikledik) emit ederken de 'GAMMA' diye bir string değerini event listener fonksiyonumuza gönderdik. )

The above example was based on an instance of EventEmitter; how do we create classes that extend EventEmitter? Node.js has a library named util, which has a method named inherits, which makes it possible to easily extend any class using any other class: (Yukarıdaki örnekte, EventEmitter class'ından bir instance yarattık. Peki EventEmitter class'ını extend eden bir class nasıl yaratabiliriz? Bunun için Node.js'nin sahip olduğu util isimli bir library'yi kullanacağız. util library'sinde inherits diye bir method vardır. Bu method'u kullanarak bir class'dan extend eden bir class yaratabiliriz. )

SuperClass'dan bir MyClass extend böyle edilir.

var util = require('util');
util.inherits(MyClass, SuperClass);

If, for some reason you don't feel like using the util module and doing util.inherits(), you can extend a class (let's say Apple) this way (Alternatif olarak, Radio class'ının EventEmitter class'ından extend etmek için şöyle de yapabilirdik.) :

Apple.prototype = Object.create(require('events').EventEmitter.prototype);

EventEmitter will help you write impressive event-based Node modules. Also your knowledge ofEventEmitter will greatly affect your efficiency as a Node.js developer, so make sure to read more about it and learn how it works inside out. If you don't know EventEmitter, you don't know Node.js yet!

The value of this, when used in a function, is the object that "owns" the function." - Nope. The value of this depends on how the function is called.

This within a callback function passed to setTimeout will represent the window object, because it is the browser that will call that callback once the time-out occurs." 

If you would have written this.emit('close', station); you would get a runtime error saying that this.emit is not a function. This is because at that moment this is window (as explained above).

A  function usually does not belong to a particular object, and that it is anonymous has no bearing on it. Even if you write setTimeout(myobj.myfunc, 100), the function passed to setTimeout does not belong to myobj. The exception is when a function is explicitly bound to a certain object that will have the role of this, with bind.

If you would have written this.emit('close', station); you would get a runtime error saying that this.emit is not a function. This is because at that moment this is window (as explained above). 

test.js kodunda, radio.on('open',...), radio.on('close',...), radio.on('messi',...) diyerek radio isimli EventEmitter object'e eklediğimiz listener'lar için, bu listener'ları EventEmitter object'e ekler eklemez, EventEmitter object'in newListener event'i emit edilir.

4 - EventEmitters-2

• EventEmitter class is inside events module.

// Import events module

var events = require('events');

// Create an eventEmitter object

var eventEmitter = new events.EventEmitter();

• When an EventEmitter instance faces any error, it emits an 'error' event. When new listener is added, 'newListener' event is fired and when a listener is removed, 'removeListener' event is fired.
• EventEmitter provides multiple properties like on and emit. on property is used to bind a function with the event and emit is used to fire an event.

tobecontinued with

http://www.tutorialspoint.com/nodejs/nodejs_event_emitter.htm

https://nodejs.org/api/events.html

5- How to create your own EventEmitter in NodeJS in 3 Steps

http://terlson.blogspot.com.tr/2013/08/how-to-create-your-own-eventemitter-in.html

I find  the code snippet in the document 

var util = require("util");

var events = require("events");

function MyStream() {

    events.EventEmitter.call(this);  // What is the meaning here ? It seams that it is equivalent to `new MyStream`  

}

util.inherits(MyStream, events.EventEmitter);

var steam = new MyStream();

What doesn't the document  give the detail about this ???

Why ? 

Why ? 

It is common practice in OOP js.

You call the constructor of the parent class in its constructor with a pointer to itself, thereby extending a parent's properties.

example:

function A () { 

console.log('a constructor'); 

this.a = 'a' 

};

function B () { 

A.call(this); 

console.log('b constructor'); 

this.b = 'b' 

};

var b = new B();

=> a constructor

=> b constructor

b.a => 'a';

b.b => 'b';