[转载]AMD 的 CommonJS wrapping

https://www.imququ.com/post/amd-simplified-commonjs-wrapping.html

它是什么？

为了复用已有的 CommonJS 模块，AMD 规定了 Simplified CommonJS wrapping，然后 RequireJS 实现了它（先后顺序不一定对）。它提供了类似于 CommonJS 的模块定义方式，如下：

define(function(require, exports, module) {

    var A = require(‘a‘);

    return function () {};

});

这样，模块的依赖可以像 CommonJS 一样「就近定义」。但就是这个看上去两全其美的做法，给大家带来了很多困扰。

它做了什么？

由于 RequireJS 是最流行的 AMD 加载器，后续讨论都基于 RequireJS 进行。

直接看 RequireJS 这部分逻辑：

//If no name, and callback is a function, then figure out if it a

//CommonJS thing with dependencies.

if (!deps && isFunction(callback)) {

    deps = [];

    if (callback.length) {

        callback

            .toString()

            .replace(commentRegExp, ‘‘)

            .replace(cjsRequireRegExp, function (match, dep) {

                deps.push(dep);

            });

        deps = (callback.length === 1 ? [‘require‘] : [‘require‘, ‘exports‘, ‘module‘]).concat(deps);

    }

}

可以看到，为了支持 CommonJS Wrapper 这种写法，define 函数里需要做这些事情：

  1. 通过 factory.toString() 拿到 factory 的源码；
  2. 去掉源码中的注释（避免匹配到注释掉的依赖模块）；
  3. 通过正则匹配 require 的方式得到依赖信息；

写模块时要把 require 当成保留字。模块加载器和构建工具都要实现上述逻辑。

对于 RequireJS，本文最开始定义的模块，最终会变成：

define([‘a‘], function(require, exports, module) {

    var A = require(‘a‘);

    return function () {};

});

等价于：

define([‘a‘], function(A) {

    return function () {};

});

结论是，CommonJS Wrapper 只是书写上兼容了 CommonJS 的写法，模块运行逻辑并不会改变。

AMD 运行策略

AMD 运行时核心思想是「Early Executing」，也就是提前执行依赖。这个好理解：

//main.js

define([‘a‘, ‘b‘], function(A, B) {

    //运行至此，a.js 和 b.js 已下载完成（运行于浏览器的 Loader 必须如此）；

    //A、B 两个模块已经执行完，直接可用（这是 AMD 的特性）；

    return function () {};

});

个人觉得，AMD 的这个特性有好有坏：

首先，尽早执行依赖可以尽早发现错误。上面的代码中，假如 a 模块中抛异常，那么 main.js 在调用 factory 方法之前一定会收到错误，factory 不会执行；如果按需执行依赖，结果是：1）没有进入使用 a 模块的分支时，不会发生错误；2）出错时，main.js 的 factory 方法很可能执行了一半。

另外，尽早执行依赖通常可以带来更好的用户体验，也容易产生浪费。例如模块 a 依赖了另外一个需要异步加载数据的模块 b，尽早执行 b 可以让等待时间更短，同时如果 b 最后没被用到，带宽和内存开销就浪费了；这种场景下，按需执行依赖可以避免浪费，但是带来更长的等待时间。

我个人更倾向于 AMD 这种做法。举一个不太恰当的例子：Chrome 和 Firefox 为了更好的体验，对于某些类型的文件，点击下载地址后会询问是否保存，这时候实际上已经开始了下载。有时候等了很久才点确认，会开心地发现文件已经下好； 如果点取消，浏览器会取消下载，已下载的部分就浪费了。

了解到 AMD 这个特性后，再来看一段代码：

//mod1.js

define(function() {

    console.log(‘require module: mod1‘);

    return {

        hello: function() {

            console.log("hello mod1");

        }

    };

});

//mod2.js

define(function() {

    console.log(‘require module: mod2‘);

    return {

        hello: function() {

            console.log("hello mod2");

        }

    };

});

//main.js

define([‘mod1‘, ‘mod2‘], function(mod1, mod2) {

    //运行至此，mod1.js 和 mod2.js 已经下载完成；

    //mod1、mod2 两个模块已经执行完，直接可用；

    console.log(‘require module: main‘);

    mod1.hello();

    mod2.hello();

    return {

        hello: function() {

            console.log(‘hello main‘);

        }

    };

});

<!--index.html-->

<script>

    require([‘main‘], function(main) {

        main.hello();

    });

</script>

在本地测试，通常结果是这样的：

require module: mod1

require module: mod2

require module: main

hello mod1

hello mod2

hello main

这个结果符合预期。但是这就是全部吗？用 Fiddler 把 mod1.js 请求 delay 200 再测试，这次输出：

require module: mod2

require module: mod1

require module: main

hello mod1

hello mod2

hello main

这是因为 main.js 中 mod1 和 mod2 两个模块并行加载，且加载完就执行，所以前两行输出顺序取决于哪个 js 先加载完。如果一定要让 mod2 在 mod1 之后执行，需要在 define 模块时申明依赖，或者通过 require.config 配置依赖：

require.config({

    shim: {

        ‘mod2‘: {

            deps : [‘mod1‘]

        }

    }

});

严重问题！

我们再回过头来看 CommonJS Wrapper 会带来什么问题。前面说过，AMD 规范中，上面的 main.js 等价于这样：

//main.js

define(function(require, exports, module) {

    //运行至此，mod1.js 和 mod2.js 已经下载完成；

    console.log(‘require module: main‘);

    var mod1 = require(‘./mod1‘); //这里才执行 mod1 ？

    mod1.hello();

    var mod2 = require(‘./mod2‘); //这里才执行 mod2 ？

    mod2.hello();

    return {

        hello: function() {

            console.log(‘hello main‘);

        }

    };

});

这种「就近」书写的依赖，非常容易让人认为 main.js 执行到对应 require 语句时才执行 mod1 或 mod2，但这是错误的，因为 CommonJS Wrapper 并不会改变 AMD「尽早执行」依赖的本质！

实际上，对于按需执行依赖的加载器，如 SeaJS，上述代码结果一定是：

require module: main

require module: mod1

hello mod1

require module: mod2

hello mod2

hello main

于是，了解过 CommonJS 或 CMD 模块规范的同学，看到使用 CommonJS Wrapper 方式写的 AMD 模块，容易产生理解偏差，从而误认为 RequireJS 有 bug。

我觉得「尽早执行」或「按需执行」两种策略没有明显的优劣之分，但 AMD 这种「模仿别人写法，却提供不一样的特性」这个做法十分愚蠢。这年头，做自己最重要！

其他问题

还有一个小问题也顺带提下：默认情况下，定义 AMD 模块时通过参数传入依赖列表，简单可依赖。而用了 CommonJS Wrapper 之后，RequireJS 需要通过正则从 factory.toString() 中提取依赖，复杂并容易出错。如 RequireJS 下这段代码会出错：

define(function(require, exports, module) {

    ‘/*‘;

    var mod1 = require(‘mod1‘),

        mod2 = require(‘mod2‘);

    ‘*/‘;

    mod1.hello();

});

//Uncaught Error: Module name "mod1" has not been loaded yet for context: _

当然，这个因为 RequireJS 的正则没写好，把正常语句当注释给过滤了，SeaJS 用的正则处理上述代码没问题，同时复杂了许多。

虽然实际项目中很难出现上面这样的代码，但如果放弃对脑残的 CommonJS Wrapper 支持后，再写 AMD 加载器就更加简单可靠。例如雨夜带刀同学写的 seed，代码十分简洁；构建工具通常基于字符串分析，仍然需要过滤注释，但可以采用 uglifyjs 压缩等取巧的方法。

考虑到不是每个 AMD Loader 都支持 CommonJS Wrapper，用参数定义依赖也能保证更好的模块通用性。至于「就近」定义依赖，我一直觉得可有可无，我们写 php 或 python 时，include 和 import 都会放在顶部，这样看代码时能一目了然地看到所有依赖，修改起来也方便。

本文部分示例来自于 SeaJS 与 RequireJS 最大的区别，致谢！

时间： 2024-10-02 19:06:23

[转载]AMD 的 CommonJS wrapping的相关文章

AMD 的 CommonJS wrapping

其实本文的标题应该是「为什么我不推荐使用 AMD 的 Simplified CommonJS wrapping」,但太长了不好看,为了美观我只能砍掉一截. 它是什么? 为了复用已有的 CommonJS 模块,AMD 规定了 Simplified CommonJS wrapping,然后 RequireJS 实现了它(先后顺序不一定对).它提供了类似于 CommonJS 的模块定义方式,如下: JSdefine(function(require, exports, module) { var A

前端模块规范AMD/UMD/CommonJs

.babelrc文件中的:module设置为false,为什么会要设置成false? 解释:使ES6模块语法转换到另一个模块类型(默认启用“commonjs”). 设置为假则不变换模块.或者传入(“amd”.“umd”,“systemjs”.“commonjs”). 什么是模块? Javascript的组件生态在最近几年的发展很给力,我们的可选性更加广泛了.这本是一件好事,但是当多个第三方Javascript在一起混合使用的时候,我们可能会遇到一个很尴尬的问题,那就是不是所有的组件都能在一起很愉

兼容AMD和COMMONJS的模块写法

兼容AMD和COMMONJS写法——定义兼容node环境和浏览器(AMD)环境的模块 // 兼容AMD和COMMONJS写法 (function (factory) { // node环境 if (typeof require === 'function' && typeof exports === 'object' && typeof module === 'object') { factory(require, exports, module); } // 浏览器AMD

FW: AMD, CMD, CommonJS和UMD

javascript 我是豆腐不是渣 4月5日发布 推荐 2 推荐 收藏 32 收藏,486 浏览 今天由于项目中引入的echarts的文件太大,requirejs经常加载超时,不得不分开来加载echarts的各个图表.但是使用echarts自带的在线构建工具生成的支持AMD 标准的模块报错,所以不得不使用echarts的全局函数,使用requirejs的shim进行加载.借此机会学习一下AMD, CMD, CommonJS和UMD各自的规范,和它们之间的区别. Javascript模块化 在了

AMD/CMD/CommonJs的区别

AMD/CMD/CommonJs是js模块化开发的标准,目前对应的实现是RequireJs/SeaJs/nodeJs. CommonJs 主要针对服务器端,AMD/CMD 主要针对浏览器端. 服务器端和浏览器端有什么区别呢? 服务器端一般采用同步加载文件,也就是说需要某个模块,服务器便停下来,等待它加载再执行,而浏览器要保证效率,需要采用异步加载,这就需要一个预处理,提前将说需要的模块并行加载好. AMD和CMD的区别,虽然都是并行加载文件,但还是有所区别,AMD是预加载,在并行加载js文件同时

AMD,CMD.CommonJs和UMD还有es6的模块化对比

CommonJS CommonJS是服务器端模块的规范,Node.js采用了这个规范. 根据CommonJS规范,一个单独的文件就是一个模块.加载模块使用require方法,该方法读取一个文件并执行,最后返回文件内部的exports对象. 例如: // foobar.js //私有变量 var test = 123; //公有方法 function foobar () { this.foo = function () { // do someing ... } this.bar = functi

AMD vs. CommonJS？

js开发者对js模块加载的尝试和创新从来都没有停止过,尤其是当nodejs的出现后,模块化加载的必要性更加凸显.本文不讨论如何在nodejs环境来模块化加载(创造者已经利用commonJS机制解决),只讨论在浏览器环境下如何来模块加载的思路,并提出一些我的看法. 浏览器环境与nodejs的环境的最大差异是,对于nodejs的环境,大多数情况下被依赖的模块文件本身就在本地(它们都在服务器上),同步取过来就能用:而对于浏览器的环境,被依赖的模块文件通常还在远程服务器上,并未加载到本地,也就是说必须是

把自己的js模块兼容到AMD CMD CommonJS

为了让同一个模块可以运行在前后端,在写作过程中需要考虑兼容前端也实现了模块规范的环境.为了保持前后端的一致性,类库开发者需要将类库代码包装在一个闭包内.以下代码演示如何将hello()方法定义到不同的运行环境中,它能够兼容Node(CommonJS),AMD,CMD以及常见的浏览器环境中: (function (name, definition) { //检测上下文环境是否为AMD或CMD var hasDefine = typeof define === 'function'; //检查上下文

amd cmd commonjs 模块规范 和 es6 的 module 语法

js的模块化 在前端开发的原始时期,只要在script标签中嵌入js代码就能实现一些基本的交互效果,但是随着时代的进步.js扮演的角色变得重要起来,js应用的场景页越来越复杂,.然而,js都没有类的概念,更不用说模块了. 为什么要有模块化 当一个项目变得复杂的时候,会出现问题,比如:命名冲突:开发中重复命名,导致命名冲突.文件依赖:项目开发中,依赖的js文件,引入遗漏,引入顺序错误. 使用模块化开发可以避免类似情况,而且利于项目的维护:提升开发效率:代码方便重用,能直接引入,避免重复开发.方便后