Javascript 可以在房间中收听加入和离开活动吗？

我想做一些类似的事情：

var room = io.sockets.in('some super awesome room');
room.on('join', function () {
    /* stuff */
});
room.on('leave', function () {
    /* stuff */
});

这似乎不起作用。可能吗

要说明所需的行为，请执行以下操作：

io.sockets.on('connection', function (socket) {
    socket.join('some super awesome room'); // should fire the above 'join' event
});

您可以使用本机“断开连接”事件

在Socket.IO中，“房间”实际上只是一个名称空间，它可以帮助您将巨大的套接字包过滤为较小的套接字包。调用

io.sockets.in（'room'）.on（'something'）

将导致在触发事件时触发房间中每个套接字的事件处理程序。如果这正是你想要的，像这样的东西应该可以做到：

var room = io.sockets.in('some super awesome room');
room.on('join', function() {
  console.log("Someone joined the room.");
});
room.on('leave', function() {
  console.log("Someone left the room.");
});

socket.join('some super awesome room');
socket.broadcast.to('some super awesome room').emit('join');

setTimeout(function() {
  socket.leave('some super awesome room');
  io.sockets.in('some super awesome room').emit('leave');
}, 10 * 1000);

需要注意的重要一点是，如果您（1）获得一个房间中所有套接字的列表，并（2）对它们进行迭代，在每个套接字上调用

emit（'join'）

，则会得到相同的效果。因此，您应该确保事件名称足够具体，不会意外地将其发送到房间的“名称空间”之外

---

如果您只想在套接字加入或离开房间时发出/使用单个事件，您需要自己编写，因为房间与其说是一个“东西”，不如说是一个“过滤器”。

我知道这个问题由来已久，但对于任何通过谷歌搜索偶然发现这个问题的人来说，这就是我的做法

加入一个房间是一件很容易解释的事情，即使没有加入或离开房间的本地活动

/* client.js */
var socket = io();
socket.on('connect', function () {
    // Join a room
    socket.emit('joinRoom', "random-room");
});

对于服务器端

/* server.js */
// This will have the socket join the room and then broadcast 
// to all sockets in the room that someone has joined
socket.on("joinRoom", function (roomName) {
    socket.join(roomName);
    io.sockets.in(roomName).emit('message','Someone joined the room');
}

// This will have the rooms the current socket is a member of
// the "disconnect" event is after tear-down, so socket.rooms would already be empty
// so we're using disconnecting, which is before tear-down of sockets
socket.on("disconnecting", function () {
    var rooms = socket.rooms;
    console.log(rooms);
    // You can loop through your rooms and emit an action here of leaving
});

更棘手的是当他们断开连接时，但幸运的是，在房间里的插座被拆除之前，添加了一个

断开

事件。在上面的示例中，如果事件是

disconnect

，则房间将为空，但

disconnecting

将拥有它们所属的所有房间。在我们的示例中，您将有两个房间，插座将是其中的一部分，

socket\35; id

和

random room

---

我希望我的研究和测试为其他人指明了正确的方向。

最近也遇到了同样的问题。 下面的代码应该是您正在寻找的答案。这可能不是最优雅的解决方案，但很有效

catch不是使用socket.join（“某物”） 您需要像这样使用

this.roomHandler.room（socket，“room1”，“join”）

---

这不是我要找的。我想为sockets

join（）

和

leave（）

房间创建事件处理程序，而不是完全连接到服务器或从服务器断开连接（尽管断开连接会导致

“leave”

事件）。@camupod-sockets不知道“房间”的含义。房间是一个应用程序级别的概念，因此套接字从不连接或离开房间。您必须自己编写一些更高级别的处理程序来发出加入和离开事件。@StephenP-sockets不需要了解房间。我想知道“房间”（

io.sockets.in（'name'）

）是否可以告诉我什么时候有人加入或离开。你什么时候加入/离开，或者其他人什么时候加入/离开？我不确定我是否理解你的要求。我有一个“房间”，我想知道任何套接字何时加入或离开它。套接字不加入或离开房间。客户加入或离开房间。我认为你对客户感兴趣（那不是你），那么？我认为你不理解这个问题。没有“我”。。。这是服务器端代码。根据，套接字确实连接和离开房间：

var io=require（'socket.io'）。侦听（80）；io.sockets.on（'connection'，function（socket）{socket.join（'justin bieber fans'）；socket.broadcast.to（'justin bieber fans'）.emit（'new fan'）；io.sockets.in（'rammstein fans'）.emit（'new non fan'）；}）啊。所以“房间”是一个低级的东西，有点像一个多播组，而不是一个聊天室。
房间不是一个“东西”，而是一个“过滤器”
——这就是我所担心的（我希望socket.io有更好的文档）。我想我必须写我自己版本的房间。。。谢谢我对
join
处理程序的参数有疑问-
/* server.js */
// This will have the socket join the room and then broadcast 
// to all sockets in the room that someone has joined
socket.on("joinRoom", function (roomName) {
    socket.join(roomName);
    io.sockets.in(roomName).emit('message','Someone joined the room');
}

// This will have the rooms the current socket is a member of
// the "disconnect" event is after tear-down, so socket.rooms would already be empty
// so we're using disconnecting, which is before tear-down of sockets
socket.on("disconnecting", function () {
    var rooms = socket.rooms;
    console.log(rooms);
    // You can loop through your rooms and emit an action here of leaving
});

class myserver{
    constructor(){


        this.io = require('socket.io')(85);
        this.io.on('connection', (socket) => {

            console.log("New User")

            this.roomHandler.room(socket,"room1","join")
            this.roomHandler.room(socket,"room2","join")
            //this.roomHandler.room(socket,"room3","join")
            this.roomHandler.room(socket,"room3","leave")


            console.log("---")
            console.log(this.roomHandler.roomsOfUser)

            socket.on('disconnect', (reason) => {
                this.roomHandler.disconnect(socket, reason)
                console.log(this.roomHandler.roomsOfUser)
            })

        })




        //Room Event Handler Definition
        this.roomHandler = {
            disconnect:(socket, reason)=>{

                if(this.roomHandler.roomsOfUser[socket.id]){
                    this.roomHandler.roomsOfUser[socket.id].forEach(room => {
                        this.roomHandler.room(socket, room, "disconnect")
                    })
                    delete this.roomHandler.roomsOfUser[socket.id];
                }
            },

            roomEvents : {},
            roomsOfUser: {},

            room:(socket,room,action)=>{//Join Or Leave
                if(typeof socket == "object" && typeof socket.join == "function"){
                    if(typeof room=="string"){

                        //Room Join
                        if(action=="join"){
                            socket.join(room)
                            this.roomHandler.roomOn(room,"join",socket)

                            //Create, append room collection for user
                            if(this.roomHandler.roomsOfUser[socket.id]){
                                this.roomHandler.roomsOfUser[socket.id].push(room)
                            }else{
                                this.roomHandler.roomsOfUser[socket.id] = [room]
                            }


                        //Room Leave
                        }else if(action == "leave"){
                            if(this.roomHandler.roomsOfUser[socket.id][room]){//Really in the room?
                                socket.leave(room)
                                this.roomHandler.roomOn(room,"leave", socket)
                            }

                        //User Disconnected
                        }else if(action == "disconnect"){
                            this.roomHandler.roomOn(room,"leave", socket)

                        }else{
                            console.log("Undefined room action.")
                        }

                    }else{ console.log("Unqualified name for room."); }
                }else{ console.error("Not a legit socket object",socket); socket.join("aaa") }
            },

            roomOn:(room, event, socket)=>{
                if (typeof this.roomHandler.roomEvents[room] == "function"){
                    this.roomHandler.roomEvents[room](event,socket)
                }else{
                    console.log(`No event found for ${room}`, this.roomHandler.roomEvents)
                }
            },

            roomRegister:(room,callback)=>{
                if (typeof room == "string" && typeof callback == "function") {
                    console.log(`Callback registered for ${room}`)
                    this.roomHandler.roomEvents[room] = callback
                }else{
                    console.log("Room name or callback is invalid.")
                }
            }
        }
        //END OF HANDLER


        //Register Functions for room events.
        this.roomHandler.roomRegister("room1",(event,socket)=>{
            console.log(`${event} for room1 BY ${socket.id}`)
        })

        this.roomHandler.roomRegister("room2",(event,socket)=>{
            console.log(`${event} for room2 BY ${socket.id}`)
        })

        this.roomHandler.roomRegister("room3",(event,socket)=>{
            console.log(`${event} for room3 BY ${socket.id}`)
        })



    }

}



const server = new myserver();