Ich versuche, eine Liste aller Sockets / Clients zu erhalten, die derzeit verbunden sind.

io.sockets gibt leider kein Array zurück.

Ich weiß, dass ich meine eigene Liste mit einem Array führen könnte, denke aber aus zwei Gründen nicht, dass dies eine optimale Lösung ist:

1. Redundanz. Socket.IO behält bereits eine Kopie dieser Liste.

2. Socket.IO bietet eine Methode zum Festlegen beliebiger Feldwerte für Clients (dh :), socket.set('nickname', 'superman')sodass ich mit diesen Änderungen Schritt halten muss, wenn ich meine eigene Liste verwalten möchte.

Hilfe?

In Socket.IO 0.7 haben Sie eine clientsMethode für die Namespaces, die ein Array aller verbundenen Sockets zurückgibt.

API für keinen Namespace:

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

Für einen Namespace

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

Hoffe das hilft jemandem in der Zukunft

HINWEIS: Diese Lösung funktioniert NUR mit Versionen vor 1.0

AKTUALISIERT 2020 Mar 06

Ab 1.x und höher verweisen Sie bitte auf diesen Link: Ermitteln Sie, wie viele Personen sich in einem Chatroom in socket.io befinden

Socket.io 1.4

Object.keys(io.sockets.sockets); gibt Ihnen alle angeschlossenen Steckdosen.

Socket.io 1.0 Ab socket.io 1.0 ist die tatsächlich akzeptierte Antwort nicht mehr gültig. Also habe ich eine kleine Funktion erstellt, die ich als vorübergehende Korrektur verwende:

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 für No Namespace wird

// 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 für einen Namespace wird:

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

Siehe auch diese verwandte Frage , in der ich eine Funktion gebe, die die Sockets für einen bestimmten Raum zurückgibt.

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 für keinen Namespace :

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

Für einen Namespace

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

Hinweis: Da die socket.io-API anscheinend fehleranfällig ist und einige Lösungen auf Implementierungsdetails beruhen, kann es eine Frage der Verfolgung der Clients selbst sein:

var clients = [];

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

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

Nach socket.io 1.0 können wir nicht verwenden

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

nicht mehr. Stattdessen können Sie Folgendes verwenden

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
}

Verwenden von Socket.IO 1.x:

Array der verbundenen Clients abrufen:

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

Ermitteln Sie die Anzahl der verbundenen Clients:

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

Sehr einfach in socket.io 1.3:

io.sockets.sockets- ist ein Array, das die verbundenen Socket-Objekte enthält. Wenn Sie den Benutzernamen in jedem Socket gespeichert haben, können Sie Folgendes tun:

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

Boom. Sie haben die Namen aller verbundenen Benutzer.

Ich habe heute diesen Schmerz durchgemacht. Socket.io ist viel besser, wenn sie eine ordnungsgemäße Dokumentation für ihre API erstellen könnten.

Wie auch immer, ich habe versucht, in io.sockets zu suchen und eine Reihe von Optionen gefunden, die wir verwenden können:

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

Beachten Sie außerdem, dass bei Verwendung von socket.io mit Namespace die oben genannten Methoden nicht mehr funktionieren, da io.sockets zu einem Array anstelle eines Objekts wird. Um dies zu beheben, ersetzen Sie einfach io.sockets durch io (dh io.sockets.connected wird zu io.connected, io.sockets.adapter.rooms wird zu io.adapter.rooms ...)

Getestet auf socket.io 1.3.5

Version +2.0

In Version +2.0 geben Sie den Namespace / Raum / Knoten an, für den Sie eine Abfrage durchführen.

Wie beim Broadcasting sind standardmäßig alle Clients aus dem Standard-Namespace ('/'):

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

Ruft eine Liste der Client-IDs ab, die mit einem bestimmten Namespace verbunden sind (ggf. über alle Knoten hinweg).

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

Ein Beispiel, um alle Clients in den Raum des Namespace zu bringen:

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

Dies ist aus der offiziellen Dokumentation: Socket.IO Server-API

Ich denke, wir können vom Server aus auf das Socket-Objekt zugreifen, und Sie können den Spitznamen zuweisen und auf seine Socket-ID verweisen.

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

Am disconnectentfernen Sie bitte den Spitznamen von io.sockets.sockets.

Dies ist der beste Weg, um in socket.io 1.3 darauf zuzugreifen

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

Für jeden, der nur einen COUNT der verbundenen Clients möchte, glaube ich, dass dies das tun wird:

io.sockets.manager.server.connections

Socket.io 1.4.4

Beispielcode für Sie.

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

Ich denke, wird jemandem dieser Codeblock helfen.

In Socket.IO 1.4

So erhalten Sie das Array aller verbundenen Benutzer:

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

So ermitteln Sie die Anzahl aller Clients:

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

Beachten Sie ab socket.io 1.5 die Änderung von indexOf, die anscheinend abgeschrieben und durch valueOf ersetzt wird

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

Für socket.io Version 2.0.3 funktioniert der folgende Code:

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

auf socket.io 1.3 habe ich dies in 2 Zeilen erreicht

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

Socket.io 1.7.3 (+):

Funktion getConnectedList ()
{
    let list = []
    
    für (Client in io.sockets.connected lassen)
    {
        list.push (client)
    }}
    
    Rückgabeliste
}}

console.log (getConnectedList ())

// gibt ['yIfhb2tw7mxgrnF6AAAA', 'qABFaNDSYknCysbgAAAB' zurück]

Für Version 2.3 funktioniert dies und Sie erhalten auch den Socket . Es scheint mir, dass sich SocketIo nach einer Weile zu schnell und zu viel mit zu wenig lesbarer Dokumentation ändert.

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

Trotzdem fühlt sich das nicht richtig an, da ich immer irgendwie dieses Gefühl mit Sockel Io habe

Ich glaube, Sie können über die Manager-Eigenschaft des Sockets darauf zugreifen.

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

Ich sehe hier viele gute Antworten und viele waren sehr nützlich, aber nicht ganz das, was ich brauchte. Ich verwende Sockets für eine Pubsub-Funktion, mit der ein interessierter Client Änderungen in einem bestimmten Datensatz anhören kann.

Mein spezielles Problem war, dass dieselbe Steckdose mehrmals in denselben Raum kam. Die Lösung hierfür bestand darin, zu überprüfen, ob die Steckdose den Raum bereits in ihrem Zimmerbesitz hatte.

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

Hoffe das hilft jemandem.

Dies ist der einfachste Weg in Socket.IO 1.0+, wenn Sie keine Namespaces oder Räume verwenden.

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

Dadurch wird der Standard-Namespace überprüft und die Länge des Sockets-Arrays bestimmt, ohne dass eine Verwendung erforderlich ist Object.keys()

Ab Version 1.5.1 kann ich auf alle Sockets in einem Namespace zugreifen mit:

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

Aus irgendeinem Grund verwenden sie ein einfaches Objekt anstelle eines Arrays, um die Socket-IDs zu speichern.

Verwenden Sie für den Cluster-Modus den Redis-Adapter

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

});

Da jede Steckdose selbst ein Raum ist, kann man feststellen, ob eine Steckdose mit derselben vorhanden ist.

Hier ist eine schnelle Möglichkeit, den Hash verbundener Sockets mithilfe von ES6-Generatoren aus einem Namespace in ein Array zu konvertieren (gilt für 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
})

Ich weiß nicht, ob das noch geht. Aber so etwas habe ich letztendlich verwendet (ich behalte ein Sitzungsobjekt auf jedem verbundenen Socket, das wiederum den Benutzernamen und andere Informationen enthält:

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

Wenn das Projekt einen socket.io- Cluster hat, bedeutet dies, dass der Socket.io-redis- Adapter verwendet wird.

Wenn der Fall wie oben beschrieben ist, muss das Abrufen des ID-Prozesses für alle verbundenen Sockets über den Adapter socket.io-redis angewendet werden. Die folgenden Beispiele könnten hierfür verwendet werden.

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

Bitte besuchen Sie die Socket.io-Redis Github Seite für weitere Details.

[email protected]

Ich habe Object.Keys verwendet, um das Array der Sockets zu verbinden. Dann iterieren Sie im selben Array mit der Kartenfunktion, um ein neues Array von Objekten zu erstellen

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

Vielleicht kann diese Antwort helfen, Socket-ID / Benutzername-Array zu erhalten.

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.