Introduction détaillée pour exiger et importer l'utilisation dans Node

Cet article présente principalement l'explication détaillée de la différence entre require et import du module d'importation dans Node. Il a une certaine valeur de référence. Les amis intéressés peuvent s'y référer.

Après la sortie du standard ES6, le module est devenu le standard. L'utilisation standard est d'exporter l'interface avec la commande export et d'importer le module avec import. Cependant, dans notre module de nœud habituel, nous adoptons la spécification CommonJS. et utilisez require pour présenter le module, utilisez module.exports pour exporter l'interface.

Si les exigences require et import ne sont pas claires, ce sera moche dans la future programmation standard.

Module à l'ère require

L'une des idées les plus importantes dans la programmation de nœuds est le module, et c'est cette idée qui rend possible les projets JavaScript à grande échelle. La programmation modulaire est populaire dans le monde js, et elle est également basée sur cela. Plus tard, du côté des navigateurs, des boîtes à outils telles que requirejs et seajs sont également apparues, selon les spécifications correspondantes, require dominait toute la programmation modulaire avant ES6. , même maintenant , ce sera toujours le cas jusqu'à ce que le module ES6 soit entièrement implémenté.

Le module Node suit la spécification CommonJS, requirejs suit AMD et seajs suit CMD Bien qu'ils soient différents, nous espérons toujours maintenir un style de code relativement unifié.

// a.js

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

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

On peut voir que afin de maintenir un haut degré d'unité dans le style, en plus d'utiliser une fonction de définition dans le module côté navigateur pour fournir la fermeture du module, autre Le code peut être exactement le même.

// b.js

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

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

est également très similaire dans son utilisation. Bien qu'AMD ou CMD proposent des styles plus riches, notre article traite principalement de l'environnement des nœuds, nous ne l'étendrons donc pas.

Module dans ES6

Le module publié par ES6 n'utilise pas directement CommonJS, pas même require, ce qui signifie que require n'est toujours qu'une partie privée du nœud Global. méthodes et module.exports ne sont que des attributs de variable globale privés du nœud et n'ont rien à voir avec les méthodes standard.

Interface du module d'exportation

L'utilisation de l'exportation est assez compliquée. Vous pouvez voir ici pour plus de détails. Voici quelques exemples :

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

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

Ajoutez la commande export devant l'interface à exporter.

Après l'export, b peut également être modifié. C'est très différent de CommonJS Concernant le mécanisme interne, cet article l'omet sans vergogne.

Notez que la syntaxe suivante comporte de sérieuses erreurs :

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

Lors de l'exportation d'une interface, elle doit avoir une correspondance biunivoque avec le variables à l’intérieur de la relation de module. Cela n'a aucun sens d'exporter 1 directement, et il est impossible d'avoir une variable qui lui corresponde lors de l'import. Bien que l'exportation a semble être valide, la valeur de a est un nombre et ne peut pas du tout être déconstruite, elle doit donc être écrite sous la forme d'exportation {a}. Même si a est affecté à une fonction, cela n'est pas autorisé. De plus, la plupart des styles suggèrent qu'il est préférable d'utiliser un export à la fin du module pour exporter toutes les interfaces, par exemple :

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

import import module

La syntaxe d'importation est différente de celle de require, et l'importation doit être placée au début du fichier, et aucun autre code logique n'est autorisé devant, ce qui est cohérent avec le style de tous les autres langages de programmation.

L'utilisation de l'importation est la même que celle de l'exportation, et c'est assez compliqué. Vous pouvez avoir une compréhension générale ici. Pour donner quelques exemples :

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

Il y a ici quelques pièges, que je ne divulguerai pas pour l'instant, mais qui seront discutés ci-dessous.

La forme d'import suivie d'accolades est l'utilisation la plus basique. Les variables entre accolades correspondent aux variables après l'export. Ici, vous devez comprendre la connaissance de la déstructuration et de l'affectation des objets. Sans cette connaissance, vous ne pouvez pas du tout vous montrer ici. En comprenant l'affectation de déstructuration, la relation de « correspondance biunivoque » peut ici être comprise en détail.

as mot-clé

Les étudiants en programmation peuvent facilement comprendre as. Pour le dire simplement, ce n'est qu'un alias. Il peut être utilisé en export, et il peut réellement être utilisé en import :

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

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

Le code ci-dessus, une fois exporté, l'interface fournie au monde extérieur est amusante , qui est a.js Le a interne est un alias pour la fonction, mais en dehors du module, a n'est pas reconnu, seulement amusant.

Le as in import est très simple Lorsque vous utilisez une méthode dans le module, vous donnez un alias à la méthode afin qu'elle puisse être utilisée dans le fichier courant. La raison en est que parfois deux modules différents peuvent passer la même interface. Par exemple, il existe un c.js qui passe également l'interface amusante :

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

. Si vous utilisez les deux modules a et c en même temps dans b.js, vous devez trouver un moyen de résoudre le problème des noms d'interface en double, car cela le résoudra.

mot-clé par défaut

D'autres écrivent des tutoriels et mettent par défaut dans la partie export, ce qui, à mon avis, n'est pas propice à la compréhension. Lors de l'exportation, vous pouvez utiliser default. Pour parler franchement, il s'agit en fait du sucre de syntaxe des alias :

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

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

Lors de l'importation, vous pouvez l'utiliser comme ceci :

import a from './d';

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

L'avantage de ce sucre de syntaxe est que vous pouvez omettre les accolades {} lors de l'importation. Pour faire simple, si vous constatez qu'une variable n'est pas entourée d'accolades (pas de signe *) lors de l'importation, vous devez la restaurer dans la syntaxe as avec des accolades dans votre esprit.

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

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，那么未来可能只需要做很少的改动。

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!