socket.io中的延迟发射率回调

Question

I have the following communication in a socket.io project

// Server side
socket.on('pattern', (value, callback) => {
   //... run some code
   callback(...)
})

// Client side
client.emit('pattern', value, (response) => {
   // ....process response
})

How does this logic stand up against latency factors? eg :-

1. If the emittance were done twice on the client side( same client) would the callback be called twice? Would the second event nullify the first( not talking about value)?

2. What would be the benefits of using this logic pattern instead of doing( especially where latency is involved):-

   // Server side socket.on('pattern', (value) => { //... run some code socket.emit('callback', response) })

    // Client side client.on('callback', (response) => ....) client.emit('pattern', value) 

How do you handle latency in these scenarios?

Answer 1

If the emittance were done twice on the client side( same client) would the callback be called twice?

Yes. Every event you send from the client is individually delivered to the server so your event handler on the server would get called for each separate message that the client sent.

Would the second event nullify the first( not talking about value)?

No. Your code would first process the first event and then it would be separately called to process the second event. What happens when your code gets two separate events with different data is completely up to your code (which you do not show). But, socket.io will deliver them both and call your code with each separate piece of data. It's up to your code how to handle that.

I don't understand your #2 question. In general, if you can combine multiple pieces of data into one transmission, that is better than sending multiple transmissions (simply less overhead). That applies to all networking and is not just specific to socket.io.