Question

I’m using nodejs + websocket module to establish a connection between the client and the server through a websocket.
The server emits several times data to the client: I know it’s a TCP connection, but let me delete every doubt about it.
Are the “emits” sequential? If the first “emit” was done at time 1s and the second “emit” at time 2s, will the client receive for sure the first emit and then the second one?
What happens if the first emit is not received yet and the second one is emitted?
Are emits blocking calls?

Answer 1

WebSockets is built on TCP. TCP guarantees delivery and ordering of packets. In addition, unlike TCP, WebSockets is message based which means that WebSocket messages are received as an entire message (TCP is streaming and ‘messages’ may get fragmented from the listener’s perspective)

In node.js, two emits that are called from the same context (the same function) one after the other will be delivered in that order. However, if your emits are in two different callbacks, you can’t always guarantee when Node.js will schedule those callbacks and so the emits may get re-ordered because the scheduled callbacks got re-ordered.

Update:

Here is an example to expand on why the event driven nature of Node.js may result in surprising re-ordering of WebSocket emits/sends:

fs.readFile(file1,function(e,data) { ws.send(data); });
fs.readFile(file2,function(e,data) { ws.send(data); }); 

The order that file1 and file2 will be delivered to the browser is not predictable (even the file size is not a guarantee of when they will fire due to things like caching, file-system fragmentation, etc). Even if the readFile of file2 is called 1 second later using a setTimeout, the browser may still receive them out of order (e.g. if file1 is much larger and takes 3s to read in then the send of file1 will happen after the send for file2).

So yes, emits/sends will be received in the browser in the order they are called in Node.js, but due to the asynchronous event driven nature of Node.js the emits/sends may not happen in the order you expect.

The asynchronous event driven nature of Node.js is what gives Node.js excellent efficiency and performance, but if you aren’t used to this type of callback based programming it can have some surprising results.