Great question! Let me break this down clearly for you:

1. When does io.use() middleware run? #

Your understanding is completely correct! Let's confirm with the official docs you quoted:

Registers a middleware, which is a function that gets executed for every incoming Socket, and receives as parameters the socket and a function to optionally defer execution to the next registered middleware.

The key phrase here is "for every incoming Socket" — this means the middleware runs exactly once per client connection, right before the connection event is triggered. It’s built for one-time setup tasks like validating authentication tokens, initializing connection-specific state, or checking client permissions. Once the connection is established, this middleware won’t run again for any subsequent events from that client.

For example, if you use io.use() to verify a user’s login token, you only need to do that once when they connect, not every time they send a chat message or update their status.

2. How to implement middleware that runs for every incoming event? #

If you need logic to execute before every single event a client sends, here are the most practical approaches:

Option 1: Use socket.onAny() (simplest official method) #

Socket.IO provides the onAny() method, which listens to all incoming events from a connected client. It runs before the event’s specific handler, making it perfect for global per-event middleware.

Example code:

// On the server, inside your connection handler
io.on('connection', (socket) => {
  // This runs for EVERY incoming event from this client
  socket.onAny((eventName, ...args) => {
    // Your middleware logic here
    console.log(`Handling event: ${eventName} from client ${socket.id}`);
    
    // Optional: Add validation or access checks
    if (eventName === 'sensitive-action' && !socket.user.isAdmin) {
      socket.emit('error', 'Unauthorized');
      return; // Block the event from reaching its handler
    }
    
    // If all checks pass, the event proceeds to its registered handler
  });

  // Regular event handlers
  socket.on('chat-message', (msg) => {
    console.log('Received chat message:', msg);
  });

  socket.on('update-status', (status) => {
    console.log('Updated status:', status);
  });
});

Option 2: Create a custom event wrapper (more flexible) #

If you want granular control — like applying middleware only to specific events, or using different middleware for event groups — you can build a wrapper function that injects your logic when registering events.

Example code:

// Helper function to wrap event handlers with middleware
function registerEventWithMiddleware(socket, eventName, handler) {
  socket.on(eventName, (...args) => {
    // Run middleware logic first
    console.log(`Processing event: ${eventName}`);
    
    // Example: Validate event data
    if (args.length === 0) {
      socket.emit('error', 'Event data missing');
      return;
    }
    
    // Execute the original handler if middleware passes
    handler.call(socket, ...args);
  });
}

// Usage inside connection handler
io.on('connection', (socket) => {
  registerEventWithMiddleware(socket, 'chat-message', (msg) => {
    console.log('Chat message received:', msg);
  });

  registerEventWithMiddleware(socket, 'update-profile', (profileData) => {
    console.log('Profile updated:', profileData);
  });
});

Option 3: Override the Socket instance (advanced) #

For full global control, you can override the socket.on method itself to ensure all events — even those registered later — use your middleware. This is more advanced but guarantees consistent behavior across all event registrations.

Example code:

io.on('connection', (socket) => {
  // Save the original `on` method
  const originalOn = socket.on;
  
  // Override `socket.on` to inject middleware
  socket.on = function(eventName, handler) {
    originalOn.call(this, eventName, (...args) => {
      // Middleware logic here
      console.log(`Event ${eventName} triggered`);
      
      // Run the original handler
      handler.apply(this, args);
    });
  };

  // All event registrations now use the wrapped `on` method
  socket.on('chat-message', (msg) => {
    console.log('Message:', msg);
  });
});

内容的提问来源于stack exchange，提问作者ThatBrianDude