Socket.io“连接”事件是否可以安全收听？

Question

I've been skeptical about this for years. The common practice is making a Socket and then listening to its "connect" event. It doesn't sound very safe.

import io from "socket.io-client";
CONNECT: const socket = io(……);
// ← An asynchronous connection establishment might happen here, no?
LISTEN: socket.on("connect", ……);

It tries to establish a connection as soon as the CONNECT statement gets executed. What if it does, before LISTEN ?

What makes such a practice safe to be used? What I believe is that just because it is two consecutive statements doesn't mean an asynchronous connection establishment cannot happen in-between. Are my thoughts wrong?

---

EDIT: internal code investigation.

I've just read the source code of socket.io-client and drawn a conclusion that the only code-wise safe way to go is to turn the autoConnect option off for io() not to create a Socket that automatically tries to establish a connection, which leads to arbitrary (“possibly-untimely”) emission of the "connect" event. This requires a manual call to socket.open() but is safe.

Here's how it goes:

1. io() creates a Manager instance and calls .socket() of it .

2. The .socket() creates a new Socket instance and then binds the Manager 's own internal handlers (that is not users') for "connecting" and "connect" events .

3. Since the Socket 's constructor .open() s if autoConnect , which involves the immediate emission of a "connecting" event and the future emission of a "connect" event , the Manager calls its own internal "connecting" event handler manually if autoConnect .

Turned out new Socket never waits for you

I could not find any safe-guard gizmo (at least code-wise ) to keep an autoConnect -ing Socket from establishing a "connect" -ion until corresponding handlers get attached.

The internal implementation is also making this assumption

What's funny is that even Manager does this dangerous practice,

Manager.prototype.socket = function (nsp, opts) {
  var socket = this.nsps[nsp];
  if (!socket) {
    socket = new Socket(this, nsp, opts);
    this.nsps[nsp] = socket;
    var self = this;
    socket.on('connecting', onConnecting);
    socket.on('connect', function () {
      socket.id = self.generateId(nsp);
    });

    if (this.autoConnect) {
      // manually call here since connecting event is fired before listening
      onConnecting();
    }
  }

  function onConnecting () {
    if (!~indexOf(self.connecting, socket)) {
      self.connecting.push(socket);
    }
  }

  return socket;
};

making an assumption that a Socket , with the autoConnect option being true or not,

socket = new Socket(this, nsp, opts);

won't get to "connect" before

socket.on('connect', function () {
  socket.id = self.generateId(nsp);
});

.

Are there any good reasons to make this assumption, aside from “the code path to handler-attaching just looks shorter (“cheaper”) than that of connection establishment?” How come this is not a race condition ?

Answer 1

You need an EventEmitter before to attach a connect event, additionally the socket.io-client library manages this scenario, take a look on:

https://github.com/socketio/socket.io-client/blob/master/lib/manager.js#L378