Node.js Socket.io连续向每个客户端发送请求的数据

代码如下：

客户端

var server = "localhost";
var socket = io('http://' + serve + ':4005');
socket.on('connect',function(){ 
socket.emit('send', {type:"<?php echo $datatype?>"}); //{type:"3,2"}
  });

var server=“localhost”；
var socket=io（'http://'+service+'：4005'）；
socket.on（'connect'，function（）{
emit（'send'，{type:}）；//{type:'3,2}
});

以下是我的节点js服务器的代码：

服务器

io.on('connection', function(client) {

    console.log('Client connected...');

    client.on('join', function(data) {
        console.log(data);
    });
    client.on('send',function(data){
        var datafinal = [];

        setInterval(function () {
        var usertype = data.type;
        var types = usertype.split(',');
            for (var i = 0; i < types.length; i++){
                datafinal.push(apifinaldata.filter((inbound) => inbound.usertype == types[i] && inbound.active == 1 ));
                }
                var final = datafinal.reduce(function(a, b) {
                    return a.concat(b);
                }, []);

                datafinal = [];

            io.emit('finaldata', final); io.emit('callwaiting', callsdatafinal);
        }, 1000);
    })


});

server.listen(4005);

io.on（'connection'，函数（客户端）{
log（'Client connected…'）；
client.on（'join'，函数（数据）{
控制台日志（数据）；
});
client.on（'send'，函数（数据）{
var datafinal=[]；
setInterval（函数（）{
var usertype=data.type；
var types=usertype.split（'，'）；
对于（变量i=0；iinbound.usertype==types[i]&inbound.active==1））；
}
var final=datafinal.reduce（函数（a，b）{
返回a.concat（b）；
}, []);
datafinal=[]；
io.emit（'finaldata'，final）；io.emit（'callwaiting'，callsdatafinal）；
}, 1000);
})
});
监听（4005）；

当我启动服务器时，它从客户机a收到一个请求，请求的数据类型是它想要的（例如

{type:“3,2”}

。因此服务器只向客户机发送特定的数据。但是当另一个客户机说B要求服务器发送

{type:“1”}的数据时

，在这种情况下，服务器会向客户端A和B分别发送正确的数据，但客户端不会连续接收数据。服务器会持续发送数据，但有时会向A和B发送数据。我希望服务器向每个连接的客户端连续发送请求的数据

另外，如果我将io.emit（'finaldata'，final）；io.emit（'callwaiting'，callsdatafinal）；更改为client.emit（'finaldata'，final）；client.emit（'callwaiting'，callsdatafinal）；它不会向任何客户端发送任何数据

因此，我需要一个解决方案，使服务器只向每个客户机连续发送每个客户机请求的特定数据

---

如何才能做到这一点？

为此，您必须跟踪客户端A和B，然后仅向特定客户端发送数据，下面是示例代码

var clientA;
var clientB;
io.on('connection', function(client) {
    console.log('Client connected...');

    client.on('join', function(data) {
        if (something){
          clientA = client;
        }
        else {
          clientB = client;
        }
        console.log(data);
    });
    client.on('send',function(data){
        var datafinal = [];

        setInterval(function () {
        var usertype = data.type;
        var types = usertype.split(',');
            for (var i = 0; i < types.length; i++){
                datafinal.push(apifinaldata.filter((inbound) => inbound.usertype == types[i] && inbound.active == 1 ));
                }
                var final = datafinal.reduce(function(a, b) {
                    return a.concat(b);
                }, []);

                datafinal = [];

            if(someCondition){
              clientA.emit('finaldata', final);
              clientA.emit('callwaiting', callsdatafinal);
            }
            else {
              clientB.emit('finaldata', final);
              clientB.emit('callwaiting', callsdatafinal);
            }
        }, 1000);
    })
});

var-clientA；
var-clientB；
io.on（'连接'，功能（客户端）{
log（'Client connected…'）；
client.on（'join'，函数（数据）{
如果（某物）{
clientA=客户；
}
否则{
clientB=客户；
}
控制台日志（数据）；
});
client.on（'send'，函数（数据）{
var datafinal=[]；
setInterval（函数（）{
var usertype=data.type；
var types=usertype.split（'，'）；
对于（变量i=0；iinbound.usertype==types[i]&inbound.active==1））；
}
var final=datafinal.reduce（函数（a，b）{
返回a.concat（b）；
}, []);
datafinal=[]；
如果（某些条件）{
clientA.emit（'finaldata'，final）；
clientA.emit（'callwaiting'，callsdatafinal）；
}
否则{
clientB.emit（'finaldata'，final）；
clientB.emit（'callwaiting'，callsdatafinal）；
}
}, 1000);
})
});

clientA和clientB是两个连接的客户端，您可以根据条件或程序逻辑向任何客户端发送数据