Heim > Artikel > Web-Frontend > Detaillierte Einführung in die UMD-Spezifikation in Javascript (mit Code)
Dieser Artikel bietet Ihnen eine detaillierte Einführung in die UMD-Spezifikation (mit Code). Ich hoffe, dass er für Freunde hilfreich ist.
Adresse: https://github.com/umdjs/umd
Die UMD-Spezifikation ist die hässlichste unter allen Spezifikationen, es gibt keine! ! ! Dadurch scheint das Modul sowohl mit den AMD- als auch den CommonJs-Spezifikationen kompatibel zu sein. Es wird hauptsächlich von einigen Drittanbieterbibliotheken verwendet, die sowohl browserseitige als auch serverseitige Referenzen unterstützen müssen. UMD ist ein Produkt einer Ära, wenn verschiedene Umgebungen endlich die einheitlichen Spezifikationen der ES-Harmonie erkennen, wird es sich auch von der Bühne der Geschichte zurückziehen.
Die Struktur der UMD-Spezifikation ist auf den ersten Blick sehr kompliziert, vor allem weil man einige Grundkenntnisse in Javascript benötigt, um dieses Paradigma zu verstehen:
(function (root, factory) { if (typeof define === 'function' && define.amd) { // AMD define(['jquery', 'underscore'], factory); } else if (typeof exports === 'object') { // Node, CommonJS之类的 module.exports = factory(require('jquery'), require('underscore')); } else { // 浏览器全局变量(root 即 window) root.returnExports = factory(root.jQuery, root._); } }(this, function ($, _) { // 方法 function a(){}; // 私有方法,因为它没被返回 (见下面) function b(){}; // 公共方法,因为被返回了 function c(){}; // 公共方法,因为被返回了 // 暴露公共方法 return { b: b, c: c } }));
Sehen wir uns zunächst die äußerste Struktur an:
(function (){}());
Es ist sehr einfach, es ist eine selbstausführende Funktion. Da es sich um einen modularen Standard handelt, bedeutet dies, dass diese selbstausführende Funktion letztendlich ein Modul exportieren kann. Aus Code-Sicht gibt es tatsächlich zwei gängige Implementierungsmethoden:
(function (factory){ //假设没有使用任何模块化方案,那么将工厂函数执行后返回的内容直接挂载到全局 window.Some_Attr = factory(); }(function(){ //自定义模块主体的内容 /* var a,b,c function a1(){} function b1(){} function c1(){} return { a:a1, b:b1 } */ }))
Das heißt, wir passen eine anonyme Funktion an, übergeben sie dann als tatsächlichen Parameter an die selbstausführende Funktion und führen sie dann in der Funktion aus. Auf diese Factory-Methode wird formal zugegriffen Parameter innerhalb der Funktion (oder Sie werden mit der Callback-Funktion oder dem Callback besser vertraut sein) und es wird einfach an das globale Objekt gehängt, wodurch der grundlegende Modulexport abgeschlossen wird.
Manchmal hoffen wir auch, das Modul in einer nicht-globalen Umgebung zu mounten. Die dynamische Übergabe des Mount-Objekts kann dazu führen, dass der Code über grundlegende Kenntnisse verfügt Drei Attribute: parent, top und self, um das neue Window-Objekt zu verfolgen, das nach dem Einbetten von „iframe“ in die Seite eingeführt wird. Die einzelne Seite Window.self zeigt auf sich selbst und wird im Code oft dadurch identifiziert, ob sie das self-Attribut enthält . Globales Objekt, daher kann die Schreibmethode hier verbessert werden, um kompatibel zu sein:
(function(root,factory){ root.Some_Attr = factory(); }(self !== undefined ? self : this, function(){ }));
2.2 Anpassung an AMD
/* * AMD规范的模块定义格式是define(id?, dependencies?, factory),factory就是实际的模块内容 */ (function (factory){ //判断全局环境是否支持AMD标准 if(typeof define === 'function' && define.amd){ //定义一个AMD模块 define([/*denpendencies*/],factory); } }(function(/*formal parameters*/){ //自定义模块主体的内容 /* var a,b,c function a1(){} function b1(){} function c1(){} return { a:a1, b:b1 } */ }))
2.3 Anpassen von CommonJs
/* * CommonJs规范使用require('moduleName')的格式来引用模块,使用module.exports对象输出模块,所以只要把模块的输出内容挂载到module.exports上就完成了模块定义。 */ (function (factory){ //判断全局环境是否支持CommonJs标准 if(typeof exports === 'object' && typeof define !== 'function'){ module.exports = factory(/*require(moduleA), require(moduleB)*/); } }(function(/*formal parameters*/){ //自定义模块主体的内容 /* var a,b,c function a1(){} function b1(){} function c1(){} return { a:a1, b:b1 } */ }))
CommonJs
Nachdem wir die Anpassung zu hinzugefügt haben, wird der Funktionskörper Der Inhalt zurückgegeben (normalerweise ein Objekt) wird auf gemountet. Wenn Sie CommonJs
-Code geschrieben haben, sind Sie damit vertraut. module.exports
node.js
Zerkleinern Sie die obigen Fragmente und Sie werden verstehen, wie
UMD
3. Ein gezielteres UMD-Paradigma
Veröffentlichen Sie hier ein jqueryPlugin-Entwicklungsparadigma, das für die meisten Entwickler nützlich sein könnte. Wenn Sie die obige Analyse verstehen, sollte der folgende Code nicht schwer zu verstehen sein:
// Uses CommonJS, AMD or browser globals to create a jQuery plugin. (function (factory) { if (typeof define === 'function' && define.amd) { // AMD. Register as an anonymous module. define(['jquery'], factory); } else if (typeof module === 'object' && module.exports) { // Node/CommonJS module.exports = function( root, jQuery ) { if ( jQuery === undefined ) { // require('jQuery') returns a factory that requires window to // build a jQuery instance, we normalize how we use modules // that require this pattern but the window provided is a noop // if it's defined (how jquery works) if ( typeof window !== 'undefined' ) { jQuery = require('jquery'); } else { jQuery = require('jquery')(root); } } factory(jQuery); return jQuery; }; } else { // Browser globals factory(jQuery); } }(function ($) { $.fn.jqueryPlugin = function () { return true; }; }));
4 Entwicklung
Das obige ist der detaillierte Inhalt vonDetaillierte Einführung in die UMD-Spezifikation in Javascript (mit Code). Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!