So implementieren Sie die Modularisierung von JS-Code

Warum den Modulmodus verwenden?

Weil im globalen Bereich deklarierte Variablen und Funktionen automatisch zu Eigenschaften des globalen Objektfensters werden, was häufig zu Namenskonflikten führt Dies führt auch zu einigen sehr wichtigen Wartbarkeitsproblemen. Je mehr globale Variablen vorhanden sind, desto größer ist die Wahrscheinlichkeit, dass Fehler auftreten. Einer der Zwecke der Modularisierung besteht darin, dieses Problem zu lösen 🎜>

Null-Global-Variablen-Modus

Dieser Modus hat weniger Anwendungsszenarien und verwendet eine IIFE (sofort ausgeführte anonyme Funktion), die den gesamten Code umschließt , sodass alle Variablen und Funktionen innerhalb der Funktion verborgen sind und die globale Welt nicht verschmutzen.

Nutzungsszenarien:

• Wenn der Code nicht von anderen Codes abhängig ist;

• Wenn keine Notwendigkeit besteht, den Code zur Laufzeit kontinuierlich zu erweitern oder zu ändern;

• Wann Wenn der Code kurz ist und nicht mit anderen Codes interagieren muss;

　

Einzelner globaler Variablenmodus

Grundlegende Definition

Der Modus „Einzelne globale Variable“ bedeutet, nur eine globale Variable zu erstellen (oder möglichst wenige globale Variablen zu erstellen). Variablen als mögliche Variable) und der Name der globalen Variablen muss eindeutig sein und darf nicht mit aktuellen oder zukünftigen integrierten APIs in Konflikt geraten. Alle Funktionscodes müssen auf dieser globalen Variablen gemountet werden.

Es wurde häufig in verschiedenen beliebten Klassenbibliotheken verwendet, wie zum Beispiel:

1. YUI definiert ein einzigartiges YUI globales Objekt

2. JQuery definiert zwei globale Objekte, $ und JQuery

3. Dojo definiert ein globales Dojo-Objekt

4. Abschluss definiert ein globales Goog-Objekt

Beispiel:

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

Definition eines Moduls

Ein Modul ist ein Allgemeines Funktionsfragment. Es werden keine neuen globalen Variablen oder Namespaces erstellt. Stattdessen wird der gesamte Code in einer einzigen Funktion gespeichert, und dieses Modul kann auch von anderen Modulen abhängen.

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

Das CoolModule hier Es ist ein Modul, aber es ist nur eine Funktion, die hier aufgerufen wird, um eine Instanz des Moduls zu erstellen. Zu diesem Zeitpunkt wird ein Abschluss gebildet (da CoolModule ein Objekt zurückgibt, dessen Attribute sich auf das interne beziehen). Funktion). Das Modul CoolModule gibt das Objekt zurück, das die öffentliche API des Moduls ist (Sie können auch direkt eine interne Funktion zurückgeben)

Daher muss das Modulmuster zwei notwendige Bedingungen erfüllen:

1. Es muss eine externe geschlossene Funktion vorhanden sein und die Funktion muss mindestens einmal aufgerufen werden (jeder Aufruf erstellt eine neue Modulinstanz), z. B. CoolModule

2. Die geschlossene Funktion muss mindestens eine interne Funktion zurückgegeben haben, damit die interne Funktion einen Abschluss im privaten Bereich bilden und auf den privaten Zustand zugreifen oder ihn ändern kann

Implementierung des Singleton-Modulmusters:

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

Sie können auch interne Verweise auf öffentliche API-Objekte darin beibehalten das Modul, sodass intern auf Modulinstanzen verwiesen werden kann. Nehmen Sie Änderungen vor, einschließlich des Hinzufügens und Löschens von Methoden und Eigenschaften

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

Der moderne Modulmechanismus

Der Namespace ist. Die funktionale Gruppierung wird einfach durch das Hinzufügen von Attributen zu globalen Variablen ausgedrückt.

Durch das Gruppieren verschiedener Funktionen nach Namespaces können Sie Ihre einzelnen globalen Variablen organisieren und den Teammitgliedern ermöglichen, zu wissen, in welchem ​​Abschnitt neue Funktionen definiert werden sollen. Oder zu welchem ​​Abschnitt wechseln, um vorhandene Funktionen zu finden.

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

Das obige ist der detaillierte Inhalt vonSo implementieren Sie die Modularisierung von JS-Code. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!