현재 연결된 모든 소켓 / 클라이언트 목록을 얻으려고합니다.

io.sockets 불행히도 배열을 반환하지 않습니다.

배열을 사용하여 내 목록을 유지할 수는 있지만 이것이 두 가지 이유로 최적의 솔루션이라고 생각하지 않습니다.

1. 여분. Socket.IO는 이미이 목록의 사본을 유지합니다.

2. Socket.IO는 클라이언트 (예 :)에 대한 임의의 필드 값을 설정하는 방법을 제공 socket.set('nickname', 'superman')하므로 내 자신의 목록을 유지하려면 이러한 변경 사항을 따라야합니다.

도움?

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 이전 버전 에서만 작동합니다

업데이트 2020 년 3 월 6 일

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`

참고 : socket.io API가 깨지기 쉽고 일부 솔루션은 구현 세부 사항에 의존하기 때문에 클라이언트를 직접 추적해야 할 수도 있습니다.

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

특정 네임 스페이스에 연결된 클라이언트 ID 목록을 가져옵니다 (해당되는 경우 모든 노드에서).

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

서버에서 소켓 객체에 액세스 할 수 있고 닉네임을 할당하고 소켓 ID를 지정할 수 있다고 생각합니다.

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

연결된 클라이언트 수를 원하는 사람이라면 누구나 그렇게 할 것이라고 믿습니다.

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 (+) :

getConnectedList () 함수
{
    let list = []
    
    for (io.sockets.connected의 클라이언트를 보자)
    {
        list.push (클라이언트)
    }
    
    반품 목록
}

console.log (getConnectedList ())

// [ '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에 대한 느낌이 항상 있기 때문에 여전히 이것이 기분이 좋지 않습니다.

소켓의 관리자 속성에서 액세스 할 수 있다고 생각하십니까?

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

나는 여기에 많은 좋은 답변을 보았고 많은 유용한 곳이 있지만 필요한 것은 아닙니다. 관심있는 클라이언트가 주어진 레코드의 모든 변경 사항을 청취 할 수있는 pubsub 기능에 소켓을 사용하고 있습니다.

내 특정 문제는 같은 소켓이 같은 방에 여러 번 참여하고 있다는 것입니다. 이에 대한 해결책은 소켓에 룸 내부에 이미 룸 속성이 있는지 확인하는 것입니다.

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

어떤 이유로, 그들은 소켓 ID를 저장하기 위해 배열 대신 일반 객체를 사용하고 있습니다.

클러스터 모드의 경우 redis-adaptor 사용

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

});

각 소켓 자체가 방이므로 소켓을 사용하여 소켓이 존재하는지 확인할 수 있습니다.

다음은 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
})

이것이 여전히 진행되고 있는지 모르겠습니다. 그러나 이와 같은 것은 내가 사용한 결과입니다 ( 연결 된 각 소켓에 세션 객체를 유지합니다.이 소켓에는 사용자 이름과 다른 정보가 포함됩니다.

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

프로젝트에 socket.io 클러스터 가있는 경우 socket.io-redis 어댑터가 사용되고 있음을 의미 합니다.

위와 같은 경우 모든 연결된 소켓 ID 프로세스를 가져 오는 것은 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 페이지 를 방문 하십시오.

socket.io@1.7.3

소켓 배열을 연결하기 위해 Object.Keys를 사용했습니다. 그런 다음 동일한 배열에서 map 함수로 반복하여 새로운 객체 배열을 만듭니다.

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

아마도이 답변은 소켓 ID / 사용자 이름 배열을 얻는 데 도움이 될 수 있습니다.

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.