How does require() in node.js work?

Source code is here. exports/require are not keywords, but global variables. Your main script is wrapped before start in a function which has all the globals like require, process etc in its context.

Note that while module.js itself is using require(), that's a different require function, and it is defined in the file called "node.js"

Side effect of above: it's perfectly fine to have "return" statement in the middle of your module (not belonging to any function), effectively "commenting out" rest of the code

var mod = require('./mod.js');

The require is a function that takes one argument called path, in this case the path is ./mod.js

when the require is invoked, a sequences of tasks are happened:

1. call Module.prototype.require function declared in lib/module.js which assert that the path exists and was a string

2. call Module._load which is a function in lib/module.js that resolve the file through Module._resolveFilename(request, parent, isMain),

3. the Module._resolveFilename function is called and checks if the module is native (The native modules are returned by NativeModule function defined in lib/internal/bootstrap_node.js),if yes it will return the module else it checks the number of characters of the parh (Must 2 character at least) and some characters (the path must started by ./) via Module._resolveLookupPaths function defined in defined in lib/internal/bootstrap_node.js
4. check the directory that contains the file
5. If the path contains an extension (in our example yes: mod.js), the basename function defined in lib/path.js checks that the extension is "js"
6. then it will create a new module for the file given in argument var module = new Module(filename, parent);
7. the content will be compiled via v8 through the function NativeModule.prototype.compile defined in lib/internal/bootstrap_node.js
8. the NativeModule.wrap defined in lib/internal/bootstrap_node.js takes the javascript content compiled of mod.js and wraps it : It wraps it in some other code that makes all this work.So the code you've written in mod.js is wrapped in a function expression. that means everything you write in node is run in V8
9. a module.exports is what's returned

Andrey showed the source code, but if you also wonder how to use it, the easy and simple explanation is here (http://nodejs.org/api/modules.html).

These were two good examples for me.

//foo.js, multiple methodsvar circle = require('./circle.js');console.log( 'The area of a circle of radius 4 is ' + circle.area(4));//circle.jsvar PI = Math.PI;exports.area = function (r) {  return PI * r * r;};exports.circumference = function (r) {  return 2 * PI * r;};//bar.jsvar square = require('./square.js');var mySquare = square(2);console.log('The area of my square is ' + mySquare.area());//square.js, single methodmodule.exports = function(width) {  return {    area: function() {      return width * width;    }  };}

My favourite pattern is

(function (controller) {  controller.init = function (app) {    app.get("/", function (req, res) {        res.render("index", {});    });  };})(module.exports);