JSコードのモジュール化を実装する方法

なぜモジュール パターンを使用するのでしょうか?

グローバル スコープで宣言された変数と関数は自動的にグローバル オブジェクト Window のプロパティになるため、多くの場合、グローバル変数が増えると、名前の競合やいくつかの非常に重要な保守性の問題が発生します。バグが発生する可能性が高くなります! したがって、モジュール化の目的の 1 つは、この問題を解決することです

このモードでは、アプリケーションのシナリオが少なくなります。すべてのコードは IIFE (即時実行される匿名関数) を通じてパッケージ化されているため、すべての変数と関数は関数内に隠されており、グローバルな状況を汚染しません。

使用シナリオ:

コードが他のコードに依存しない場合

• 実行時にコードを継続的に拡張または変更する必要がない場合。コードは短く、他のコードと対話する必要はありません。単一グローバル変数モードは、グローバル変数を作成することのみを意味し、グローバル変数の名前は一意である必要があり、他のコードと競合してはなりません。現在または将来の組み込み API をすべてこのグローバル変数にマウントします。

• これは、次のようなさまざまな人気のあるクラス ライブラリで広く使用されています:

• YUI は唯一の YUI グローバル オブジェクトを定義します

JQuery は 2 つのグローバル オブジェクト $ と JQuery を定義します

Dojo は dojo グローバル オブジェクトを定義します

Closure は goog グローバル オブジェクトを定義します

例:

var Mymodule= {}; 
 
Mymodule.Book = function(){...}; 
Mymodule.Book.prototype.getName = function(){....}; 
 
Mymodule.Car = function(){...}; 
Mymodule.Car.prototype.getWheels = function(){....};

1. の定義module

2. モジュールとは新しいグローバル変数や名前空間を作成するのではなく、すべてのコードを 1 つの関数に格納します。同じモジュールを他のモジュールに依存させることができます。

   function CoolModule(){ 
           var something = 'cool'; 
           var another = [1,2,3]; 
           function doSomething(){ 
               console.log( something); 
           } 
           function doAnother(){ 
               console.log(another.join('!')); 
           } 
           return { 
               doSomething: doSomething, 
               doAnother: doAnother 
           }; 
   } 
   var foo = CoolModule(); 
   foo.doSomething(); //cool 
   foo.doAnother(); //1!2!3

3. CoolModuleはこちら これはモジュールですが、単なる関数です。ここで CoolModule 関数が呼び出され、モジュールのインスタンス foo が作成されます (CoolModule はオブジェクトを返すため、その属性の 1 つは内部オブジェクトを参照します)。モジュール CoolModule はモジュールのパブリック API を返します (内部関数を直接返すこともできます)。したがって、モジュール パターンは次の 2 つの必要な条件を満たす必要があります:

4. CoolModule

など、関数は少なくとも 1 回呼び出される必要があります (呼び出しごとに新しいモジュール インスタンスが作成されます)。クローズされた関数には、内部関数がプライベート スコープでクロージャを形成し、アクセス可能にする またはプライベート状態を変更する

シングルトン モジュール パターンの実装:

var foo = ( function CoolModule(){ 
        ...//代码同上例 
})(); 
foo.doSomething(); 
foo.doAnother();

モジュール内にパブリック API オブジェクトへの内部参照を保持することもできるため、モジュール インスタンスメソッドやプロパティの追加と削除など、内部で変更できます

function CoolModule(){ 
    var something = 'cool'; 
    var another = [1,2,3]; 
    function change() { 
        pubicAPI.doSomething = doAnother; 
    } 
    function doSomething(){ 
        console.log( something); 
    } 
    function doAnother(){ 
        console.log(another.join('!')); 
    } 
    var pubicAPI = { 
        change: change, 
        doSomething: doSomething 
    }; 
    return pubicAPI; 
} 
var foo = CoolModule(); 
foo.doSomething(); //cool 
foo.change(); 
foo.doSomething(); //1!2!3 
var foo1 = CoolModule(); 
foo1.doSomething(); //cool

最新のモジュールメカニズム

名前空間は、グローバル変数にプロパティを追加することで表される単なる機能グループです。

名前空間に従ってさまざまな関数をグループ化すると、単一のグローバル変数を整理した状態に保つことができ、また、チーム メンバーが新しい関数を定義する必要があるセクションや、既存の関数を見つけるためにどのセクションに移動すればよいのかを把握できるようになります。

　　例如：定义一个全局变量Y，Y.DOM下的所有方法都是和操作DOM相关的，Y.Event下的所有方法都是和事件相关的。

1. 　　常见的用法是为每一个单独的JS文件创建一个新的全局变量来声明自己的命名空间;

2. 　　每个文件都需要给一个命名空间挂载功能;这时就需要首先保证该命名空间是已经存在的，可以在单全局变量中定义一个方法来处理该任务：该方法在创建新的命名空间时不会对已有的命名空间造成破坏，使用命名空间时也不需要再去判断它是否存在。

var MyGolbal = { 
    namespace: function (ns) { 
        var parts = ns.split('.'), 
            obj = this, 
            i, len = parts.length; 
        for(i=0;i<len;i++){ 
            if(!obj[parts[i]]){ 
                obj[parts[i]] = {} 
            } 
            obj = obj[parts[i]]; 
        } 
        return obj; 
    } 
}; 
MyGolbal.namespace(&#39;Book&#39;); //创建Book 
MyGolbal.Book; //读取 
MyGolbal.namespace(&#39;Car&#39;).prototype.getWheel = function(){...}

　　大多数模块依赖加载器或管理器，本质上都是将这种模块定义封装进一个友好的API

var MyModules = (function Manager() { 
    var modules = {}; 
    function define(name, deps, impl) { 
        for(var i=0; i<deps.length; i++){ 
            deps[i] = modules[deps[i]]; 
        } 
        modules[name] = impl.apply(impl,deps); 
    } 
    function get(name) { 
        return modules[name]; 
    } 
    return { 
        define: define, 
        get: get 
    }; 
})();

　　以上代码的核心是modules[name] = impl.apply(impl,deps);，为了模块的定义引入了包装函数(可以传入任何依赖)，并且将模块的API存储在一个根据名字来管理的模块列表modules对象中;

　　使用模块管理器MyModules来管理模块：

MyModules.define('bar',[],function () { 
    function hello(who) { 
        return 'let me introduce: '+who; 
    } 
    return{ 
        hello: hello 
    }; 
}); 
MyModules.define('foo',['bar'],function (bar) { 
    var hungry = 'hippo'; 
    function awesome() { 
        console.log(bar.hello(hungry).toUpperCase()); 
    } 
    return { 
        awesome: awesome 
    }; 
}); 
var foo = MyModules.get('foo'); 
foo.awesome();//LET ME INTRODUCE: HIPPO

　　异步模块定义(AMD):

define('my-books', ['dependency1','dependency2'],  
    function (dependency1, dependency2) { 
        var Books = {}; 
        Books.author = {author: 'Mr.zakas'}; 
        return Books; //返回公共接口API 
    } 
);

　　通过调用全局函数define()，并给它传入模块名字、依赖列表、一个工厂方法，依赖列表加载完成后执行这个工厂方法。AMD模块模式中，每一个依赖都会对应到独立的参数传入到工厂方法里，即每个被命名的依赖最后都会创建一个对象被传入到工厂方法内。模块可以是匿名的(即可以省略第一个参数)，因为模块加载器可以根据JavaScript文件名来当做模块名字。要使用AMD模块，需要通过使用与AMD模块兼容的模块加载器，如RequireJS、Dojo来加载AMD模块

requre(['my-books'] , function(books){ 
            books.author; 
            ... 
   } 
)

　　以上所说的模块都是是基于函数的模块，它并不是一个能被稳定识别的模式(编译器无法识别)，它们的API语义只是在运行时才会被考虑进来。因此可以在运行时修改一个模块的API

　　未来的模块机制

　　ES6为模块增加了一级语法支持，每个模块都可以导入其它模块或模块的特定API成员，同样也可以导出自己的API成员;ES6的模块没有‘行内’格式，必须被定义在独立的文件中(一个文件一个模块)ES6的模块API更加稳定，由于编译器可以识别，在编译时就检查对导入的API成员的引用是否真实存在。若不存在，则编译器会在运行时就抛出‘早期’错误，而不会像往常一样在运行期采用动态的解决方案;

　　bar.js

function hello(who) { 
    return 'let me introduce: '+who; 
} 
export hello; //导出API: hello

　　foo.js

//导入bar模块的hello() 
import hello from 'bar'; 
 
var hungry = 'hippo'; 
function awesome() { 
    console.log(hello(hungry).toUpperCase()); 
} 
export awesome;//导出API: awesome

　　baz.js

//完整导入foo和bar模块 
module foo from 'foo'; 
module bar from 'bar'; 
foo.awesome();

1. 　　import可以将一个模块中的一个或多个API导入到当前作用域中，并分别绑定在一个变量上;

2. 　　module会将整个模块的API导入并绑定到一个变量上;

3. 　　export会将当前模块的一个标识符(变量、函数)导出为公共API;

4. 　　模块文件中的内容会被当做好像包含在作用域闭包中一样来处理，就和函数闭包模块一样;

以上がJSコードのモジュール化を実装する方法の詳細内容です。詳細については、PHP 中国語 Web サイトの他の関連記事を参照してください。