1. configuration(可选，默认为 undefined): 一个loader的配置对象， 它允许你在运行的时候重新配置loader.
2. dependencies(可选，默认为 空数组[]): 一个包含模块标识符的数组， 如果指定了这个参数， 这些模块会在你的代码运行前被解析。 它们会依据有列表里的顺序加载，也按照列表里的顺序作为参数传递给回调函数。
3. 回调函数: 一个函数，里面包含你想要运行的代码，这个函数依赖的模块在会上一个参数dependencies指定。 为了支持异步加载及能够使用这些代码的非全局引用，所以你必须将代码封装在这个回调函数里面。

require({
    baseUrl: "/js/",packages: [
        { name: "dojo",location: "//ajax.googleapis.com/ajax/libs/dojo/1.9.2/" },{ name: "my",location: "my" }
    ]
},[ "my/app" ]);

探究更深层次的define

// in "my/nls/common.js"
define({
    greeting: "Hello!",howAreYou: "How are you?"
});

loader 是如何工作的？

// my/app.js

defined("5")

// index.html

require(["my/app"],function(app){
    console.log(app);  //output 5
})

<script data-dojo-config="async: true" src="js/lib/dojo/dojo.js"></script>

var dojoConfig = {
    baseUrl: "/js/",//服务器绝对路径，如果需要相对于index.html,请指定为./js/
    tlmSiblingOfDojo: false,location: "lib/dojo" },{ name: "dijit",location: "lib/dijit" },{ name: "dojox",location: "lib/dojox" },location: "my",main: "app" }
    ]
};

/js/my/widget/Person.js

/
    js/
        dojo/
        dijit/
        dojox/
        my/
        util/

• name: 包的名称. 它应该与模块组的文件夹名称相同
• location: 包的路径; 可以是一个相对于baseUrl的相对路径，也可以是一个绝对路径。 我们更希望于从dojo package来加载模块，而不是路径的方式如”dojo/dom" 而不是"lib/dojo/dom"(再看看本文开头的文件结构）， 所以我们指定dojo包的 location属性为"lib/dojo". 它会告知loader，试图加载"dojo/dom"模块都应该是加载"/js/lib/dojo/dom.js"文件（记住， baseUrl "js" 文件夹会被添加到文件名的前面）
• main (可选，默认为 main.js): 如果只是指定了包的名字，那么指定的这个文件会被当成包的入口文件。 例如， 如果你请求”dojo"，那么实际被加载的文件是"js/dojo/main.js". 由于我们在"my" package 里面重写了这个属性， 如果有人请求"my",他们将实际加载的是 "js/my/app.js".

dojoConfig = {
    packages: [
        { name: "dojo16",location: "lib/dojo16" },{ name: "dijit16",location: "lib/dijit16" },{ name: "dojox16",location: "lib/dojox16" },{ name: "dojo",{ name: "myOldApp",location: "myOldApp" },location: "my" }
    ],map: {
        myOldApp: {
            dojo: "dojo16",dijit: "dijit16",dojox: "dojox16"
        }
    }
};

• （行3-5) 首先我们定义了3个包，3个包的路径指向包含dojo 1.6版本的文件夹
• （行6-8) 接着我们定义了当前dojo版本的包
• （行9-10）我们定义了自己开发的老版本及新版本的代码。
• （行12-18） 我们定了了一个map配置: 它只在 "myOldApp" 模块内有效， 在“myOldApp"内的所有请求"dojo","dijit' 以及 "dojox" 都映射到"dojo16","dijit16' 以及 "dojox16".
• "my" 包内的模块请求dojo,digit,dojox包中的模块，都将使用dojo当前的版本。

// in "my/widget/NavBar.js"
define([
    "dojo/dom","my/otherModule","my/widget/InfoBox"
],function(dom,otherModule,InfoBox){
    // …
});

// in "my/moduleA.js"
define([ "./moduleB" ],function(moduleB){
    return {
        getValue: function(){
            return "oranges";
        },print: function(){
            // dependency on moduleB
            log(moduleB.getValue());
        }
    };
});
 
// in "my/moduleB.js"
define([ "./moduleA" ],function(moduleA){
    return {
        getValue: function(){
            // dependency on moduleA
            return "apples and " + moduleA.getValue();
        }
    };
});
 
// in "index.html"
require([
    "my/moduleA"
],function(moduleA) {
    moduleA.print();
});

1. 解析传递给require的依赖（在index.html)的模块： moduleA
2. 解析moduleA的依赖：moduleB
3. 解析moduleB的依赖：moduleA
4. 检测加载器当前正在尝试处理解析moduleA（即发现这是循环调用）
5. 临时地将解析moduleA设置为空数组，退出循环依赖
6. 通过调用moduleB的工厂函数，恢复moduleB的解析。 代表moduleA的空对象会被传到给工厂函数。
7. 设置moduleB的引用为工厂函数返回的值。
8. 通过调用moduleA的工厂函数，继续moduleA的解析。
9. 设置moduleA的引用为工厂函数的返回值， 虽然整个loader现在引用了一个有效的值。但是moduleB依然引用的是一个空对象。
10. 执行moduleA.print - 由于moduleB 只是引用到一个空对易用。 当调用moduleA.getValue时会获得一个错误。

// in "my/moduleA.js"
define([ "./moduleB",exports){
    exports.isValid = true;
 
    exports.getValue = function(){
        return "oranges";
    };
 
    exports.print = function(){
        // dependency on moduleB
        log(moduleB.getValue());
    }
});
 
// in "my/moduleB.js"
define([ "./moduleA" ],function(moduleA){
    // this code will run at resolution time,when the reference to  这段代码将运行在模块解析时， 这时引用的模块A为一个空对象，所以moduleA.isValid 是一个undefined.
    // moduleA is an empty object,so moduleA.isValid will be undefined
    if(moduleA.isValid){
        return {
            getValue: function(){
                return "won't happen";
            }
        };
    }
 
    // this code returns an object with a method that references moduleA  这段代码将会返回一个引用了moduleA的方法的对象，getValue不能在moduleA没有被实际解析之前调用。 由于模块A中使用了exports. 所以可以调用moduleA的getValue()方法.
    // the "getValue" method won't be called until after moduleA has       
    // actually been resolved,and since it uses exports,the "getValue"
    // method will be available
    return {
        getValue: function(){
            return "apples and " + moduleA.getValue();
        }
    };
});
 
// in "index.html"
require([
    "my/moduleA"
],function(moduleA) {
    moduleA.print();
});

加载非AMD规范的代码

• 以 "/" 开头的标识符
• 以协议开头的标识符（如”http:","https")
• 标识符以".js" 结尾

// in "my/legacyModule.js"
dojo.provide("my.legacyModule");
my.legacyModule = {
    isLegacy: true
};

# node.js:
node path/to/dojo.js load=my/serverConfig load=my/app
 
# rhino:
java -jar rhino.jar path/to/dojo.js load=my/serverConfig load=my/app

<script data-dojo-config="async: true" src="path/to/dojo.js"></script>
<script>require(["my/serverConfig","my/app"]);</script>