Próbuję uzyskać listę wszystkich gniazd / klientów, które są obecnie połączone.

io.sockets niestety nie zwraca tablicy.

Wiem, że mógłbym zachować własną listę za pomocą tablicy, ale nie sądzę, że jest to optymalne rozwiązanie z 2 powodów:

1. Nadmierność. Socket.IO przechowuje już kopię tej listy.

2. Socket.IO zapewnia metodę ustawiania dowolnych wartości pól dla klientów (tj .:), socket.set('nickname', 'superman')więc musiałbym nadążać za tymi zmianami, gdybym miał utrzymywać własną listę.

Wsparcie?

W Socket.IO 0.7 masz clientsmetodę w przestrzeniach nazw, która zwraca tablicę wszystkich połączonych gniazd.

API bez przestrzeni nazw:

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

Przestrzeń nazw

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

Mam nadzieję, że pomoże to komuś w przyszłości

UWAGA: To rozwiązanie działa TYLKO z wersją wcześniejszą niż 1.0

AKTUALIZACJA 2020 Mar 06

Od wersji 1.xi nowszej, skorzystaj z tego linku: sprawdzanie liczby osób na czacie w socket.io

Socket.io 1.4

Object.keys(io.sockets.sockets); daje wszystkie podłączone gniazda.

Socket.io 1.0 Począwszy od socket.io 1.0, rzeczywista zaakceptowana odpowiedź nie jest już poprawna. Zrobiłem więc małą funkcję, której używam jako tymczasowej poprawki:

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

Interfejs API dla braku przestrzeni nazw zostanie zmieniony

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

Interfejs API dla przestrzeni nazw staje się:

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

Zobacz także to pokrewne pytanie , w którym podaję funkcję zwracającą gniazda dla danego pomieszczenia.

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 bez przestrzeni nazw :

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

Na przestrzeni nazw

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

Uwaga: ponieważ wydaje się, że interfejs API socket.io jest podatny na awarie, a niektóre rozwiązania polegają na szczegółach implementacji, może to być kwestia samodzielnego śledzenia klientów:

var clients = [];

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

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

Po socket.io 1.0 nie możemy używać

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

już. Zamiast tego możesz użyć następującego

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
}

Korzystanie z Socket.IO 1.x:

Uzyskaj tablicę połączonych klientów:

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

Uzyskaj liczbę połączonych klientów:

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

Bardzo prosty w socket.io 1.3:

io.sockets.sockets- to tablica zawierająca połączone obiekty gniazd. Jeśli zapisałeś nazwę użytkownika w każdym gnieździe, możesz:

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

Bum. Masz nazwy wszystkich połączonych użytkowników.

Przeszedłem dzisiaj przez ten ból. Socket.io byłby znacznie lepszy, gdyby mogli stworzyć odpowiednią dokumentację dla swojego API.

W każdym razie próbowałem zajrzeć do io.sockets i znalazłem kilka opcji, których możemy użyć:

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

Zwróć również uwagę, że podczas korzystania z socket.io z przestrzenią nazw powyższe metody nie działają, ponieważ io.sockets staje się tablicą zamiast obiektem. Aby rozwiązać ten problem, po prostu zamień io.sockets na io (tj. Io.sockets.connected stanie się io.connected, a io.sockets.adapter.rooms stanie się io.adapter.rooms ...)

Testowane na socket.io 1.3.5

Wersja +2.0

W wersji +2.0 określasz przestrzeń nazw / pokój / węzeł, o który pytasz.

Podobnie jak w przypadku rozgłaszania, wartością domyślną są wszyscy klienci z domyślnej przestrzeni nazw („/”):

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

Pobiera listę identyfikatorów klientów połączonych z określoną przestrzenią nazw (we wszystkich węzłach, jeśli dotyczy).

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

Przykład pobierania wszystkich klientów w pokoju przestrzeni nazw:

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

To pochodzi z oficjalnej dokumentacji: Socket.IO Server-API

Myślę, że możemy uzyskać dostęp do obiektu gniazda z serwera i możesz przypisać pseudonim i wskazać jego identyfikator gniazda,

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

W dniu disconnectusuń pseudonim z domeny io.sockets.sockets.

To najlepszy sposób, aby uzyskać do niego dostęp w socket.io 1.3

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

Dla każdego, kto chce tylko LICZBA podłączonych klientów, wierzę, że to wystarczy:

io.sockets.manager.server.connections

Socket.io 1.4.4

Przykładowy kod dla Ciebie.

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

Myślę, że pomoże komuś ten blok kodu.

W Socket.IO 1.4

Aby uzyskać tablicę wszystkich podłączonych użytkowników:

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

Aby uzyskać liczbę wszystkich klientów:

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

Począwszy od socket.io 1.5, zwróć uwagę na zmianę w stosunku do indexOf, który wydaje się być zdeprecjonowany i zastąpiony przez 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;
}

W przypadku socket.io w wersji 2.0.3 działa następujący kod:

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

na socket.io 1.3, zrobiłem to w 2 liniach

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

Socket.io 1.7.3 (+):

funkcja getConnectedList ()
{
    let list = []
    
    for (niech klient w io.sockets.connected)
    {
        list.push (klient)
    }
    
    lista zwrotów
}

console.log (getConnectedList ())

// zwraca ['yIfhb2tw7mxgrnF6AAAA', 'qABFaNDSYknCysbgAAAB']

W wersji 2.3 to działa i dostaniesz również gniazdo , wydaje mi się, że socketIo zmienia się zbyt szybko i za dużo, a dokumentacja jest mało czytelna po używaniu go przez jakiś czas.

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

nadal to nie jest w porządku, ponieważ zawsze mam to uczucie z gniazdem Io

Uważam, że można uzyskać do tego dostęp z właściwości menedżera gniazda?

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

Widzę tutaj wiele dobrych odpowiedzi, a wiele z nich jest całkiem przydatnych, ale nie do końca potrzebnych. Używam gniazd dla funkcji pubsub, w której zainteresowany klient może nasłuchiwać zmian w danym rekordzie.

Moim konkretnym problemem było to, że to samo gniazdo kilka razy łączyło się z tym samym pokojem. Rozwiązaniem tego problemu było sprawdzenie, czy gniazdo ma już pomieszczenie w jego pomieszczeniach.

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

Mam nadzieję, że to komuś pomoże.

Jest to najprostszy sposób w Socket.IO 1.0+, jeśli nie używasz przestrzeni nazw ani pokojów.

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

Spowoduje to sprawdzenie domyślnej przestrzeni nazw i określenie długości tablicy gniazd, bez konieczności jej używania Object.keys()

Od wersji 1.5.1 mogę uzyskać dostęp do wszystkich gniazd w przestrzeni nazw za pomocą:

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

Z jakiegoś powodu używają zwykłego obiektu zamiast tablicy do przechowywania identyfikatorów gniazd.

W trybie klastra za pomocą adaptera redis

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

});

Ponieważ każde gniazdo samo w sobie jest pokojem, można sprawdzić, czy gniazdo istnieje, używając tego samego.

Oto szybki sposób konwersji skrótu połączonych gniazd z przestrzeni nazw na tablicę przy użyciu generatorów ES6 (dotyczy 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
})

Nie wiem, czy to nadal trwa. Ale coś takiego właśnie skończyło się na tym (trzymam obiekt sesji na każdym podłączonym gnieździe, który z kolei zawiera nazwę użytkownika i inne informacje:

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

Jeśli projekt ma socket.io klaster to oznacza socket.io-Redis adapter jest używany.

W przypadku podobnym do powyższego, proces pobierania wszystkich podłączonych gniazd musi odbywać się za pomocą adaptera socket.io-redis . W tym celu można wykorzystać poniższe przykłady;

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

Proszę odwiedź uzyskać więcej informacji, stronę github socket.io-redis .

[email protected]

Użyłem Object.Keys, aby uzyskać tablicę podłączonych gniazd. Następnie w tej samej tablicy wykonaj iterację z funkcją map, aby zbudować nową tablicę obiektów

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

Być może ta odpowiedź może pomóc w uzyskaniu tablicy identyfikatorów gniazda / nazw użytkowników.

wersja 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.