Wie implementiert requireJS einen Modullader?

Dieser Artikel führt hauptsächlich in ein tiefgreifendes Verständnis der RequireJS-Implementierung eines einfachen Modulladers ein. Jetzt teile ich ihn mit Ihnen und gebe ihn als Referenz.

Im vorherigen Artikel haben wir mehr als einmal die Bedeutung der modularen Programmierung und die Probleme hervorgehoben, die sie lösen kann:

① Lösen Sie das Problem des Namenskonflikts bei einzelnen Dateivariablen

② Probleme bei der Front-End-Zusammenarbeit mit mehreren Personen lösen

③ Probleme bei der Dateiabhängigkeit lösen

④ Laden bei Bedarf (diese Aussage ist eigentlich sehr falsch)

⑤. ..

Um den Loader besser zu verstehen, habe ich ein wenig den Quellcode von requireJS gelesen, aber für viele Studenten ist die Implementierung des Loaders immer noch nicht klar

Tatsächlich wird es nicht durch Code implementiert, sondern nur durch Lesen. Wenn Sie eine Bibliothek oder ein Framework verstehen möchten, können Sie nur teilweise verstehen, daher werde ich heute einen einfachen Loader implementieren

Analyse des Loader-Prinzips

Tatsächlich ist ein vollständiges Modul erforderlich, um ein Programm auszuführen. Der folgende Code ist ein Beispiel:

//求得绩效系数
 var performanceCoefficient = function () {
  return 0.2;
 };
 //住房公积金计算方式
 var companyReserve = function (salary) {
  return salary * 0.2;
 };
 //个人所得税
 var incomeTax = function (salary) {
  return salary * 0.2;
 };
 //基本工资
 var salary = 1000;
 //最终工资
 var mySalary = salary + salary * performanceCoefficient();
 mySalary = mySalary - companyReserve(mySalary) - incomeTax(mySalary - companyReserve(mySalary));
 console.log(mySalary);

Für mein gesamtes Gehalt erhält das Unternehmen Leistungsbelohnungen, aber andere Der Algorithmus kann sehr komplex sein, was die Anwesenheitsquote, den Abschlussgrad usw. betreffen kann.

wird uns vorerst egal sein Es steigt, es wird sinken, also zahlen wir die Wohnungsvorsorgekasse und ziehen die Einkommensteuer ab. Am Ende bin ich es Gehalt

Für ein vollständiges Programm ist der obige Prozess unverzichtbar, aber jede Funktion kann extrem kompliziert sein, und Dinge, die mit Geld zu tun haben, sind kompliziert, sodass allein die Leistung des Unternehmens 1000 Codezeilen überschreiten kann

Also beginnen wir hier mit der Aufteilung:

<script src="companyReserve.js" type="text/javascript"></script>
<script src="incomeTax.js" type="text/javascript"></script>
<script src="performanceCoefficient.js" type="text/javascript"></script>
<script type="text/javascript">
 //基本工资
 var salary = 1000;
 //最终工资
 var mySalary = salary + salary * performanceCoefficient();
 mySalary = mySalary - companyReserve(mySalary) - incomeTax(mySalary - companyReserve(mySalary));
 console.log(mySalary);
</script>

Der obige Code scheint „geteilt“ zu sein, aber tatsächlich verursacht er auch „Nachdem ich das Problem der „Kombination“ gelöst habe, können die Dateien schließlich auch Abhängigkeiten beinhalten.“ Geben Sie unsere Anforderung und Definition ein

Anforderung und Definition

Tatsächlich ist die obige Lösung immer noch nach Dateien und nicht nach Modulen unterteilt. Wenn sich der Dateiname ändert, wird die Seite angezeigt wird Änderungen mit sich bringen. Um dieses Problem zu lösen, muss eines unserer Module einer Pfad-JS-Datei entsprechen, und der Rest besteht darin, das entsprechende Modul zu laden Das Frontend-Modul beinhaltet Anfragen. Diese Schreibweise:

var pathCfg = {
 'companyReserve': 'companyReserve',
 'incomeTax': 'incomeTax',
 'performanceCoefficient': 'performanceCoefficient'
};

gilt also nicht für das Frontend. Auch wenn Sie es irgendwo sehen, müssen wir uns an die AMD-Spezifikation halten 🎜>

companyReserve = requile('companyReserve');

Hier ist eine Standardmethode zum Schreiben von requireJS. Definieren Sie zuerst das Modul und seine Pfadzuordnung und definieren Sie die Abhängigkeiten.

require.config({
 'companyReserve': 'companyReserve',
 'incomeTax': 'incomeTax',
 'performanceCoefficient': 'performanceCoefficient'
});
require(['companyReserve', 'incomeTax', 'performanceCoefficient'], function (companyReserve, incomeTax, performanceCoefficient) {
 //基本工资
 var salary = 1000;
 //最终工资
 var mySalary = salary + salary * performanceCoefficient();
 mySalary = mySalary - companyReserve(mySalary) - incomeTax(mySalary - companyReserve(mySalary));
 console.log(mySalary);
});

Ein einfacher und vollständiger Modullader sieht im Grunde so aus: Zuerst ist es ein Array von Abhängigkeiten, und zweitens ist ein Rückruf erforderlich, um alle Abhängigkeiten zu laden, bevor er ausgeführt werden kann, und die Parameter des Rückrufs sind die Ergebnisse der Ausführung der Abhängigkeiten, sodass das Definitionsmodul im Allgemeinen einen Rückgabewert haben muss

Schema Ja, wie kann man es erreichen?

Implementierungsplan

Wenn es um das Laden von Modulen geht, ist die erste Reaktion der Leute Ajax, denn wann immer sie den Inhalt der Moduldatei abrufen können, ist diese modular aufgebaut. Die Verwendung von Ajax ist jedoch nicht möglich, da Ajax domänenübergreifende Probleme hat

und die modulare Lösung zwangsläufig mit domänenübergreifenden Problemen umgehen muss. Daher ist es praktisch, dynamisch erstellte Skript-Tags zum Laden von JS-Dateien zu verwenden werden zur ersten Wahl, aber die Lösung, die kein Ajax verwendet, stellt immer noch Anforderungen an die Schwierigkeit der Implementierung

PS: In unserer eigentlichen Arbeit wird es auch Szenen zum Laden von HTML-Vorlagendateien geben. Wir werden darüber sprechen später

Normalerweise dient require als Programmeingang zum Planen von Javascript-Ressourcen. Nach dem Laden in jedes Definitionsmodul erstellt jedes Modul stillschweigend ein Skript-Tag zum Laden.

Nach dem Laden Wenn alle abhängigen Module geladen sind, wird der Rückruf ausgeführt.

Das Prinzip ist ungefähr das gleiche, der Rest ist nur die spezifische Implementierung, und zeigen Sie dann, ob diese Theorie zuverlässig ist.

Loader-Kastrationsimplementierung

Kernmodul

Gemäß der obigen Theorie beginnen wir mit den drei Grundfunktionen des Eingangs

require(depArr, callback)

Diese drei Module sind unverzichtbar:

① config wird verwendet, um die Zuordnung zwischen Modulen und Pfaden zu konfigurieren, oder hat andere Verwendungszwecke

② erforderlich ist der Programmeingang

③ Design definieren Jedes Modul reagiert auf den Anforderungsplan

Dann haben wir eine Methode zum Erstellen eines Skript-Tags und zum Abhören seines onLoad-Ereignisses

④ LoadScript

Als nächstes laden wir das Skript-Tag. Schließlich sollte es ein globales Modulobjekt geben, das zum Speichern geladener Module verwendet wird. Daher werden hier zwei Anforderungen vorgeschlagen:

⑤ require.moduleObj Modulspeicherobjekt

⑥ Modul, Modul Der Konstruktor von

Mit den oben genannten Kernmodulen haben wir den folgenden Code gebildet:

var require = function () {
};
require.config = function () {
};
require.define = function () {
};

Dann ist der nächste Schritt die spezifische Implementierung und dann nachholen die fehlenden Schnittstellen und Details während des Implementierungsprozesses, oft Die endgültige Implementierung hat nichts mit dem ursprünglichen Design zu tun...

Code-Implementierung

这块最初实现时，本来想直接参考requireJS的实现，但是我们老大笑眯眯的拿出了一个他写的加载器，我一看不得不承认有点妖

于是这里便借鉴了其实现，做了简单改造：

(function () {
 //存储已经加载好的模块
 var moduleCache = {};
 var require = function (deps, callback) {
  var params = [];
  var depCount = 0;
  var i, len, isEmpty = false, modName;
  //获取当前正在执行的js代码段，这个在onLoad事件之前执行
  modName = document.currentScript && document.currentScript.id || 'REQUIRE_MAIN';
  //简单实现，这里未做参数检查，只考虑数组的情况
  if (deps.length) {
   for (i = 0, len = deps.length; i < len; i++) {
    (function (i) {
     //依赖加一
     depCount++;
     //这块回调很关键
     loadMod(deps[i], function (param) {
      params[i] = param;
      depCount--;
      if (depCount == 0) {
       saveModule(modName, params, callback);
      }
     });
    })(i);
   }
  } else {
   isEmpty = true;
  }
  if (isEmpty) {
   setTimeout(function () {
    saveModule(modName, null, callback);
   }, 0);
  }
 };
 //考虑最简单逻辑即可
 var _getPathUrl = function (modName) {
  var url = modName;
  //不严谨
  if (url.indexOf(&#39;.js&#39;) == -1) url = url + &#39;.js&#39;;
  return url;
 };
 //模块加载
 var loadMod = function (modName, callback) {
  var url = _getPathUrl(modName), fs, mod;
  //如果该模块已经被加载
  if (moduleCache[modName]) {
   mod = moduleCache[modName];
   if (mod.status == &#39;loaded&#39;) {
    setTimeout(callback(this.params), 0);
   } else {
    //如果未到加载状态直接往onLoad插入值，在依赖项加载好后会解除依赖
    mod.onload.push(callback);
   }
  } else {
   /*
   这里重点说一下Module对象
   status代表模块状态
   onLoad事实上对应requireJS的事件回调，该模块被引用多少次变化执行多少次回调，通知被依赖项解除依赖
   */
   mod = moduleCache[modName] = {
    modName: modName,
    status: &#39;loading&#39;,
    export: null,
    onload: [callback]
   };
   _script = document.createElement(&#39;script&#39;);
   _script.id = modName;
   _script.type = &#39;text/javascript&#39;;
   _script.charset = &#39;utf-8&#39;;
   _script.async = true;
   _script.src = url;
   //这段代码在这个场景中意义不大，注释了
   //   _script.onload = function (e) {};
   fs = document.getElementsByTagName(&#39;script&#39;)[0];
   fs.parentNode.insertBefore(_script, fs);
  }
 };
 var saveModule = function (modName, params, callback) {
  var mod, fn;
  if (moduleCache.hasOwnProperty(modName)) {
   mod = moduleCache[modName];
   mod.status = &#39;loaded&#39;;
   //输出项
   mod.export = callback ? callback(params) : null;
   //解除父类依赖，这里事实上使用事件监听较好
   while (fn = mod.onload.shift()) {
    fn(mod.export);
   }
  } else {
   callback && callback.apply(window, params);
  }
 };
 window.require = require;
 window.define = require;
})();

首先这段代码有一些问题：

没有处理参数问题，字符串之类皆未处理

未处理循环依赖问题

未处理CMD写法

未处理html模板加载相关

未处理参数配置，baseUrl什么都没有搞

基于此想实现打包文件也不可能

......

但就是这100行代码，便是加载器的核心，代码很短，对各位理解加载器很有帮助，里面有两点需要注意：

① requireJS是使用事件监听处理本身依赖，这里直接将之放到了onLoad数组中了

② 这里有一个很有意思的东西

document.currentScript

这个可以获取当前执行的代码段

requireJS是在onLoad中处理各个模块的，这里就用了一个不一样的实现，每个js文件加载后，都会执行require（define）方法

执行后便取到当前正在执行的文件，并且取到文件名加载之，正因为如此，连script的onLoad事件都省了......

demo实现

<html xmlns="http://www.w3.org/1999/xhtml">
<head>
 <title></title>
</head>
<body>
</body>
<script src="require.js" type="text/javascript"></script>
<script type="text/javascript">
 require([&#39;util&#39;, &#39;math&#39;, &#39;num&#39;], function (util, math, num) {
  num = math.getRadom() + &#39;_&#39; + num;
  num = util.formatNum(num);
  console.log(num);
 });
</script>
</html>

//util
define([], function () {
 return {
  formatNum: function (n) {
   if (n < 10) return &#39;0&#39; + n;
   return n;
  }
 };
});

//math
define(['num'], function (num) {
 return {
  getRadom: function () {
   return parseInt(Math.random() * num);
  }
 };
});

//math
define(['num'], function (num) {
 return {
  getRadom: function () {
   return parseInt(Math.random() * num);
  }
 };
});

上面是我整理给大家的，希望今后会对大家有帮助。

相关文章：

有关在Vue2.x中父组件与子组件双向绑定（详细教程）

详细介绍在Vue2.0中v-for迭代语法的变化（详细教程）

在vue2.0中循环遍历并且加载不同图片（详细教程）

Das obige ist der detaillierte Inhalt vonWie implementiert requireJS einen Modullader?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!