js兼容多种模块规范，使用require加载JSLite方法

时间 2020-01-06

标签兼容多种模块规范使用 require 加载 jslite 方法栏目 JavaScript 繁體版

原文原文链接

使用require加载JSLite、zepto、jQuery方法，它们是同类型的库因此加载方式同样，下面是一个实例。javascript

requirejs 引用实例方法

RequireJS的目标是鼓励代码的模块化，它使用了不一样于传统<script>标签的脚本加载步骤。能够用它来加速、优化代码，但其主要目的仍是为了代码的模块化。它鼓励在使用脚本时以module ID替代URL地址。html

目录结构

去RequireJS官网下载，将require.js 放入到lib目录；下载JSLite 1.1.5 放到lib目录中。github

├── app.js
├── index.html
└── lib
    ├── JSLite.js
    ├── extend-jslite.js
    └── require.js

文件内容

app.jsweb

requirejs.config({
  paths: {
      jslite:'lib/extend-jslite',
      // zepto:'lib/zepto'
  }
});
require(['jslite'], function(j) {
    console.log("z,$:",j('body'))
});

index.html编程

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Document</title>
    <script type="text/javascript" data-main="app.js" src="lib/require.js"></script>
</head>
<body>
</body>
</html>

extend-jslite.jsapi

define([
    'lib/JSLite'
], function(a) {
    "use strict";
    window.JSLite = JSLite
    // If `$` or `jQuery` is not yet defined, point them to `JSLite`
    '$' in window || (window.$ = JSLite)
    'jQuery' in window || (window.jQuery = JSLite)
    return JSLite;
});

竞争者

systemjs数组
browserify
webpack | github 我更喜欢这个玩意儿

webpack

AMD 或者 CommonJS – 两个它都支持。构建配置比 RequireJS 更加易于理解，也更具访问性。经过它的热插拔特性和内置的本地静态服务器可让发布更加便捷。

名词解释

CommonJS

CommonJs 是服务器端模块的规范，Node.js采用了这个规范。

根据CommonJS规范，一个单独的文件就是一个模块。加载模块使用require方法，该方法读取一个文件并执行，最后返回文件内部的exports对象。

模块文件foobar.js

//私有变量
var test = 123;
//公有方法
function foobar () {
    this.foo = function () {
        // do someing ...
    }
    this.bar = function () {
        //do someing ...
    }
}
 
//exports对象上的方法和变量是公有的
var foobar = new foobar();
exports.foobar = foobar;

require方法默认读取foobar.js文件，能够省略js后缀

var test = require('./foobar').foobar;
test.bar();

CommonJS 加载模块是同步的，因此只有加载完成才能执行后面的操做。像Node.js主要用于服务器的编程，加载的模块文件通常都已经存在本地硬盘，因此加载起来比较快，不用考虑异步加载的方式，因此CommonJS规范比较适用。但若是是浏览器环境，要从服务器加载模块，这是就必须采用异步模式。因此就有了 AMD CMD 解决方案。
A Gentle Browserify Walkthrough

AMD

AMD(Asynchromous Module Definition)是 RequireJS 在推广过程当中对模块定义的规范化产出
AMD异步加载模块。它的模块支持对象函数构造器字符串 JSON等各类类型的模块。
适用AMD规范适用define方法定义模块。

//经过数组引入依赖 ，回调函数经过形参传入依赖
define(['someModule1', 'someModule2'], function (someModule1, someModule2) {
 
    function foo () {
        /// someing
        someModule1.test();
    }
 
    return {foo: foo}
});

AMD规范容许输出模块兼容CommonJS规范，这时define方法以下：

define(function (require, exports, module) {
     
    var reqModule = require("./someModule");
    requModule.test();
     
    exports.asplode = function () {
        //someing
    }
    return exports;
});

CMD

CMD是SeaJS 在推广过程当中对模块定义的规范化产出

CMD和AMD的区别有如下几点：

1.对于依赖的模块AMD是提早执行，CMD是延迟执行。不过RequireJS从2.0开始，也改为能够延迟执行（根据写法不一样，处理方式不经过）。

2.CMD推崇依赖就近，AMD推崇依赖前置。

//AMD
define(['./a','./b'], function (a, b) {
 
    //依赖一开始就写好
    a.test();
    b.test();
});
 
//CMD
define(function (requie, exports, module) {
     
    //依赖能够就近书写
    var a = require('./a');
    a.test();
     
    ...
    //软依赖
    if (status) {
     
        var b = requie('./b');
        b.test();
    }
});

虽然 AMD也支持CMD写法，但依赖前置是官方文档的默认模块定义写法。

3.AMD的api默认是一个当多个用，CMD严格的区分推崇职责单一。例如：AMD里require分全局的和局部的。CMD里面没有全局的 require,提供 seajs.use()来实现模块系统的加载启动。CMD里每一个API都简单纯粹。
区别的详细解释

UMD兼容多种模块规范

umd是AMD和CommonJS的糅合
AMD 浏览器第一的原则发展异步加载模块。
CommonJS 模块以服务器第一原则发展，选择同步加载，它的模块无需包装(unwrapped modules)。
这迫令人们又想出另外一个更通用的模式UMD （Universal Module Definition）。但愿解决跨平台的解决方案。

UMD先判断是否支持Node.js的模块（exports）是否存在，存在则使用Node.js模块模式。
在判断是否支持AMD（define是否存在），存在则使用AMD方式加载模块。

兼容多种模块规范

(function (root, factory) {
    var JSLite = factory(root);
    if (typeof define === 'function' && define.amd) {
        // AMD
        // define([], factory);
        define('JSLite', function() { return JSLite; });
    } else if (typeof exports === 'object') {
        // Node.js
        module.exports = JSLite;
    } else {
        // Browser globals
        root.JSLite = JSLite;
    }
})(this, function () {
    //module ...
});

兼容多种模块规范

;(function(name,definition){
    //检测上下文环境是否为AMD或CMD
    var hasDefine = typeof define === 'function',
        // 检测上下文环境是否为Node
        hasExports = typeof module !== 'function' && module.exports;
    if(hasDefine){
        //AMD环境或CMD环境
        define(definition);
    }else if(hasExports){
        //定义为普通Node模块
        module.exports = definition();
    }else{
        //将模块的执行结果挂在window变量中，在浏览器中this指向window对象
        this[name] = definition();
    }

})('hello',function(){
    var hello = function(){}
    return hello
})

关注公众号