Javascript RemovelListener删除在'；这'；听众

我有一个socket.io服务器，在每个socket.io连接中都有一个自定义方法“looper.output”。每当我关闭socket.io连接时，我都会启动另一个自定义方法“looper.disconnect”，该方法将删除关闭的客户端的“output”侦听器。我的问题是，每当客户端关闭时，looper.disconnect不仅会从该客户端删除侦听器，还会从关闭客户端后启动的每个客户端删除侦听器

例如，如果我有4个客户端A、B、C和D，它们也按顺序连接到服务器，并且客户端C关闭；looper.disconnect将删除C和D的侦听器，但保留A和B

要使looper.disconnect仅删除调用它的客户端的侦听器，我需要更改什么？在上面的示例中，我只希望删除客户端C的侦听器

var express = require('express');
var http = require('http');
var spawn = require('child_process').spawn;
var util = require('util');
var fs = require('fs');
var EventEmitter = require('events').EventEmitter;
var sys = require('sys');

var app     = express(),
    server  = http.createServer(app),
    io      = require('socket.io').listen(server);

function Looper(req)  {
    this.req = req;
    EventEmitter.call(this);
}
sys.inherits(Looper, EventEmitter);

Looper.prototype.run = function() {
    var self = this;
    var cmd = spawn('./flow',[this.req]); // <-- script that outputs req every second
    cmd.stdout.setEncoding('utf8');
    cmd.stdout.on('data', function(data) {
        self.emit('output',data);
    });
}

Looper.prototype.output = function(callback) {
    this.output.outCallback = function(mydata) {
        return callback(mydata.trim());
    }
    this.on('output', this.output.outCallback);
}

Looper.prototype.disconnect = function() {
    this.removeListener('output',this.output.outCallback);
}

var looper = new Looper('blah');
looper.run();

app.use(express.static(__dirname + '/public'));

app.get('/', function(req, res) {
    res.send(
        "<script src='/socket.io/socket.io.js'></script>\n"+
        "<script>\n"+
        "\tvar socket=io.connect('http://127.0.0.1:3000');\n"+
        "\tsocket.on('stream', function(data) {\n"+
        "\t\tconsole.log(data);\n"+
        "\t});\n"+
        "</script>\n"
    );
});
server.listen(3000);

io.sockets.on('connection', function(webSocket) {
    looper.output(function(res) {
        webSocket.emit('stream',res+":"+webSocket.id);
    });

    webSocket.on('disconnect', function() {
        looper.disconnect();
    });
});

var express=require（'express'）；
var http=require（'http'）；
var spawn=require（'child_process'）。spawn；
var util=require（'util'）；
var fs=需要（'fs'）；
var EventEmitter=require（'events'）。EventEmitter；
var sys=需要（'sys'）；
var app=express（），
服务器=http.createServer（应用程序），
io=require（'socket.io'）。侦听（服务器）；
功能活套（req）{
this.req=req；
EventEmitter.call（this）；
}
sys.inherits（Looper、EventEmitter）；
Looper.prototype.run=函数（）{
var self=这个；
var cmd=spawn（'./flow'，[this.req]）；//您可以让侦听器始终处于打开状态，并在侦听器函数中向添加到looper对象的所有回调发送数据

每个客户端的回调都由会话id标识

var express = require('express');
var http = require('http');
var spawn = require('child_process').spawn;
var util = require('util');
var fs = require('fs');
var EventEmitter = require('events').EventEmitter;
var sys = require('sys');

var app     = express(),
    server  = http.createServer(app),
    io      = require('socket.io').listen(server);

function Looper(req)  {
    this.req = req;
    Looper.prototype.outCallbacks = {};
    EventEmitter.call(this);
}
sys.inherits(Looper, EventEmitter);

Looper.prototype.callAllCallbacks = function(data) {
    for (var callback in this.outCallbacks) {
    if (this.outCallbacks.hasOwnProperty(callback)) {
        this.outCallbacks[callback](data);
    }
    }
}

Looper.prototype.run = function() {
    var self = this;
    var cmd = spawn('./flow',[this.req]); // <-- script that outputs req every second
    cmd.stdout.setEncoding('utf8');
    cmd.stdout.on('data', function(data) {
    self.emit('output',data);
    });

    this.on('output', this.callAllCallbacks);
}

Looper.prototype.addCallback = function(session_id, callback) {
    this.outCallbacks[session_id] = function(mydata) {
    return callback(mydata.trim());
    }
}

Looper.prototype.disconnect = function(session_id) {
    delete this.outCallbacks[session_id];
}

var looper = new Looper('blah');
looper.run();

app.use(express.static(__dirname + '/public'));

app.get('/', function(req, res) {
    res.send(
        "<script src='/socket.io/socket.io.js'></script>\n"+
        "<script>\n"+
        "\tvar socket=io.connect('http://127.0.0.1:3000');\n"+
        "\tsocket.on('stream', function(data) {\n"+
        "\t\tconsole.log(data);\n"+
        "\t});\n"+
        "</script>\n"
    );
});
server.listen(3000);

io.sockets.on('connection', function(webSocket) {
    var session_id = webSocket.id;

    looper.addCallback(session_id, function(res) {
    webSocket.emit('stream',res+":"+webSocket.id);
    });

    webSocket.on('disconnect', function() {
    looper.disconnect(session_id);
    });
});

var express=require（'express'）；
var http=require（'http'）；
var spawn=require（'child_process'）。spawn；
var util=require（'util'）；
var fs=需要（'fs'）；
var EventEmitter=require（'events'）。EventEmitter；
var sys=需要（'sys'）；
var app=express（），
服务器=http.createServer（应用程序），
io=require（'socket.io'）。侦听（服务器）；
功能活套（req）{
this.req=req；
Looper.prototype.outCallbacks={}；
EventEmitter.call（this）；
}
sys.inherits（Looper、EventEmitter）；
Looper.prototype.callAllCallbacks=函数（数据）{
for（此.outCallbacks中的var回调）{
if（this.outCallbacks.hasOwnProperty（回调））{
this.outCallbacks[callback]（数据）；
}
}
}
Looper.prototype.run=函数（）{
var self=这个；
var cmd=spawn（'./flow'，[this.req]）；//我真的不明白它为什么会以这种方式失败，但您的主要问题是您正在将所有函数的引用保存在同一个位置

另一个选项是为每个客户端提供回调函数引用，如下所示：

var express = require('express');
var http = require('http');
var spawn = require('child_process').spawn;
var util = require('util');
var fs = require('fs');
var EventEmitter = require('events').EventEmitter;
var sys = require('sys');

var app     = express(),
    server  = http.createServer(app),
    io      = require('socket.io').listen(server);

function Looper(req)  {
    this.req = req;
    EventEmitter.call(this);
}
sys.inherits(Looper, EventEmitter);

Looper.prototype.run = function() {
    var self = this;
    var cmd = spawn('./flow',[this.req]); // <-- script that outputs req every second
    cmd.stdout.setEncoding('utf8');
    cmd.stdout.on('data', function(data) {
        self.emit('output',data);
    });
}

Looper.prototype.output = function(callback) {
    this.on('output', callback);
}

Looper.prototype.disconnect = function(callback) {
    this.removeListener('output', callback);
}

var looper = new Looper('blah');
looper.run();

app.use(express.static(__dirname + '/public'));

app.get('/', function(req, res) {
    res.send(
        "<script src='/socket.io/socket.io.js'></script>\n"+
        "<script>\n"+
        "\tvar socket=io.connect('http://127.0.0.1:3000');\n"+
        "\tsocket.on('stream', function(data) {\n"+
        "\t\tconsole.log(data);\n"+
        "\t});\n"+
        "</script>\n"
    );
});
server.listen(3000);

io.sockets.on('connection', function(webSocket) {
    var callback = function(res) {
        webSocket.emit('stream',res.trim()+":"+webSocket.id);
    }

    looper.output(callback);

    webSocket.on('disconnect', function() {
        looper.disconnect(callback);
    });
});

var express=require（'express'）；
var http=require（'http'）；
var spawn=require（'child_process'）。spawn；
var util=require（'util'）；
var fs=需要（'fs'）；
var EventEmitter=require（'events'）。EventEmitter；
var sys=需要（'sys'）；
var app=express（），
服务器=http.createServer（应用程序），
io=require（'socket.io'）。侦听（服务器）；
功能活套（req）{
this.req=req；
EventEmitter.call（this）；
}
sys.inherits（Looper、EventEmitter）；
Looper.prototype.run=函数（）{
var self=这个；
var cmd=spawn（'./flow'，[this.req]）；//谢谢你的建议，我检查了你的代码并对其进行了更新以使其正常工作。这会起作用，但是否有可能完成我在原始问题中试图做的事情？这似乎更像是解决问题的一种方法，而不是一个答案。另一个可靠的答案。这一个答案更符合原始问题的方式我仍然想知道为什么原始代码不能正常工作。谢谢你的帮助。