Ausführliche Einführung zum Erfordernis und Importieren der Nutzung in Node

In diesem Artikel wird hauptsächlich der Unterschied zwischen „require“ und „import“ des Importmoduls in Node vorgestellt. Interessierte Freunde können sich darauf beziehen.

Nach der Veröffentlichung des ES6-Standards wurde das Modul zum Standard. Die Standardverwendung besteht darin, die Schnittstelle mit dem Exportbefehl zu exportieren und das Modul mit dem Import einzuführen. In unserem üblichen Knotenmodul übernehmen wir jedoch die CommonJS-Spezifikation und verwenden Sie require, um das Modul einzuführen, und verwenden Sie module.exports, um die Schnittstelle zu exportieren.

Wenn Anforderung und Import nicht klar sind, wird dies in der zukünftigen Standardprogrammierung hässlich sein.

Modul im Require-Zeitalter

Eine der wichtigsten Ideen in der Node-Programmierung ist das Modul, und es ist diese Idee, die groß angelegte JavaScript-Projekte ermöglicht. Modulare Programmierung ist in der js-Welt beliebt und basiert auch darauf. Später erschienen auf der Browserseite auch Toolkits wie requirejs und seajs. Man kann sagen, dass require die gesamte modulare Programmierung vor ES6 dominierte Dies wird auch jetzt noch der Fall sein, bis das ES6-Modul vollständig implementiert ist.

Das Node-Modul folgt der CommonJS-Spezifikation, requirejs folgt AMD und seajs folgt CMD. Obwohl sie unterschiedlich sind, hoffen wir dennoch, einen relativ einheitlichen Codestil beizubehalten.

// a.js

// -------- node -----------
module.exports = {
 a : function() {},
 b : 'xxx'
};

// ----------- AMD or CMD ----------------
define(function(require, exports, module){
 module.exports = {
  a : function() {},
  b : 'xxx'
 };
});

Es ist ersichtlich, dass zur Aufrechterhaltung eines hohen Maßes an Einheitlichkeit im Stil zusätzlich eine Definitionsfunktion im browserseitigen Modul bereitgestellt werden muss das Schließen des Moduls, andere Der Code kann genau derselbe sein.

// b.js

// ------------ node ---------
var m = require('./a');
m.a();

// ------------ AMD or CMD -------------
define(function(require, exports, module){
  var m = require('./a');
  m.a();
});

ist auch in der Anwendung sehr ähnlich. Obwohl AMD oder CMD umfangreichere Stile bereitstellen, geht es in unserem Artikel hauptsächlich um die Knotenumgebung, sodass wir sie nicht erweitern.

Modul in ES6

Das von ES6 veröffentlichte Modul verwendet CommonJS nicht direkt, nicht einmal require, was bedeutet, dass require immer noch nur ein privater Teil des Knotens Global ist Methoden und module.exports sind nur globale Variablenattribute, die für den Knoten privat sind und nichts mit Standardmethoden zu tun haben.

Export-Modulschnittstelle exportieren

Die Verwendung von Export ist ziemlich kompliziert. Einzelheiten finden Sie hier. Hier ein paar Beispiele:

// a.js
export default function() {}
export function a () {}

var b = 'xxx';
export {b}; // 这是ES6的写法，实际上就是{b:b}
setTimeout(() => b = 'ooo', 1000);
export var c = 100;

Fügen Sie den Exportbefehl vor der zu exportierenden Schnittstelle hinzu.

Nach dem Export kann b auch geändert werden. Dies unterscheidet sich stark von CommonJS. In Bezug auf den internen Mechanismus wird dieser schamlos weggelassen.

Beachten Sie, dass die folgende Syntax schwerwiegende Fehler aufweist:

// 错误演示
export 1; // 绝对不可以
var a = 100;
export a;

Beim Exportieren einer Schnittstelle muss diese eine Eins-zu-eins-Entsprechung mit der haben Variablen innerhalb der Modulbeziehung. Es macht keinen Sinn, 1 direkt zu exportieren, und es ist unmöglich, beim Importieren eine entsprechende Variable zu haben. Obwohl export a gültig zu sein scheint, ist der Wert von a eine Zahl und kann überhaupt nicht dekonstruiert werden, sodass er in der Form von export {a} geschrieben werden muss. Auch wenn a einer Funktion zugewiesen ist, ist dies nicht zulässig. Darüber hinaus schlagen die meisten Stile vor, dass es am besten ist, am Ende des Moduls einen Export zu verwenden, um alle Schnittstellen zu exportieren, zum Beispiel:

export {fun as default,a,b,c};

import import Modul

Die Importsyntax unterscheidet sich von der Anforderungssyntax, und der Import muss am Anfang der Datei platziert werden, und es darf kein anderer logischer Code vorangestellt werden, was mit dem Stil aller anderen übereinstimmt Programmiersprachen.

Die Verwendung von Import ist die gleiche wie Export und sie ist ziemlich kompliziert. Hier können Sie sich ein allgemeines Verständnis verschaffen. Um ein paar Beispiele zu nennen:

import $ from 'jquery';
import * as _ from '_';
import {a,b,c} from './a';
import {default as alias, a as a_a, b, c} from './a';

Hier gibt es einige Fallstricke, die ich vorerst nicht verrate, die aber weiter unten besprochen werden.

Die Form des Imports gefolgt von geschweiften Klammern ist die einfachste Verwendung. Die Variablen in den geschweiften Klammern entsprechen den Variablen nach dem Export. Hier müssen Sie das Wissen über Objektdestrukturierung und -zuweisung verstehen. Ohne dieses Wissen können Sie hier überhaupt nicht angeben. Wenn Sie die Destrukturierungszuweisung verstehen, können Sie die Beziehung „Eins-zu-Eins-Korrespondenz“ hier im Detail verstehen.

as Schlüsselwort

Programmierschüler können es leicht verstehen als. Es kann beim Export verwendet werden, und es kann tatsächlich beim Import verwendet werden:

// a.js
var a = function() {};
export {a as fun};

// b.js
import {fun as a} from './a';
a();

Der obige Code macht beim Exportieren und der bereitgestellten externen Schnittstelle Spaß, und zwar a.js Das interne a ist ein Alias ​​für die Funktion, aber außerhalb des Moduls wird a nicht erkannt, es macht nur Spaß.

Der As-In-Import ist sehr einfach. Wenn Sie eine Methode im Modul verwenden, geben Sie der Methode einen Alias, damit sie in der aktuellen Datei verwendet werden kann. Der Grund dafür ist, dass manchmal zwei verschiedene Module dieselbe Schnittstelle übergeben. Beispielsweise gibt es ein C.js, das auch die Fun-Schnittstelle übergibt:

// c.js
export function fun() {};

Wenn Sie die beiden Module a und c gleichzeitig in b.js verwenden, müssen Sie einen Weg finden, das Problem doppelter Schnittstellennamen zu lösen, und das wird es auch lösen.

Standardschlüsselwort

Andere Leute schreiben Tutorials und setzen Standard in den Exportteil, was meiner Meinung nach nicht zum Verständnis beiträgt. Beim Exportieren können Sie die Standardeinstellung verwenden, um es ganz klar auszudrücken:

// d.js
export default function() {}

// 等效于：
function a() {};
export {a as default};

Beim Importieren können Sie es folgendermaßen verwenden:

import a from './d';

// 等效于，或者说就是下面这种写法的简写，是同一个意思
import {default as a} from './d';

Der Vorteil dieses syntaktischen Zuckers besteht darin, dass Sie beim Importieren die geschweiften Klammern {} weglassen können. Einfach ausgedrückt: Wenn Sie beim Importieren feststellen, dass eine Variable nicht in geschweiften Klammern eingeschlossen ist (kein *-Zeichen), sollten Sie sie im Kopf auf die as-Syntax mit geschweiften Klammern zurücksetzen.

所以，下面这种写法你也应该理解了吧：

import $,{each,map} from 'jquery';

import后面第一个 $ 是 {defalut as $} 的替代写法。

*符号

*就是代表所有，只用在import中，我们看下两个例子：

import * as _ from '_';

在意义上和 import _ from '_'; 是不同的，虽然实际上后面的使用方法是一样的。它表示的是把 '_' 模块中的所有接口挂载到 _ 这个对象上，所以可以用 _.each调用某个接口。

另外还可以通过*号直接继承某一个模块的接口：

export * from '_';

// 等效于：
import * as all from '_';
export all;

*符号尽可能少用，它实际上是使用所有export的接口，但是很有可能你的当前模块并不会用到所有接口，可能仅仅是一个，所以最好的建议是使用花括号，用一个加一个。

该用require还是import？

require的使用非常简单，它相当于module.exports的传送门，module.exports后面的内容是什么，require的结果就是什么，对象、数字、字符串、函数……再把require的结果赋值给某个变量，相当于把require和module.exports进行平行空间的位置重叠。

而且require理论上可以运用在代码的任何地方，甚至不需要赋值给某个变量之后再使用，比如：

require('./a')(); // a模块是一个函数，立即执行a模块函数
var data = require('./a').data; // a模块导出的是一个对象
var a = require('./a')[0]; // a模块导出的是一个数组

你在使用时，完全可以忽略模块化这个概念来使用require，仅仅把它当做一个node内置的全局函数，它的参数甚至可以是表达式：

require(process.cwd() + '/a');

但是import则不同，它是编译时的（require是运行时的），它必须放在文件开头，而且使用格式也是确定的，不容置疑。它不会将整个模块运行后赋值给某个变量，而是只选择import的接口进行编译，这样在性能上比require好很多。

从理解上，require是赋值过程，import是解构过程，当然，require也可以将结果解构赋值给一组变量，但是import在遇到default时，和require则完全不同： var $ = require('jQuery'); 和 import $ from 'jquery' 是完全不同的两种概念。

上面完全没有回答“改用require还是import？”这个问题，因为这个问题就目前而言，根本没法回答，因为目前所有的引擎都还没有实现import，我们在node中使用babel支持ES6，也仅仅是将ES6转码为ES5再执行，import语法会被转码为require。这也是为什么在模块导出时使用module.exports，在引入模块时使用import仍然起效，因为本质上，import会被转码为require去执行。

但是，我们要知道这样一个道理，ES7很快也会发布，js引擎们会尽快实现ES6标准的规定，如果一个引擎连标准都实现不了，就会被淘汰， ES6是迟早的事 。如果你现在仍然在代码中部署require，那么等到ES6被引擎支持时，你必须升级你的代码，而如果现在开始部署import，那么未来可能只需要做很少的改动。

Das obige ist der detaillierte Inhalt vonAusführliche Einführung zum Erfordernis und Importieren der Nutzung in Node. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!