How to uniquely identify a socket with Node.js

TLDR; How to identify sockets in event based programming model.

I am just starting up with node.js , in the past i have done most of my coding
part in C++ and PHP sockets() so node.js is something extremely new to me.

In c++ to identify a socket we could have done something like writing a main socket say server to listen for new connections and changes, and then handling those connections accordingly.

If you are looking for actual sockets and not socket.io, they do exist.

But as stated, Node.js and Javascript use an event-based programming model, so you create a (TCP) socket, listen on an IP:port (similar to bind), then accept connection events which pass a Javascript object representing the connection.

From this you can get the FD or another identifier, but this object is also a long-lived object that you can store an identifier on if you wish (this is what socket.io does).

var server = net.createServer();

server.on('connection', function(conn) {
  conn.id = Math.floor(Math.random() * 1000);
  conn.on('data', function(data) {
    conn.write('ID: '+conn.id);
  });
});
server.listen(3000);

Timothy’s approach is good, the only thing to mention – Math.random() may cause id’s duplication. So the chance it will generate the same random number is really tiny, but it could happen. So I’d recommend you to use dylang’s module – shortid:

var shortid = require('shortid');
var server = net.createServer();

server.on('connection', function(conn) {
  conn.id = shortid.generate();
  conn.on('data', function(data) {
    conn.write('ID: '+conn.id);
  });
});
server.listen(3000);

So in that case you can be sure that no id duplications will occur.

in typescript:

import { v4 as uuidv4 } from 'uuid';
import net from 'net';
class Socket extends net.Socket {
  id?: string;
}

const server = net.createServer();

server.on('connection', (conn) => {
  conn.id = uuidv4();
  conn.on('data', (data) => {
      console.log(conn.id);
  });
});
server.listen(3000);

you need to add id first;

In c++ to identify a socket we could have done something like writing
a main socket say server to listen for new connections and then
handling those connections accordingly.but so far i havent found
anything like that in node.js . (the berkeley socket model) Does it
even exist in node.js .. if not i am going back to my C++ :$

You should go back, because JavaScript is a prototype-based, object-oriented scripting language that is dynamic, weakly typed and has first-class functions. They are both completely different languages and you will have to have a different mindset to write clean JavaScript code.

https://github.com/LearnBoost/Socket.IO/wiki/Migrating-0.6-to-0.7

Session ID

If you made use of the sessionId property of socket in v0.6, this is now simply .id.

// v0.6.x
var sid = socket.sessionId;

// v0.7.x
var sid = socket.id;

if you found this question by looking for socket.io unique ids that you can use to differentiate between sockets on the client-side (just like i did), then here is a very simple answer:

var id = 0; //initial id value
io.sockets.on('connection', function(socket) {

    var my_id = id; //my_id = value for this exact socket connection
    id++; //increment global id for further connnections

    socket.broadcast.emit("user_connected", "user with id " + my_id + "connected");
}

on every new connection the id is incremented on the serverside. this guarantees a unique id.
I use this method for finding out where a broadcast came from on the clientside and saving data from concurrent sockets.

for example:

server-side

var my_coords = {x : 2, y : -5};
socket.broadcast.emit("user_position", {id: my_id, coord: my_coords});  

client-side

user = {};
socketio.on("user_position", function(data) {
    if(typeof user[data.id] === "undefined")
        user[data.id] = {};

    user[data.id]["x"] = data.coord.x;
    user[data.id]["y"] = data.coord.y;
});

How to identify a client based on its socket id. Useful for private messaging and other stuff.

Using socket.io v1.4.5

client side:

var socketclientid = "john"; //should be the unique login id
var iosocket = io.connect("http://localhost:5000", {query: "name=john"});

var socketmsg = JSON.stringify({
  type: "private messaging",
  to: "doe",
  message: "whats up!"
});                        
iosocket.send(socketmsg);

server side:

io.on('connection', function(socket){
  var sessionid = socket.id;
  var name = socket.handshake.query['name'];
  //store both data in json object and put in array or something

socket.on('message', function(msg){
  var thesessionid = socket.id;      
  var name = ???? //do lookup in the user array using the sessionid
  console.log("Message receive from: " + name);

  var msgobject = JSON.parse(msg);
  var msgtype = msgobject.type;
  var msgto = msgobject.to;
  var themessage = msgobject.message;

  //do something with the msg
  //john want to send private msg to doe
  var doesocketid = ???? //use socket id lookup for msgto in the array
                         //doe must be online
  //send to doe only
  if (msgtype == "private messaging") 
     socket.to(doesocketid).emit('message', 'themessage');

});

mmmm, i don’t really get what you’re looking for but socket-programming with node.js (and socket.io) is really straight forward. take a look at some examples on the socket.io homepage:

// note, io.listen() will create a http server for you
var io = require('socket.io').listen(80);

io.sockets.on('connection', function (socket) {
  io.sockets.emit('this', { will: 'be received by everyone connected'});

  socket.on('private message', function (from, msg) {
    console.log('I received a private message by ', from, ' saying ', msg);
  });

  socket.on('disconnect', function () {
    sockets.emit('user disconnected');
  });
});

on connecting to the server, every socket get an unique id with which you can identify it later on.

hope this helps!?
cheers