Das Hinzufügen oder Entfernen von EventEmitter.call (this) in meinem Node-Beispiel macht keinen Unterschied, warum?

Question

Ich bin neu bei Node.js und fing an, es zu lernen.

Ich stieß auf "EventEmitter" in "Events" -Modul in Knoten.

Nachdem nach dem Beispiel in EventEmitter Dokumentation ich den bolow Code geschrieben,

var EventEmitter = require("events"); 
var util = require("util"); 

var Ticker = function(){ 
    var self = this; 
    EventEmitter.call(self); 

    self.start = function(){ 
    setInterval(function(){ 
     self.emit("tick"); 
    },1000); 
    } 

    self.on("tick",function(){ 
    console.log("Keep Ticking"); 
    }); 
} 

util.inherits(Ticker,EventEmitter); 

var ticker = new Ticker(); 
ticker.start(); 

Wenn ich den Code ausführen

node example03.js 

die Ausgabe

rahul@ubuntu:~/rahul/NodePractise/EventEmitter$ node example03.js 
Keep Ticking 
Keep Ticking 
Keep Ticking 
Keep Ticking 
^C 
rahul@ubuntu:~/rahul/NodePractise/EventEmitter$ 

Nun, auch wenn ich Kommentieren Sie die Zeile

//EventEmitter.call(self); 

Der Code funktioniert gut.

Also was ist der Zweck der obigen Zeile und wie ist ihre Präsenz wichtig.

Answer 1

Also was ist der Zweck der obigen Zeile und wie ist ihre Anwesenheit wichtig.

Die Codezeile:

EventEmitter.call(self); 

ist, so dass die Basisklasse (was man von geerbt) es richtig initialisiert werden kann eigene Instanz ist jeweils Sie Zeit, eine neue Instanz der abgeleiteten Klasse erstellen. Dies ist ein sehr wichtiger Schritt, der nicht ausgelassen werden sollte.

Um genau zu erklären, was es macht, ist EventEmitter die Konstruktorfunktion des Objekts, von dem Sie abgeleitet wurden. .call(self) weist Javascript an, diese Konstruktorfunktion aufzurufen und den Wert this auf das Objekt festzulegen, das gerade erstellt wurde (auf das in Ihrem Code self zeigt). Das wird am Ende den EventEmitter Konstruktor auf die gleiche Weise aufrufen wie new EventEmitter() würde es nennen, was Sie wollen. Der einzige Unterschied hier von new EventEmitter() ist, dass Sie this auf eine Instanz Ihres abgeleiteten Objekts zeigen, nicht nur auf ein EventEmitter Objekt.

In allen Fällen der Vererbung sollten Sie den Basisklassenkonstruktor aufrufen, damit er sich richtig initialisieren kann. Aber, es kann einige Arten von Objekten geben, die im Konstruktor nicht wirklich viel tun, also kann es passieren, dass Dinge funktionieren, wenn Sie es weglassen. Oder sie scheinen einfach zu funktionieren, aber es wird Probleme auf der Straße geben.

---

Hinzufügen oder Entfernen von EventEmitter.call (dies) in meinem Knoten Beispiel ist keinen Unterschied machen, warum?

Wenn man sich die EventEmitter code on Github anschaut, kann man sehen, dass der EventEmitter Konstruktor tut dies:

function EventEmitter() { 
    EventEmitter.init.call(this); 
} 

Und die .init() Methode tut dies:

EventEmitter.init = function() { 
    this.domain = null; 
    if (EventEmitter.usingDomains) { 
    // if there is an active domain, then attach to it. 
    domain = domain || require('domain'); 
    if (domain.active && !(this instanceof domain.Domain)) { 
     this.domain = domain.active; 
    } 
    } 

    if (!this._events || this._events === Object.getPrototypeOf(this)._events) { 
    this._events = {}; 
    this._eventsCount = 0; 
    } 

    this._maxListeners = this._maxListeners || undefined; 
}; 

Also, wenn Sie scheitern Um den übergeordneten Konstruktor aufzurufen, werden im EventEmitter-Objekt mehrere Instanzvariablen vorhanden sein, die nicht ordnungsgemäß initialisiert werden. Was das mit dem Code macht, ist eine Vermutung (es würde weitere Code-Studien und Tests erfordern, um es sicher zu wissen), aber es ist keine gute Sache. Einige Funktionen funktionieren möglicherweise ohne diese Initialisierung, aber es ist sehr wahrscheinlich, dass andere Dinge nicht ordnungsgemäß funktionieren.