javascript闭包怎么在WebSockets中应用

function createWebSocketHandler(ws, connectionId) {
    let isActive = true; // 这个变量被闭包捕获
    const connectionStartTime = Date.now(); // 同样被捕获

    ws.onmessage = (event) => {
        if (!isActive) {
            console.log(`Connection ${connectionId} is inactive, ignoring message.`);
            return;
        }
        console.log(`Message from ${connectionId}: ${event.data}`);
        // 这里可以访问 connectionId 和 isActive
        // 比如根据 connectionId 路由消息到特定用户
    };

    ws.onclose = () => {
        isActive = false; // 更新状态，这个状态只对当前连接有效
        const duration = Date.now() - connectionStartTime;
        console.log(`Connection ${connectionId} closed after ${duration}ms.`);
        // 清理与 connectionId 相关的资源
    };

    ws.onerror = (error) => {
        console.error(`Error on connection ${connectionId}:`, error);
        // 记录错误，并可能关闭连接
    };

    // 返回一些公共接口，如果需要的话
    return {
        getConnectionId: () => connectionId,
        isConnectionActive: () => isActive
    };
}

// 假设这是服务器端或客户端创建连接的逻辑
// const newWs = new WebSocket('ws://localhost:8080');
// createWebSocketHandler(newWs, 'user-123');

connectionId

isActive

connectionStartTime

createWebSocketHandler

onmessage

onclose

onerror

ws

userId

userName

roomId

onmessage

ws

// 假设这是在处理新的WebSocket连接时
wss.on('connection', function connection(ws, req) {
    const userId = getUserIdFromRequest(req); // 从请求中解析用户ID，这可能是认证后的结果
    const userSessionData = {
        id: userId,
        lastActive: Date.now(),
        // ...其他用户相关数据
    };

    // 将 userSessionData 通过闭包“绑定”到 ws 的事件处理器上
    ws.on('message', function incoming(message) {
        // 在这里，我们可以直接访问到 userSessionData
        console.log(`Received message from user ${userSessionData.id}: ${message}`);
        // 根据 userSessionData.id 将消息广播到特定房间，或更新用户状态
        userSessionData.lastActive = Date.now(); // 更新用户活跃时间
        // ...
    });

    ws.on('close', function() {
        console.log(`User ${userSessionData.id} disconnected.`);
        // 清理与该用户相关的资源，比如从在线用户列表中移除
    });

    ws.on('error', function(error) {
        console.error(`Error for user ${userSessionData.id}:`, error);
    });

    // 也可以将 ws 实例和 userSessionData 存储在一个全局映射中，方便通过 userId 查找 ws 实例
    // activeConnections.set(userId, ws);
});

onmessage

onclose

function setupHeartbeat(ws, interval = 30000) {
    let lastPongTime = Date.now();
    let heartbeatIntervalId;

    ws.onmessage = (event) => {
        if (event.data === 'pong') {
            lastPongTime = Date.now();
            // console.log('Received pong, updating lastPongTime');
        }
        // ...处理其他消息
    };

    // 启动心跳
    heartbeatIntervalId = setInterval(() => {
        if (Date.now() - lastPongTime > interval * 2) { // 如果长时间没收到pong
            console.warn('Heartbeat timeout, closing connection.');
            ws.close();
            clearInterval(heartbeatIntervalId);
        } else {
            ws.send('ping');
        }
    }, interval);

    ws.onclose = () => {
        clearInterval(heartbeatIntervalId); // 连接关闭时清除定时器
        console.log('Heartbeat stopped for this connection.');
    };

    ws.onerror = () => {
        clearInterval(heartbeatIntervalId);
        console.error('Heartbeat stopped due to error.');
    };
}

// const clientWs = new WebSocket('ws://localhost:8080');
// setupHeartbeat(clientWs);

lastPongTime

heartbeatIntervalId

ws

heartbeatIntervalId

function createReconnectableWebSocket(url, options = {}) {
    const { maxAttempts = 10, initialDelay = 1000 } = options;
    let ws = null;
    let reconnectAttempts = 0;
    let reconnectTimeoutId = null;

    const connect = () => {
        ws = new WebSocket(url);

        ws.onopen = () => {
            console.log('WebSocket connected.');
            reconnectAttempts = 0; // 成功连接后重置尝试次数
            clearTimeout(reconnectTimeoutId); // 清除任何待执行的重连定时器
            // 可以在这里触发一个 onConnect 回调
            if (options.onConnect) options.onConnect(ws);
        };

        ws.onmessage = (event) => {
            // console.log('Received message:', event.data);
            if (options.onMessage) options.onMessage(event.data);
        };

        ws.onclose = (event) => {
            console.log('WebSocket disconnected:', event.code, event.reason);
            ws = null; // 清空旧的ws实例

            if (reconnectAttempts < maxAttempts) {
                const delay = initialDelay * Math.pow(2, reconnectAttempts);
                reconnectAttempts++;
                console.log(`Attempting to reconnect in ${delay / 1000}s... (Attempt ${reconnectAttempts})`);
                reconnectTimeoutId = setTimeout(connect, delay); // 闭包捕获 connect 函数
            } else {
                console.error('Max reconnect attempts reached. Giving up.');
                if (options.onMaxAttemptsReached) options.onMaxAttemptsReached();
            }
            if (options.onClose) options.onClose(event);
        };

        ws.onerror = (error) => {
            console.error('WebSocket error:', error);
            // 错误通常也会触发 onclose，所以这里不需要额外的重连逻辑
            if (options.onError) options.onError(error);
        };
    };

    connect(); // 首次连接

    // 返回一个可以控制连接的对象，比如手动关闭
    return {
        send: (message) => {
            if (ws && ws.readyState === WebSocket.OPEN) {
                ws.send(message);
            } else {
                console.warn('WebSocket not open, message not sent.');
            }
        },
        close: () => {
            if (ws) {
                ws.close();
                clearTimeout(reconnectTimeoutId); // 手动关闭时也要清除重连定时器
            }
        }
    };
}

// 使用示例：
// const myWebSocket = createReconnectableWebSocket('ws://localhost:8080/chat', {
//     onMessage: (data) => console.log('App received:', data),
//     onConnect: (wsInstance) => console.log('App connected, ready to send!'),
//     onMaxAttemptsReached: () => alert('无法连接到服务器，请检查网络！')
// });
// myWebSocket.send('Hello server!');

createReconnectableWebSocket

reconnectAttempts

reconnectTimeoutId

connect

onopen

onclose