How to use import and export in node.js

Import and export are modular imports and exports in es6. Node.js does not support them at this stage. They need to be compiled through babel to turn them into modular code for node.js. (For the node.js module, please refer to other node.js modular articles) This article mainly introduces the detailed explanation of the use of import and export in node.js. The editor thinks it is quite good. Now I will share it with you and make it for everyone. refer to. Let’s follow the editor to take a look, I hope it can help everyone.

export exposure

Use export to expose methods, objects, strings, etc., as shown in the following code

//写法1
export var foo=function(){
  console.log(1);
}
//写法2
var bar ={a:"1",b:2};
export {bar};
//写法3
var baz='hello world';
export {baz as qux};

Then, after the above code is compiled by babel, it becomes executable node.js code, as follows

"use strict";
//标记这个模块是es的模块
Object.defineProperty(exports, "__esModule", {
  value: true
});
//写法1
var foo = exports.foo = function foo() {
  console.log(1);
};
//写法2
var bar = { a: "1", b: 2 };
exports.bar = bar;
//写法3

var baz = 'hello world';
exports.qux = baz;

We know after seeing the above code, es6 The export will be converted into the exposure method of exports in node.js.

import Import

Let’s look at how to write import. Let’s introduce the file xx.js where export is written above

The first way to write it

import {foo,qux} from './xx';
console.log(qux);

foo, qux are the attributes we expose in xx.js. There are three attributes exposed in xx.js: foo, bar, and qux , it can be seen that this writing method requires knowing the names of the attributes exposed in the imported file, and can be written as needed without enumerating all attributes.

Let’s take a look at the code compiled by babel:

'use strict';
var _ = require('./xx');
console.log(_.qux);

is a simple require method that introduces xx.js, so use In this way, we can introduce es6 modules or node.js modules.

Second way of writing

import * as xx from './xx';
console.log(xx.bar);

Here we still introduce xx.js, this way of writing will expose xx.js The attributes of are all assigned to the variable xx (actually, it is an alias for module.exports). After being compiled by Babel, it is as follows:

'use strict';
var _ = require('./xx');
var xx = _interopRequireWildcard(_);
function _interopRequireWildcard(obj) {
  //判断是node模块还是es模块
  if (obj && obj.__esModule) {
    return obj;
  }
  else {
    var newObj = {};
    if (obj != null) {
      for (var key in obj) { 
        if (Object.prototype.hasOwnProperty.call(obj, key)) 
         newObj[key] = obj[key];
      }
    }
  //兼容旧的babel编译
    newObj.default = obj;
    console.log(newObj);
    return newObj;
  }
}
console.log(xx.bar);

Seeing the above code, there is One determines whether it is a node module or an es module. This writing method is also compatible with es modules and node modules.

The third way of writing

import oo from './xx'
console.log(oo.bar);

In this way of writing oo is a random variable, which you may think at first glance It’s the same as the second way of writing, but it’s not. Let’s take a look at the compiled code:

'use strict';
var _ = require('./xx');
var _2 = _interopRequireDefault(_);
function _interopRequireDefault(obj) { 
 return obj && obj.__esModule ? obj : 
 { default: obj }; 
}
console.log(_2.default.bar);

In the last line, oo.bar is compiled into _2.default. bar, there is one more default, of course the bar here cannot be found, so this usage is not used to introduce the export attribute, but the export default mentioned below.

export default exposure and one-time exposure

I will summarize export and export default in other articles. Here we only talk about the usage of export default. Let’s look at the code. .

var foo=123;
export default foo;

After being compiled by babel

"use strict";
Object.defineProperty(exports, "__esModule", {
 value: true
});
var foo = 123;
exports.default = foo;

See that the last line of foo will be assigned to exports.default, so It just corresponds to the writing method of import oo from './xx', which will call the properties in default, so these two usages should be used accordingly. Since the value of the attribute will be assigned to exports.default, you can have the following usage

export default 123;

export default {foo:123};

export default function f(){}

export default function (){}

The above code is written separately, because export default can only be used once in a js. The reason is the same as using module.exports, except that you cannot write more than one, the following is also the case Wrong writing:

export default var foo=123; //错误

export default can also be used to expose classes. I won’t go into details here, they are all exposures.

Some other usages

Inheritance

This is module inheritance, which is actually a parent module introducing a child module. Then the exposed attributes of the sub-module are exposed:

export * from './xx';

After being compiled

##

'use strict';
Object.defineProperty(exports, "__esModule", {
 value: true
});
var _ = require('./xx');
Object.keys(_).forEach(function (key) {
 if (key === "default" || key === "__esModule") return;
 Object.defineProperty(exports, key, {
  enumerable: true,
  get: function get() {
   return _[key];
  }
 });
});

Pay attention to the following The sentence

if (key === "default" || key === "__esModule") return;

default attribute is not exposed to the outside world... This shows that using exports default in the xx.js file we imported is invalid. The alternative writing method is

export {default} from './xx';

The inherited writing method is often used to organize multiple modules, and is often used together with the introduction package mentioned below

Induction folder (Introduction package )

Many people don’t understand the following line of code

import * as o from './oo'; //oo是个文件

Why import can introduce a folder, please note that not all folders can be used, inside At least one file is index.js or a js with package.json and another name. Because there is index.js in the folder, this is not a folder but a node.js package (for more information, see node.js package article), import will be compiled by babel into require. require can refer to the package of the specified path. Therefore, import can import a folder. We can rely on index.js to export other file codes in the folder, for example:

//index.js
export * from './1';
export * from './2';

We can get the attributes exposed in 1.js and 2.js by importing the oo folder.

Summarize

Looking at the code compiled by babel, we can see that the usage of export and exports, module.exports and export default are similar. As for what to use and how to use it, it depends on personal preference.

Related recommendations:

Detailed explanation of the usage and difference between export import and export default in JavaScript ES6

The above is the detailed content of How to use import and export in node.js. For more information, please follow other related articles on the PHP Chinese website!