CODEWITHSUNDEEP
node.jsnpmsocket.io
md venkatesh
md venkatesh

Reputation: 157

How node-modules are implemented in node.js , how function implemention and creating instance are same in socket.io

const io = require('socket.io')();
// or
const Server = require('socket.io');
const io = new Server();

I am confused with following syntax

1) what is socket.io (is it a class or interface i checked the documention in node.js it showed be interface )

2)If it is interface i think we have to use class for using it (i didn't see any documentation to implement interface in javascript )

3) for understanding i tried the following (created 2 files)

example.js

module.exports =  function () {
  console.log("welcome to javascript");
}

use.js

let imp = require('./example')()

From following Link i have learned about require [https://nodejs.org/en/knowledge/getting-started/what-is-require/][1]

Now i am confused how socket is implemented and how the following 2 syntax's are equal

If socket is a function we can call by 

const io = require('socket.io')();

If it is a class we generally do the following (create a instance and use it )

const Server = require('socket.io');
const io = new Server();

But in the documention they said both the syntax are equal how ?

One is for excuting the module.exports and one is used for instancing a class how both are equal

Upvotes: 0

Views: 183

Answers (1)

jfriend00
jfriend00

Reputation: 707336

When you do this:

let x = require('someModule');

The value of x is whatever the module sets the module.exports value to in the module. It can literally be anything. It's entirely up to the module what they assign to that. It is often an object (with properties), but it can also be a function and sometimes it's even a function with properties.

To see what socket.io assigns to module.exports, we can go right to the source where we see:

module.exports = Server;

So, then we go look at what is Server and find this:

function Server(srv, opts){
  if (!(this instanceof Server)) return new Server(srv, opts);
  if ('object' == typeof srv && srv instanceof Object && !srv.listen) {
    opts = srv;
    srv = null;
  }
  opts = opts || {};
  this.nsps = {};
  this.parentNsps = new Map();
  this.path(opts.path || '/socket.io');
  this.serveClient(false !== opts.serveClient);
  this.parser = opts.parser || parser;
  this.encoder = new this.parser.Encoder();
  this.adapter(opts.adapter || Adapter);
  this.origins(opts.origins || '*:*');
  this.sockets = this.of('/');
  if (srv) this.attach(srv, opts);
}

From that, we can see that it is a constructor function that can be called as either:

const x = new Server(...);

or as:

const x = Server(...);

So, the answer is as follows:

require('socket.io') gives you a constructor function.

That constructor function can be caller either with new or just as a regular function and it adapts to return the same thing, a new server object.

So, when you do this:

const server = require('socket.io')();

it first gets the exported constructor function and then calls it and assigns the newly created object to the server variable.

1) what is socket.io (is it a class or interface i checked the documentation in node.js it should be interface )

socket.io on the server exports a constructor function for creating a server object. It can be called either as a regular function or with new.

2)If it is interface i think we have to use class for using it (i didn't see any documentation to implement interface in javascript )

It's a function. Javascript doesn't have a specific type called an interface. The socket.io code defines a constructor the older fashioned way (before the class keyword existed) though the outcome is largely the same. It defines a constructor function that, when called will create an object of the desired type.

3) Now i am confused how socket is implemented and how the following 2 syntax's are equal

In Javascript, these two different pieces of code create the same server object:

const io = require('socket.io');
const server = io();

and

const server = require('socket.io')();

The second is just a shortcut that doesn't assign the intermediate result from require('socket.io') to a variable, but rather just calls it directly. It will work like this only when the first function call returns a function. So, the first syntax gets a function, assigns it to the io variable and then calls it. The second syntax gets the function and immediately calls it without assigning it to a variable. In both cases the result of getting the function and calling it ends up in the server variable.

Upvotes: 2

Related Questions