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:
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:
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!3Daher muss das Modulmuster zwei notwendige Bedingungen erfüllen:
var foo = ( function CoolModule(){
...//代码同上例
})();
foo.doSomething();
foo.doAnother();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(); //coolDer 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下的所有方法都是和事件相关的。 常见的用法是为每一个单独的JS文件创建一个新的全局变量来声明自己的命名空间; 每个文件都需要给一个命名空间挂载功能;这时就需要首先保证该命名空间是已经存在的，可以在单全局变量中定义一个方法来处理该任务：该方法在创建新的命名空间时不会对已有的命名空间造成破坏，使用命名空间时也不需要再去判断它是否存在。 大多数模块依赖加载器或管理器，本质上都是将这种模块定义封装进一个友好的API 以上代码的核心是modules[name] =
impl.apply(impl,deps);，为了模块的定义引入了包装函数(可以传入任何依赖)，并且将模块的API存储在一个根据名字来管理的模块列表modules对象中; 使用模块管理器MyModules来管理模块： 异步模块定义(AMD): 通过调用全局函数define()，并给它传入模块名字、依赖列表、一个工厂方法，依赖列表加载完成后执行这个工厂方法。AMD模块模式中，每一个依赖都会对应到独立的参数传入到工厂方法里，即每个被命名的依赖最后都会创建一个对象被传入到工厂方法内。模块可以是匿名的(即可以省略第一个参数)，因为模块加载器可以根据JavaScript文件名来当做模块名字。要使用AMD模块，需要通过使用与AMD模块兼容的模块加载器，如RequireJS、Dojo来加载AMD模块 以上所说的模块都是是基于函数的模块，它并不是一个能被稳定识别的模式(编译器无法识别)，它们的API语义只是在运行时才会被考虑进来。因此可以在运行时修改一个模块的API 未来的模块机制 ES6为模块增加了一级语法支持，每个模块都可以导入其它模块或模块的特定API成员，同样也可以导出自己的API成员;ES6的模块没有‘行内’格式，必须被定义在独立的文件中(一个文件一个模块)ES6的模块API更加稳定，由于编译器可以识别，在编译时就检查对导入的API成员的引用是否真实存在。若不存在，则编译器会在运行时就抛出‘早期’错误，而不会像往常一样在运行期采用动态的解决方案; bar.js foo.js baz.js import可以将一个模块中的一个或多个API导入到当前作用域中，并分别绑定在一个变量上; module会将整个模块的API导入并绑定到一个变量上; export会将当前模块的一个标识符(变量、函数)导出为公共API; 模块文件中的内容会被当做好像包含在作用域闭包中一样来处理，就和函数闭包模块一样; 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!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('Book'); //创建Book
MyGolbal.Book; //读取
MyGolbal.namespace('Car').prototype.getWheel = function(){...}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
};
})();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: HIPPOdefine('my-books', ['dependency1','dependency2'],
function (dependency1, dependency2) {
var Books = {};
Books.author = {author: 'Mr.zakas'};
return Books; //返回公共接口API
}
);requre(['my-books'] , function(books){
books.author;
...
}
)function hello(who) {
return 'let me introduce: '+who;
}
export hello; //导出API: hello//导入bar模块的hello()
import hello from 'bar';
var hungry = 'hippo';
function awesome() {
console.log(hello(hungry).toUpperCase());
}
export awesome;//导出API: awesome//完整导入foo和bar模块
module foo from 'foo';
module bar from 'bar';
foo.awesome();
![[Web-Frontend] Node.js-Schnellstart](https://img.php.cn/upload/course/000/000/067/662b5d34ba7c0227.png)
