Comment implémenter la modularisation du code JS

Pourquoi utiliser le mode module ?

Parce que les variables et fonctions déclarées dans la portée globale deviennent automatiquement des propriétés de l'objet global Window, ce qui conduit souvent à des conflits de noms, le sera également entraîner des problèmes de maintenabilité très importants. Plus il y a de variables globales, plus la probabilité d'introduire des bugs est grande !

Mode variable globale zéro

Ce mode a moins de scénarios d'application et utilise une IIFE (fonction anonyme immédiatement exécutée), encapsule tout le code, afin que toutes les variables et fonctions soient cachées à l'intérieur de la fonction et ne polluent pas le monde global.

Scénarios d'utilisation :

• Lorsque le code ne dépendra pas d'autres codes ;

• Lorsqu'il n'est pas nécessaire d'étendre ou de modifier continuellement le code au moment de l'exécution

• Quand ; Lorsque le code est court et n'a pas besoin d'interagir avec d'autres codes

　 Mode variable globale unique

Définition de base

Le mode variable globale unique signifie créer une seule variable globale (ou créer aussi peu de variables globales variables comme variable possible), et le nom de la variable globale doit être unique et n'entrera pas en conflit avec les API intégrées actuelles ou futures. Tous les codes fonctionnels doivent être montés sur cette variable globale.

Il a été largement utilisé dans diverses bibliothèques de classes populaires, telles que :

1. YUI définit un unique Le YUI objet global

2. JQuery définit deux objets globaux, $ et JQuery

3. Dojo définit un Objet global dojo

4. La fermeture définit un objet global goog

Exemple :

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

Définition d'un module

Un module est un fragment fonctionnel général. Il ne crée pas de nouvelles variables globales ou d'espaces de noms. Au lieu de cela, tout le code est stocké dans une seule fonction. Ce module peut être représenté par un nom, et ce module peut également dépendre d'autres modules.

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

Le CoolModule ici C'est un module, mais ce n'est qu'une fonction. La fonction CoolModule est appelée ici pour créer une instance foo du module. A ce moment, une fermeture est formée (car CoolModule renvoie un objet dont l'un des attributs fait référence à l'interne. fonction). Le module CoolModule renvoie L'objet est l'API publique du module (vous pouvez également renvoyer directement une fonction interne)

Par conséquent, le modèle du module doit remplir deux conditions nécessaires :

1. Il doit y avoir une fonction fermée externe, et la fonction doit être appelée au moins une fois (chaque appel créera une nouvelle instance de module), comme CoolModule

2. La fonction fermée doit avoir au moins une fonction interne renvoyée, afin que la fonction interne puisse former une fermeture dans la portée privée et pouvoir accéder ou modifier l'état privé

Implémentation du modèle de module singleton :

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

Vous pouvez également conserver des références internes à des objets API publics à l'intérieur le module, afin que les instances de module puissent être référencées en interne Apporter des modifications, y compris l'ajout et la suppression de méthodes et de propriétés

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

Le mécanisme de module moderne

L'espace de noms est Le regroupement fonctionnel s'exprime simplement en ajoutant des attributs aux variables globales.

Le regroupement de différentes fonctions en fonction des espaces de noms peut garder vos variables globales uniques organisées et permettre aux membres de l'équipe de savoir dans quelle section les nouvelles fonctions doivent être définies ou d'accéder à quelle section pour trouver les fonctions existantes.

　　例如：定义一个全局变量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. 　　模块文件中的内容会被当做好像包含在作用域闭包中一样来处理，就和函数闭包模块一样;

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!