CommonJS wrapper and AMD define

RequireJS has many ways of defining a module, this document will cover the 2 ways of defining a module which contain dependencies, the standard AMD define and the simplified CommonJS wrapper, both ways can be used on the same project and toggled at will, but it’s important to understand how both patterns differs and the problems that may arise.

Table of Contents

Standard AMD define

The basic definition of an AMD module is like this:

define(['foo', 'foo/bar'], function(foo, bar){
    return {
        doSomething : function(){
            console.log(foo + bar);

This means that modules foo and foo/bar will be loaded (if not available yet) before the definition function gets called and it will pass both modules as arguments to the definition function. More about it on the RequireJS API page

So how does it work?

  1. RequireJS reads the dependency array.
  2. Then it checks if each module was already registered for the current context:
    1. If module was registered uses it;
    2. Otherwise:
      1. resolve the ID into a URI by checking the paths.config and current module path;
      2. loads script;
      3. If AMD module, repeat steps till all the dependencies are loaded.
  3. After all the dependencies are ready it calls the definition function passing the dependencies as arguments, it will then register the module as the value returned by the definition function.

Simplified CommonJS wrapper

If you prefer to author your modules as if it was a CommonJS module (specially if you have a very large dependency array) you can use the simplified CommonJS wrapper.

define(function(require, exports, module){
    var foo = require('foo'),
        bar = require('foo/bar');

    exports.doSomething = function(){
        console.log(foo + bar);

A module is only treated as a CJS module if it doesn’t contain a dependency array and the definition function contain at least one parameter.

More info about the Simplified CJS Wrapper at RequireJS documentation.

How does it work?

  1. RequireJS checks if define was called without a dependency array.
  2. Then it checks if the definition function contains any parameters by readingFunction.prototype.length.
    1. If it contains, treats the module as CJS:
      1. Call Function.prototype.toString() and read all the synchronousrequire() calls inside the definition function.
      2. Load all dependencies like if it was on the dependency list of a standard AMD module (see step 2 of “standard AMD define”).
      3. After dependencies are ready it calls the definition function passing the special modules require, exports and module as arguments, then registers module as returned value or as value set as module.exports or the exports object itself.
    2. If not, execute definition function and register module as returned value. (standard AMD without any dependencies)

Notes about synchronous require()

On a standard AMD module you can use a synchronous require() as long as the module was already registered for that context:

define(['require', 'lorem/ipsum'], function(require){
    // since 'lorem/ipsum' is on the dependency list it will be registered
    // before calling the definition function, so the synchronous require will
    // also work
    console.log( require('lorem/ipsum') );

But this would fail if the module dolor/amet wasn’t registered yet:

define(['require'], function(require){
    console.log( require('dolor/amet') );

Since we are passing a dependency array as first argument of the define call it will treat the module as a standard AMD module, so it won’t read the definition function content to figure out the dependencies before calling it. You would get the following error:

Uncaught Error: Module name ‘dolor/amet’ has not been loaded yet for context: _

more info

But if you use the Simplified CommonJS Wrapper instead it would load the dependency before calling the definition function:

    // this will work since RequireJS will treat module as CJS
    console.log( require('dolor/amet') );

Magic modules

The special modules require, exports and module are also available for standard AMD modules.


define(['exports'], function(exports){
    //add properties to the exports object as if the module was a CJS module = 'bar';
    exports.lorem = function(){

Properties added to the exports object will be on the public interface of the module, no need to return any value.


This module gives you information about the module ID and location of the current module:

define(['module'], function(module){


The previous examples used the require module to load other dependencies but it also contains.

  • require.toUrl(moduleName) : It will return a full path to the resource, obeying any RequireJS configuration.


My other post about require, module, exports


Leave a Reply

Fill in your details below or click an icon to log in: Logo

You are commenting using your account. Log Out /  Change )

Google+ photo

You are commenting using your Google+ account. Log Out /  Change )

Twitter picture

You are commenting using your Twitter account. Log Out /  Change )

Facebook photo

You are commenting using your Facebook account. Log Out /  Change )


Connecting to %s