Estou tentando obter uma lista de todos os soquetes / clientes que estão conectados no momento.

io.sockets infelizmente não retorna uma matriz.

Sei que poderia manter minha própria lista usando uma matriz, mas não acho que essa seja uma solução ideal por 2 motivos:

1. Redundância. O Socket.IO já mantém uma cópia desta lista.

2. O Socket.IO fornece um método para definir valores de campo arbitrários para clientes (ou seja:), socket.set('nickname', 'superman')para que eu precise acompanhar essas alterações se quiser manter minha própria lista.

Socorro?

No Socket.IO 0.7, você tem um clientsmétodo nos espaços para nome, isso retorna uma matriz de todos os soquetes conectados.

API para nenhum espaço de nome:

var clients = io.sockets.clients();
var clients = io.sockets.clients('room'); // all users from room `room`

Para um espaço para nome

var clients = io.of('/chat').clients();
var clients = io.of('/chat').clients('room'); // all users from room `room`

Espera que isso ajude alguém no futuro

NOTA: Esta solução só funciona com a versão anterior à 1.0

ATUALIZAÇÃO 2020 Mar 06

A partir da 1.xe acima, consulte este link: obter quantas pessoas estão em uma sala de bate-papo no socket.io

Socket.io 1.4

Object.keys(io.sockets.sockets); fornece todos os soquetes conectados.

Socket.io 1.0 A partir do socket.io 1.0, a resposta realmente aceita não é mais válida. Então, eu criei uma pequena função que eu uso como uma correção temporária:

function findClientsSocket(roomId, namespace) {
    var res = []
    // the default namespace is "/"
    , ns = io.of(namespace ||"/");

    if (ns) {
        for (var id in ns.connected) {
            if(roomId) {
                var index = ns.connected[id].rooms.indexOf(roomId);
                if(index !== -1) {
                    res.push(ns.connected[id]);
                }
            } else {
                res.push(ns.connected[id]);
            }
        }
    }
    return res;
}

A API para No namespace se torna

// var clients = io.sockets.clients();
// becomes : 
var clients = findClientsSocket();

// var clients = io.sockets.clients('room');
// all users from room `room`
// becomes
var clients = findClientsSocket('room');

A API para um espaço de nome se torna:

// var clients = io.of('/chat').clients();
// becomes
var clients = findClientsSocket(null, '/chat');

// var clients = io.of('/chat').clients('room');
// all users from room `room`
// becomes
var clients = findClientsSocket('room', '/chat');

Veja também esta questão relacionada , na qual dou uma função que retorna os soquetes para uma determinada sala.

function findClientsSocketByRoomId(roomId) {
var res = []
, room = io.sockets.adapter.rooms[roomId];
if (room) {
    for (var id in room) {
    res.push(io.sockets.adapter.nsp.connected[id]);
    }
}
return res;
}

Socket.io 0.7

API para nenhum espaço de nome :

var clients = io.sockets.clients();
var clients = io.sockets.clients('room'); // all users from room `room`

Para um espaço para nome

var clients = io.of('/chat').clients();
var clients = io.of('/chat').clients('room'); // all users from room `room`

Nota: Como parece que a API socket.io está sujeita a falhas, e algumas soluções dependem de detalhes de implementação, pode ser uma questão de rastrear os clientes:

var clients = [];

io.sockets.on('connect', function(client) {
    clients.push(client); 

    client.on('disconnect', function() {
        clients.splice(clients.indexOf(client), 1);
    });
});

Após o socket.io 1.0, não podemos usar

io.sockets.clients(); 
or
io.sockets.clients('room'); 

não mais. Em vez disso, você pode usar o seguinte

var clients_in_the_room = io.sockets.adapter.rooms[roomId]; 
for (var clientId in clients_in_the_room ) {
  console.log('client: %s', clientId); //Seeing is believing 
  var client_socket = io.sockets.connected[clientId];//Do whatever you want with this
}

Usando o Socket.IO 1.x:

Obtenha a matriz dos clientes conectados:

io.engine === io.eio // => true
Object.keys(io.engine.clients) // => [ 'US8AxrUrrDF_G7ZUAAAA', 'Ov2Ca24Olkhf2NHbAAAB' ]
Object.keys(io.eio.clients)    // => [ 'US8AxrUrrDF_G7ZUAAAA', 'Ov2Ca24Olkhf2NHbAAAB' ]

Obtenha o número de clientes conectados:

io.engine.clientsCount // => 2
io.eio.clientsCount    // => 2

Muito simples no socket.io 1.3:

io.sockets.sockets- é uma matriz que contém os objetos de soquete conectados. Se você armazenou o nome de usuário em cada soquete, poderá:

io.sockets.sockets.map(function(e) {
    return e.username;
})

Estrondo. Você tem os nomes de todos os usuários conectados.

Eu passei por essa dor hoje. O Socket.io será muito melhor se eles puderem criar uma documentação adequada para sua API.

Enfim, tentei examinar o io.sockets e encontrei várias opções que podemos usar:

io.sockets.connected //Return {socket_1_id: {}, socket_2_id: {}} . This is the most convenient one, since you can just refer to io.sockets.connected[id] then do common things like emit()
io.sockets.sockets //Returns [{socket_1}, {socket_2}, ....]. Can refer to socket_i.id to distinguish
io.sockets.adapter.sids //Return {socket_1_id: {}, socket_2_id: {}} . Looks similar to the first one but the object is not actually the socket, just the information.

// Not directly helps but still relevant
io.sockets.adapter.rooms //Returns {room_1_id: {}, room_2_id: {}}
io.sockets.server.eio.clients //Return client sockets
io.sockets.server.eio.clientsCount //Return number of connected clients

Além disso, observe que, ao usar o socket.io com espaço para nome, os métodos acima serão interrompidos, pois io.sockets se torna uma matriz em vez de um objeto. Para resolver, basta substituir io.sockets por io (ou seja, io.sockets.connected se torna io.connected, io.sockets.adapter.rooms se torna io.adapter.rooms ...)

Testado em socket.io 1.3.5

Versão +2.0

Na versão +2.0, você especifica o espaço para nome / sala / nó no qual está consultando.

Como na transmissão, o padrão são todos os clientes do espaço para nome padrão ('/'):

const io = require('socket.io')();  
io.clients((error, clients) => {
      if (error) throw error;
      console.log(clients); // => [6em3d4TJP8Et9EMNAAAA, G5p55dHhGgUnLUctAAAB]
});

Obtém uma lista de IDs de clientes conectados a um namespace específico (em todos os nós, se aplicável).

const io = require('socket.io')();
io.of('/chat').clients((error, clients) => {
     if (error) throw error;
     console.log(clients); // => [PZDoMHjiu8PYfRiKAAAF, Anw2LatarvGVVXEIAAAD]
});

Um exemplo para obter todos os clientes na sala de namespace:

const io = require('socket.io')();
io.of('/chat').in('general').clients((error, clients) => {
      if (error) throw error;
      console.log(clients); // => [Anw2LatarvGVVXEIAAAD] 
});

Isto é da documentação oficial: Socket.IO Server-API

Acho que podemos acessar o objeto de soquete do servidor, e você pode atribuir o apelido e apontar seu ID de soquete,

io.sockets.on('connection',function(socket){ 
    io.sockets.sockets['nickname'] = socket.id;
    client.on("chat", function(data) {      
        var sock_id = io.sockets.sockets['nickname']
        io.sockets.sockets[sock_id].emit("private", "message");
    });    
});

Em disconnect, remova o apelido de io.sockets.sockets.

Esta é a melhor maneira de acessá-lo no socket.io 1.3

Object.keys(socket.adapter.rooms[room_id])

Para qualquer pessoa que queira apenas uma CONTAGEM de clientes conectados, acredito que isso será possível:

io.sockets.manager.server.connections

Socket.io 1.4.4

Código de exemplo para você.

function get_clients_by_room(roomId, namespace) {
        io.of(namespace || "/").in(roomId).clients(function (error, clients) {
            if (error) { throw error; }
            console.log(clients[0]); // => [Anw2LatarvGVVXEIAAAD]
            console.log(io.sockets.sockets[clients[0]]); //socket detail
            return clients;
        });
    }

Eu acho que vai ajudar alguém nesse bloco de código.

No Socket.IO 1.4

Para obter a matriz de Todos os usuários conectados:

var allConnectedClients = Object.keys(io.sockets.connected);// This will return the array of SockeId of all the connected clients

Para obter a contagem de todos os clientes:

var clientsCount = io.engine.clientsCount ; // This will return the count of connected clients

No socket.io 1.5, observe a alteração de indexOf que parece depreciada e substituída por valueOf

function findClientsSocket(roomId, namespace) {
    var res = [];
    var ns = io.of(namespace ||"/");    // the default namespace is "/"

    if (ns) {
        for (var id in ns.connected) {
            if (roomId) {
                //var index = ns.connected[id].rooms.indexOf(roomId) ;
                var index = ns.connected[id].rooms.valueOf(roomId) ; //Problem was here

                if(index !== -1) {
                    res.push(ns.connected[id]);
                }
            } else {
                res.push(ns.connected[id]);
            }
        }
    }
    return res.length;
}

Para socket.io versão 2.0.3, o seguinte código funciona:

function findClientsSocket(io, roomId, namespace) {
    var res = [],
        ns = io.of(namespace ||"/");    // the default namespace is "/"

    if (ns) {
        for (var id in ns.connected) {
            if(roomId) {
                // ns.connected[id].rooms is an object!
                var rooms = Object.values(ns.connected[id].rooms);  
                var index = rooms.indexOf(roomId);
                if(index !== -1) {
                    res.push(ns.connected[id]);
                }
            }
            else {
                res.push(ns.connected[id]);
            }
        }
    }
    return res;
}

no socket.io 1.3 eu consegui isso em 2 linhas

var usersSocketIds = Object.keys(chat.adapter.rooms['room name']);
var usersAttending = _.map(usersSocketIds, function(socketClientId){ return chat.connected[socketClientId] })

Socket.io 1.7.3 (+):

função getConnectedList ()
{
    deixe lista = []
    
    for (deixe o cliente em io.sockets.connected)
    {
        list.push (cliente)
    }
    
    lista de retorno
}

console.log (getConnectedList ())

// retorna ['yIfhb2tw7mxgrnF6AAAA', 'qABFaNDSYknCysbgAAAB']

Para a versão 2.3, isso funciona e você também recebe o soquete , parece-me que o socketIo está mudando muito rápido e muito com pouca documentação legível depois de usá-lo por um tempo.

ioSite.of('/').in(roomId).clients((error, clients) => {
    if (error) throw error;
    for (var i=0;i<clients.length;i++) {
        clientId=clients[i];
        console.log(clientId);

        // load the socket of your namespace
        var socket=ioSite.of('/').in(roomId).connected[clientId]
        console.log(socket.constructor.name);
        console.log(socket.id);
    }
});

ainda assim isso não parece certo, pois sempre tenho esse sentimento com o soquete Io

Eu acredito que você pode acessar isso a partir da propriedade do gerenciador do soquete?

var handshaken = io.manager.handshaken;
var connected = io.manager.connected;
var open = io.manager.open;
var closed = io.manager.closed;

Eu vejo muitas respostas boas aqui e muitas onde são úteis, mas não exatamente o que eu precisava. Estou usando soquetes para um recurso de pubsub no qual um cliente interessado pode ouvir as alterações em um determinado registro.

Meu problema específico era que o mesmo soquete estava entrando na mesma sala várias vezes. A solução para isso foi verificar se o soquete já tinha o quarto dentro da propriedade de seus quartos.

var room = myObj.id.toString();
if (socket.rooms.indexOf(room) === -1) {
    socket.join(room);
    socket.emit('subscribed', {to : room});
} else {
    console.log("Already in room");
}

Espero que isso ajude alguém.

Essa é a maneira mais simples do Socket.IO 1.0+, se você não estiver usando espaços ou espaços para nome.

io.nsps["/"].sockets.length

Isso examina o espaço para nome padrão e determina o comprimento da matriz de soquetes, sem a necessidade de usar Object.keys()

A partir da versão 1.5.1, eu posso acessar todos os soquetes em um espaço para nome com:

var socket_ids = Object.keys(io.of('/namespace').sockets);
socket_ids.forEach(function(socket_id) {
    var socket = io.of('/namespace').sockets[socket_id];
    if (socket.connected) {
        // Do something...
    }
});

Por alguma razão, eles estão usando um objeto simples em vez de uma matriz para armazenar os IDs de soquete.

Para o modo de cluster, usando o adaptador redis

io.in(<room>).clients(function(err, clients) {

});

Como cada soquete é uma sala, é possível descobrir se existe um soquete usando o mesmo.

Aqui está uma maneira rápida de converter o hash de soquetes conectados de um espaço para nome em uma matriz usando geradores ES6 (aplica-se a socket.io> = v1.0.0):

io.on('connection', function(socket) {
  var hash = io.of('/').connected
  var list = null

  hash[Symbol.iterator] = function*() {
    // for..of loop to invoke Object.keys() default iterator
    // to get the array values instead of the keys
    for(var id of Object.keys(hash)) yield hash[id]
  }

  list = [...hash]
  console.log(Array.isArray(list)) // true
})

Não sei se isso ainda está acontecendo. Mas algo assim foi o que acabei usando (mantenho um objeto de sessão em cada soquete conectado, que por sua vez contém o nome de usuário e outras informações:

var connectedUsers = Object.keys(io.sockets.connected).map(function(socketId) {
    return io.sockets.connected[socketId].session.username;
});

Se o projeto tiver um cluster socket.io, isso significa que o adaptador socket.io-redis está sendo usado.

Se o caso for o anterior, é necessário aplicar o processo de identificação de todos os soquetes conectados por meio do adaptador socket.io-redis . Os exemplos abaixo podem ser usados ​​para isso;

io.of('/').adapter.clients(function (err, clients) {
  console.log("clients: ", clients); // an array containing all connected socket ids
});


io.of('/').adapter.allRooms(function (err, rooms) {
  console.log("all rooms: ", rooms);
});

Visite a página do socket.io-redis no github para obter mais detalhes.

[email protected]

Eu usei Object.Keys para obter a matriz do soquete conectada. Na mesma matriz, itere a função map para criar uma nova matriz de objetos

var connectedUsers = Object.keys(io.sockets.connected).map(function(socketId) {
    return { socket_id : socketId, socket_username: io.sockets.connected[socketId].username };
});

// test
console.log(connectedUsers);

Talvez esta resposta possa ajudar a obter o array socket id / username.

v.10

var clients = io.nsps['/'].adapter.rooms['vse'];
/* 
'clients' will return something like:
Room {
sockets: { '3kiMNO8xwKMOtj3zAAAC': true, FUgvilj2VoJWB196AAAD: true },
length: 2 }
*/
var count = clients.length;  // 2
var sockets = clients.map((item)=>{  // all sockets room 'vse'
       return io.sockets.sockets[item];
      });
sample >>>
var handshake  = sockets[i].handshake; 
handshake.address  .time .issued ... etc.