What is happening when require("http").Server() is evaluated with an Express app as its argument?

I was reading the Socket.io Chat Demo here: http://socket.io/get-started/chat/
and I got confused when looking at their require statements.

var app = require('express')();
var http = require('http').Server(app);
var io = require('socket.io')(http);

app.get('/', function(req, res){

io.on('connection', function(socket){
console.log('a user connected');

http.listen(3000, function(){
console.log('listening on *:3000');

Am I correct in thinking that require("express") produces an executable Express function (with all of the necessary functions and fields that go with that), and that require("http").Server(app) creates a http.Server object with all of its fields and functions.

If so, I am confused because Express creates a server when we call the .listen function so it seems redundant and backwards to pass an Express app to an http module server.

So, my question is, what is really happening here?

Here is Solutions:

We have many solutions to this problem, But we recommend you to use the first solution because it is tested & true solution that will 100% work for you.

Solution 1

The http server expects a function which has the following signature:

function(req, res)

require('express')(); will create a function with that signature which handles all the magic that express makes available like routing, middleware, etc. Express can create it’s own http server instance, but since you’re also using socket.io (which expects access to the http server as well), you’ll need a separate http instance.

Solution 2

var app = require('express')(); //infact, app is a requestListener function. 

var http = require('http').Server(app); // infact, function Server eqs http.createServer;

// infact,app.listen eqs http.listen 

other code from nodejs and express model

we can see, require(“express”)() return app is a function.

//express/lib/express.js   https://github.com/strongloop/express/blob/master/lib/express.js

var proto = require('./application');

exports = module.exports = createApplication;

function createApplication() {
  var app = function(req, res, next) {
    app.handle(req, res, next);

  mixin(app, EventEmitter.prototype, false);
  mixin(app, proto, false);

  app.request = { __proto__: req, app: app };
  app.response = { __proto__: res, app: app };
  return app;

we can see, node.createServer eqs Server

//nodejs/lib/http.js  https://github.com/nodejs/node/blob/master/lib/http.js

exports.createServer = function(requestListener) {
  return new Server(requestListener);

we can see, express app.listen eqs http.listen

//express/lib/application.js  https://github.com/strongloop/express/blob/master/lib/application.js

app.listen = function listen() {
  var server = http.createServer(this);
  return server.listen.apply(server, arguments);

//nodejs/lib/_http_server.js  https://github.com/nodejs/node/blob/master/lib/_http_server.js

function Server(requestListener) {
  if (!(this instanceof Server)) return new Server(requestListener);
  net.Server.call(this, { allowHalfOpen: true });

  if (requestListener) {
    this.addListener('request', requestListener);

  this.httpAllowHalfOpen = false;

  this.addListener('connection', connectionListener);

  this.addListener('clientError', function(err, conn) {

Solution 3

const app = express();
let server = require('http').Server(app);

This makes the server listening to the port we provide.

const app = express();
let server = require('http').createServer(app);

So Server and createServer are the same according to the node.js HTTP library source code.

Ref : nodejs/lib/http.js

exports.Server = Server;

exports.createServer = function(requestListener) {
  return new Server(requestListener);


Note: Use and implement solution 1 because this method fully tested our system.
Thank you 🙂

All methods was sourced from stackoverflow.com or stackexchange.com, is licensed under cc by-sa 2.5, cc by-sa 3.0 and cc by-sa 4.0

Leave a Reply