Javascript socket.io发射三次

首先，我会说我在这个网站上发现了几个类似的问题。但这些都不适用于我的情况

我有一个服务器和客户机（node.js/socket.io的标准配置）并在按下按钮时调用发出套接字事件。这个很好用。。。除了它似乎发出三次（至少服务器运行该函数三次）。在这一点上，我盯着代码看了太久，需要另一双眼睛

希望有人有主意

客户端代码：

importJS('/js/pages/admin_base.js',function(){
    var restartLMC = function(io){
        toggleLoad();
        var user = localStorage.getItem('User');
        io.emit('restart_request',{session: user});
    };
    AdminIO = new io('http://localhost:26266');
    AdminIO.on('restart_success',function(dat){
        toggleLoad();
        dropInfo(dat);
    });
    AdminIO.on('sendError',function(dat){
        dropInfo(dat,{level: 'error'});
    });
    AdminIO.on('restart_fail',function(dat){
        toggleLoad();
        dropInfo(dat,{level: 'error'});
    });
    $('#restart').on('click',function(){
        restartLMC(AdminIO);
    });
});

管理代码：

process.stdout.write('\033c');
console.log('\x1b[36m', "Admin server starting...", '\x1b[0m');
var 
    ini = require('node-ini')
    , conf = ini.parseSync('../config.ini')
    , CS = require('../lm_modules/CoreSync.js')
    , CoreSync = new CS()
    , checkSession = function (session, callback) {
            var res;
            if (!CoreSync) { throw "Fatal error, there is no connection to the Core service!"; }
            if (CoreSync.sessions) {
                if (CoreSync.sessions[session]) {
                    res = CoreSync.sessions[session];
                    callback(res);
                }
                else {
                    CoreSync.sync('session', function (err, dat) {
                        if (CoreSync.sessions[session]) {
                            res = CoreSync.sessions[session];
                            callback(res);
                        } else { res = false; callback(res); }
                    });
                }
            } else {
                res = false; callback(res);
            }
            if (res === "undefined") { callback(false); }
        }
    , runCMD = function(cmd,errCB,callback){
        var
            command
            , args;
        if(cmd.cmd){ command = cmd.cmd; } else { command = cmd; }
        if(cmd.args){ args = cmd.args; }
        const spawn = require('child_process').spawn;        
        const ex = spawn(command, args);
        ex.stdout.on('data', (data) => {
            callback(data);
        });
        ex.stderr.on('data', (data) => {
            errCB(data);
        });
        ex.on('close', (code) => {

        });
    }    
    , executeCMD = function(cmd,callback){
        const exec = require('child_process').exec
              , cdw = (__dirname + '/../');
        exec(cmd, {cwd: cdw}, (err, stdout, stderr) => {
            if (err) {
                callback(err,null);
                return;
            }
            callback(stderr,stdout);
        });
    }    
    , io = require('socket.io').listen(26266) // can use up to 26485

console.log('\x1b[32m', "Admin server started.", '\x1b[0m');
console.log("Admin server listening at " + "http://" + conf["Server"]["binding"] + ":26266");
io.on('connection', function (socket) {   
    socket.on('restart_request', function(req){
        console.log('Recieved restart request');       
        var success = false
            , session = JSON.parse(req.session)
            , sessionID = session.sessionID;
        checkSession(sessionID, function (ses) {
            if (ses === false) { console.error('CheckSession failed: No session exists'); return; }
            if (ses.user.uuid !== session.uuid) { console.error('CheckSession failed: UUID mismatched'); return; }
            if (ses.user.role < conf['Permissions']['lm_restart']){ socket.emit('restart_fail','Insufficient permissions.'); return; }
            if(process.platform === 'win32'){            
                executeCMD('cd',function(err,res){
                    var errSent = false;
                    if(err){                        
                        console.error(err);
                        if(!errSent){ socket.emit('sendError','Restart failed'); }
                        errSent = true;
                        if(res === null){return;}
                    }
                    console.log(res);
                    socket.emit('restart_success','LM successfully restarted.');
                });                
            }
            else if(process.platform === 'linux'){

            }
        });
    });
});

process.stdout.write（'\033c'）；
log（'\x1b[36m'，“管理服务器正在启动…”，'\x1b[0m'）；
变量
ini=require（'node-ini'）
，conf=ini.parseSync（“../config.ini”）
，CS=require（“../lm_modules/CoreSync.js”）
，CoreSync=new CS（）
，checkSession=函数（会话，回调）{
var-res；
如果（！CoreSync）{throw“致命错误，没有到核心服务的连接！”；}
if（CoreSync.sessions）{
if（CoreSync.sessions[会话]）{
res=CoreSync.sessions[session]；
回收（res）；
}
否则{
CoreSync.sync（'session'，函数（err，dat）{
if（CoreSync.sessions[会话]）{
res=CoreSync.sessions[session]；
回收（res）；
}else{res=false；回调（res）；}
});
}
}否则{
res=false；回调（res）；
}
如果（res==“未定义”）{callback（false）；}
}
，runCMD=function（cmd，errCB，回调）{
变量
命令
，args；
if（cmd.cmd）{command=cmd.cmd；}else{command=cmd；}
如果（cmd.args）{args=cmd.args；}
const spawn=require（'child_process'）。spawn；
const ex=spawn（命令，args）；
例如stdout.on（'data'，（data）=>{
回调（数据）；
});
例如，在（'data'，（data）=>{
errCB（数据）；
});
例如，on（'关闭'，（代码）=>{
});
}    
，executeCMD=函数（cmd，回调）{
const exec=require（'child_process'）。exec
，cdw=（uu dirname+'/../'）；
exec（cmd，{cwd:cdw}，（err，stdout，stderr）=>{
如果（错误）{
回调（err，null）；
返回；
}
回调（stderr、stdout）；
});
}    
，io=require（'socket.io'）。listen（26266）//最多可使用26485
log（'\x1b[32m'，“管理服务器已启动”。，'\x1b[0m'）；
log（“在“+”http://“+conf[“server”][“binding”]+”：26266上侦听的管理服务器”）；
io.on（'连接'，函数（套接字）{
socket.on（'restart_request'，函数（req）{
log（'收到重新启动请求'）；
var成功=错误
，session=JSON.parse（req.session）
，sessionID=session.sessionID；
检查会话（会话ID，函数（ses）{
if（ses==false）{console.error（'CheckSession失败：不存在会话'）；return；}
if（ses.user.uuid！==session.uuid）{console.error（'CheckSession失败：uuid不匹配'）；return；}
if（ses.user.role

对于那些可能已经看到这一点并发现这是一个奇怪的问题/情况的人来说……我找到了这一点的两个部分

第一部分是绑定时的$（）。出于某种原因（即使在js代码中它并没有多次调用），在绑定前添加unbind（）部分解决了问题…它将额外的发射从3减少到了2（直到我启动另一个服务器应用程序，然后又返回到3…）

我发现的另一部分是（出于某种原因）socket.io连接被复制的次数与socket服务器运行的次数一样多。有关此问题的更多详细信息…我相信，一旦找到原因，我的问题就会得到解决