В Socket.IO 0.7 у вас есть метод clients в пространствах имен, он возвращает массив всех подключенных сокетов.

API без пространства имен:

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

Для пространства имен

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

Надеюсь, это поможет кому-то в будущем

ПРИМЕЧАНИЕ. Это решение ТОЛЬКО работает с версией до 1.0.

ОБНОВЛЕНО 6 марта 2020 г.

Начиная с версии 1.x и выше, перейдите по этой ссылке: узнать, сколько человек участвует в чате в socket.io

Socket.io 1.4

Object.keys(io.sockets.sockets); дает вам все подключенные сокеты.

Socket.io 1.0 Начиная с socket.io 1.0, фактически принятый ответ больше не действителен. Поэтому я сделал небольшую функцию, которую использую как временное исправление:

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;
}

Api для без пространства имен становится

// 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');

Api для пространства имен становится:

// 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');

Также см. Этот связанный с этим вопрос, в котором я даю функцию, которая возвращает сокеты для данной комнаты.

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 для без пространства имен:

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

Для пространства имен

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

Примечание. Поскольку кажется, что API socket.io склонен к сбоям, а некоторые решения зависят от деталей реализации, это может быть связано с отслеживанием клиентов самостоятельно:

var clients = [];

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

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

После socket.io 1.0 мы не можем использовать

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

больше. Вместо этого вы можете использовать следующие

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
}

Использование Socket.IO 1.x:

Получите массив подключенных клиентов:

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

Получите количество подключенных клиентов:

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

Очень просто в socket.io 1.3:

io.sockets.sockets - массив, содержащий объекты подключенных сокетов. Если вы сохранили имя пользователя в каждом сокете, вы можете:

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

Бум. У вас есть имена всех подключенных пользователей.

Сегодня я пережил эту боль. Socket.io было бы намного лучше, если бы они могли составить надлежащую документацию для своего API.

В любом случае, я попытался заглянуть в io.sockets и нашел несколько вариантов, которые мы можем использовать:

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

Также обратите внимание, что при использовании socket.io с пространством имен вышеперечисленные методы не работают, поскольку io.sockets становится массивом, а не объектом. Чтобы решить эту проблему, просто замените io.sockets на io (т.е. io.sockets.connected становится io.connected, io.sockets.adapter.rooms становится io.adapter.rooms ...)

Проверено на socket.io 1.3.5

Версия +2.0

В версии +2.0 вы указываете пространство имен / комнату / узел, к которому вы запрашиваете.

Как и в случае трансляции, по умолчанию используются все клиенты из пространства имен по умолчанию ('/'):

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

Получает список идентификаторов клиентов, подключенных к определенному пространству имен (по всем узлам, если применимо).

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

Пример получения всех клиентов в комнате пространства имен:

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

Это из официальной документации: Socket.IO Server-API

Я думаю, что мы можем получить доступ к объекту сокета с сервера, и вы можете назначить псевдоним и указать его идентификатор сокета,

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");
    });    
});

На disconnect удалите ник из io.sockets.sockets.

Это лучший способ получить к нему доступ в socket.io 1.3

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

Я считаю, что для всех, кто хочет просто COUNT подключенных клиентов, это сработает:

io.sockets.manager.server.connections

Socket.io 1.4.4

Пример кода для вас.

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;
        });
    }

Думаю кому-то поможет этот блок кода.

В Socket.IO 1.4

Чтобы получить массив всех подключенных пользователей:

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

Чтобы получить счетчик всех клиентов:

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

Начиная с socket.io 1.5, обратите внимание на изменение indexOf, которое, по-видимому, обесценивается и заменяется на 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;
}

Для socket.io версии 2.0.3 работает следующий код:

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;
}

на socket.io 1.3 я сделал это в 2 строки

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

Socket.io 1.7.3 (+):

function getConnectedList ()
{
    let list = []
    
    for ( let client in io.sockets.connected )
    {
        list.push(client)
    }
    
    return list
}

console.log( getConnectedList() )

// returns [ 'yIfhb2tw7mxgrnF6AAAA', 'qABFaNDSYknCysbgAAAB' ]

Для версии 2.3 это работает, и вам также будет предоставлен сокет, мне кажется, что socketIo меняется слишком быстро и слишком много с плохо читаемой документацией после его использования в течение некоторого времени.

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);
    }
});

все же это кажется неправильным, так как у меня всегда такое чувство с сокетом Io как-то

Для кластерного режима с использованием redis-adapter

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

});

Поскольку каждый сокет сам по себе является комнатой, можно определить, существует ли сокет, используя то же самое.

[email protected]

 io.in('room1').sockets.sockets.forEach((socket,key)=>{
        console.log(socket);
    })

все экземпляры сокетов в room1

namespace.allSockets ()

Обещание возврата ‹Set›

io.allSockets() все идентификаторы подключенных сокетов в основном пространстве имен

io.in('room').allSockets() // все подключенные идентификаторы в 'комнате'

io.of('/namespace').allSockets() // все подключенные идентификаторы в '/ namespace' (вы также можете объединить это с комнатами)

2021 Update V4.0+

Ни один из ответов не помог мне. Я избавлю тебя от боли. Их API и документация сильно изменились с 1.0.

Server Api все доступные параметры

Но вам нужно копать здесь

// return all Socket instances
var clients = io.sockets;

clients.sockets.forEach(function(data,counter){

//console.log(data);//maps

var socketid =  data.id;//log ids
var isConnected = data.connected//true,false;

});

Я считаю, что вы можете получить доступ к этому из свойства менеджера сокета?

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

Я вижу здесь много хороших ответов, и многие из них довольно полезны, но не совсем то, что мне нужно. Я использую сокеты для функции pubsub, в которой заинтересованный клиент может прослушивать любые изменения в данной записи.

Моя конкретная проблема заключалась в том, что одна и та же розетка несколько раз присоединялась к одной и той же комнате. Решением было проверить, есть ли у розетки помещение в свойстве rooms.

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");
}

Надеюсь, это кому-то поможет.

Это самый простой способ в Socket.IO 1.0+, если вы не используете пространства имен или комнаты.

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

Это смотрит на пространство имен по умолчанию и определяет длину массива сокетов, без необходимости использовать Object.keys()

Начиная с версии 1.5.1, я могу получить доступ ко всем сокетам в пространстве имен с помощью:

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...
    }
});

По какой-то причине они используют простой объект вместо массива для хранения идентификаторов сокетов.

Если в проекте есть кластер socket.io, это означает, что используется адаптер socket.io-redis.

В случае, подобном описанному выше, процесс получения идентификатора всех подключенных сокетов должен быть применен через адаптер socket.io-redis. Для этого можно использовать приведенные ниже примеры;

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);
});

Посетите страницу socket.io-redis на github для получения дополнительных сведений.

Вот быстрый способ преобразовать хэш подключенных сокетов из пространства имен в массив с помощью генераторов ES6 (применяется к 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
})

Я не знаю, продолжается ли это до сих пор. Но что-то вроде этого я в итоге использовал (я сохраняю объект session на каждом подключенном сокете, который, в свою очередь, содержит имя пользователя и другую информацию:

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

[email protected]

Я использовал Object.Keys, чтобы подключить массив сокетов. Затем в том же массиве выполните итерацию с функцией карты, чтобы построить новый массив объектов.

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);

Возможно, этот ответ поможет получить массив идентификаторов сокетов / имен пользователей.

io.sockets.sockets.keys ()

Это мне помогает.

для socket.io версии 4.0.0

На стороне сервера, чтобы перечислить некоторые свойства всех активных сокетов, я использую это:

function listSocketsProperty(myProperty){
  let sck = io.sockets.sockets
  const mapIter = sck.entries()
  while(1){
    let en = mapIter.next().value?.[0]
    if(en) console.log( sck.get(en)[myProperty] )
    else break
  }
}

Объяснение:

sck = io.sockets.sockets - это объект Map.

Метод Entries () возвращает новый объект Iterator, содержащий пары [ключ, значение] для каждого элемента в объекте Map.

ru = mapIter.next (). value?. [0] получает ключ - первый элемент пары.

Если повторять больше не нужно, en становится неопределенным, и это прерывает цикл while.

Пример:

У моих сокетов есть свойство playerName, и я хочу перечислить имена всех активных игроков во всех комнатах. Для этого я просто вызываю функцию:

listSocketsProperty('playerName')

и войдите в консоль примерно так:

John
Peter
Zoran
etc.