# es6 modules – How can I use an ES6 import in Node.js?

## The Question :

393 people think this question is useful

I’m trying to get the hang of ES6 imports in Node.js and am trying to use the syntax provided in this example:

I’m looking through the support table, but I was not able to find what version supports the new import statements (I tried looking for the text import/require). I’m currently running Node.js 8.1.2 and also believe that since the cheatsheet is referring to .js files it should work with .js files.

As I run the code (taken from the cheatsheet’s first example):

import { square, diag } from 'lib';



I get the error:

SyntaxError: Unexpected token import.

Reference to library I’m trying to import:

//------ lib.js ------
export const sqrt = Math.sqrt;
export function square(x) {
return x * x;
}
export function diag(x, y) {
return sqrt(square(x) + square(y));
}



What am I missing and how can I get node to recognize my import statement?

• So much for “same language everywhere” when you get stuck on the very first line in half the tutorials out there, using this syntax.
• Are we there yet??
• @Larrydx kind of. Nodejs v13 requires to have package.json somewhere in current or parent directory and {"type": "module"} in it and you can use ES6 imports. From doc: Files ending with .js or lacking any extension will be loaded as ES modules when the nearest parent package.json file contains a top-level field "type" with a value of "module". Check more here: nodejs.org/api/esm.html#esm_package_json_type_field

367 people think this answer is useful

Node.js has included experimental support for ES6 support. Read more about here: https://nodejs.org/docs/latest-v13.x/api/esm.html#esm_enabling.

TLDR;

Node.js >= v13

It’s very simple in Node.js 13 and above. You need to either:

• Save the file with .mjs extension, or
• Add { "type": "module" } in the nearest package.json.

You only need to do one of the above to be able to use ECMAScript modules.

Node.js <= v12

If you are using Node.js version 8-12, save the file with ES6 modules with .mjs extension and run it like:

node --experimental-modules my-app.mjs



286 people think this answer is useful

You can also use npm package called esm which allows you to use ES6 modules in Node.js. It needs no configuration. With esm you will be able to use export/import in your JavaScript files.

Run the following command on your terminal

yarn add esm



or

npm install esm



After that, you need to require this package when starting your server with node. For example if your node server runs index.js file, you would use the command

node -r esm index.js



{
"name": "My-app",
"version": "1.0.0",
"description": "Some Hack",
"main": "index.js",
"scripts": {
"test": "echo \"Error: no test specified\" &amp;&amp; exit 1",
"start": "node -r esm index.js"
},

}



Then run this command from the terminal to start your node server

npm start



Check this link for more details.

164 people think this answer is useful

I just wanted to use the import and export in JavaScript files.

Everyone says it’s not possible. But, as of May 2018, it’s possible to use above in plain Node.js, without any modules like Babel, etc.

Here is a simple way to do it.

Create the below files, run, and see the output for yourself.

Also don’t forget to see Explanation below.

### File myfile.mjs

function myFunc() {
console.log("Hello from myFunc")
}

export default myFunc;



### File index.mjs

import myFunc from "./myfile.mjs"  // Simply using "./myfile" may not work in all resolvers

myFunc();



### Run

node  --experimental-modules  index.mjs



### Output

(node:12020) ExperimentalWarning: The ESM module loader is experimental.

Hello from myFunc



Explanation:

1. Since it is experimental modules, .js files are named .mjs files
2. While running you will add --experimental-modules to the node index.mjs
3. While running with experimental modules in the output you will see: “(node:12020) ExperimentalWarning: The ESM module loader is experimental. “
4. I have the current release of Node.js, so if I run node --version, it gives me “v10.3.0”, though the LTE/stable/recommended version is 8.11.2 LTS.
5. Someday in the future, you could use .js instead of .mjs, as the features become stable instead of Experimental.
6. More on experimental features, see: https://nodejs.org/api/esm.html

51 people think this answer is useful

Using Node.js v12.2.0, I can import all standard modules like this:

import * as Http from 'http'
import * as Fs from 'fs'
import * as Path from 'path'
import * as Os from 'os'



Versus what I did before:

const
Http = require('http')
,Fs = require('fs')
,Path = require('path')
,Os = require('os')



Any module that is an ECMAScript module can be imported without having to use an .mjs extension as long as it has this field in its package.json file:

"type": "module"



So make sure you put such a package.json file in the same folder as the module you’re making.

And to import modules not updated with ECMAScript module support, you can do like this:

// Implement the old require function
import { createRequire } from 'module'
const require = createRequire(import.meta.url)

// Now you can require whatever
const
WebSocket = require('ws')
,Mime = require('mime-types')
,Chokidar = require('chokidar')



And of course, do not forget that this is needed to actually run a script using module imports (not needed after v13.2):

node --experimental-modules my-script-that-use-import.js



And that the parent folder needs this package.json file for that script to not complain about the import syntax:

{
"type": "module"
}



If the module you want to use has not been updated to support being imported using the import syntax then you have no other choice than using require (but with my solution above that is not a problem).

I also want to share this piece of code which implements the missing __filename and __dirname constants in modules:

import {fileURLToPath} from 'url'
import {dirname} from 'path'
const __filename = fileURLToPath(import.meta.url)
const __dirname = dirname(__filename)



23 people think this answer is useful

If you are using the modules system on the server side, you do not need to use Babel at all. To use modules in Node.js ensure that:

1. Use a version of node that supports the –experimental-modules flag
2. Your *.js files must then be renamed to *.mjs

That’s it.

However and this is a big however, while your shinny pure ES6 code will run in an environment like Node.js (e.g., 9.5.0) you will still have the craziness of transpilling just to test. Also bear in mind that Ecma has stated that release cycles for JavaScript are going to be faster, with newer features delivered on a more regular basis. Whilst this will be no problems for single environments like Node.js, it’s a slightly different proposition for browser environments. What is clear is that testing frameworks have a lot to do in catching up. You will still need to probably transpile for testing frameworks. I’d suggest using Jest.

Also be aware of bundling frameworks. You will be running into problems there.

17 people think this answer is useful

Use:

  "devDependencies": {
"@babel/core": "^7.2.0",
"@babel/preset-env": "^7.2.0",
"@babel/register": "^7.0.0"
}



### File .babelrc

{
"presets": ["@babel/preset-env"]
}



### Entry point for the Node.js application:

require("@babel/register")({})

// Import the rest of our application.
module.exports = require('./index.js')



15 people think this answer is useful

You may try esm.

Here is some introduction: esm

8 people think this answer is useful

Back to Jonathan002‘s original question about

“… what version supports the new ES6 import statements?”

based on the article by Dr. Axel Rauschmayer, there is a plan to have it supported by default (without the experimental command line flag) in Node.js 10.x LTS. According to node.js’s release plan as it is on 3/29, 2018, it’s likely to become available after Apr 2018, while LTS of it will begin on October 2018.

8 people think this answer is useful

### Solution

https://www.npmjs.com/package/babel-register

// This is to allow ES6 export syntax
// to be properly read and processed by node.js application
require('babel-register')({
presets: [
'env',
],
});

// After that, any line you add below that has typical ES6 export syntax
// will work just fine

const utils = require('../../utils.js');
const availableMixins = require('../../../src/lib/mixins/index.js');



### Below is definition of file *mixins/index.js

export { default as FormValidationMixin } from './form-validation'; // eslint-disable-line import/prefer-default-export



That worked just fine inside my Node.js CLI application.

8 people think this answer is useful

Using the .mjs extension (as suggested in the accepted answer) in order to enable ECMAScript modules works. However, with Node.js v12, you can also enable this feature globally in your package.json file.

import statements of .js and extensionless files are treated as ES modules if the nearest parent package.json contains “type”: “module”.

{
"type": "module",
"main": "./src/index.js"
}



(Of course you still have to provide the flag --experimental-modules when starting your application.)

nodemon --inspect ./index.js --exec babel-node --presets es2015,stage-2