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

Question

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){
res.sendfile('index.html');
});

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?

Answer 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.

Answer 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 };
  app.init();
  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) {
    conn.destroy(err);
  });