ES6 modules: import, export, dynamic imports

Anton Ioffe - September 10th 2023 - 20 minutes read

Welcome to an in-depth exploration of ES6 modules, a cornerstone of modern JavaScript development. This comprehensive powerhouse of an article is designed to pique your curiosity, satisfy your quest for knowledge, and strengthen your coding prowess. From defining ES6 modules to explaining their basic syntax all the way down to their integration with popular JavaScript frameworks, we cover astonishing ground.

Delving beyond the exterior, we further investigate the complexities of named and default exports, the contrasts between CommonJS and ES6 modules, and even the practical usage of ES6 modules, breaking down intricate processes like dynamic and conditional imports. Your understanding of path specifications may benefit immensely from the effective examples presented here.

In the later sections, we venture into advanced topics like module singleton and dynamic module loading, complete with well-commented code examples and comprehensive analyses of potential pitfalls. Brace yourself for a thrilling journey as we traverse the distinctive landscape of ES6 modules. It's a rich, engaging, and worthy read for any senior developer hoping to demystify the nuances of this pivotal aspect of JavaScript in modern web development.

Understanding ES6 Modules: Definition, Basic Syntax, Export and Import

ES6 Modules, also known as ECMAScript 2015 modules, are a standardized way to organize and structure JavaScript code, particularly for large codebases. Having been introduced in the ECMAScript 6 (ES6) specification, they encapsulate "pieces" of the code into reusable, self-contained files to increase development efficiency and code clarity.

Before we dive into imports and exports, let's first understand the basic syntax of an ES6 module.

Basic Syntax of ES6 Modules

The basic structure of an ES6 module revolves around two key concepts: exports and imports. Each module has its own scope and doesn't leak variables to the global scope. This eliminates the risk of variable name collision across files.

A module contains JavaScript code within a file. For instance, let's have calculator.js as an example:

// calculator.js
const add = (num1, num2) => num1 + num2;
const subtract = (num1, num2) => num1 - num2;
const multiply = (num1, num2) => num1 * num2;
const divide = (num1, num2) => num1 / num2;

This file contains four functions and acts as a module. However, these functions are unshareable until we use the export keyword.

The export Keyword in ES6 Modules

The export keyword allows us to expose functions, objects or variables from a module so that they can be imported into other modules. This makes modules reusable and modular.

Going back to our calculator.js example, we add the export keyword:

// calculator.js
export const add = (num1, num2) => num1 + num2;
export const subtract = (num1, num2) => num1 - num2;
export const multiply = (num1, num2) => num1 * num2;
export const divide = (num1, num2) => num1 / num2;

With this, we've now made our calculator functions available to be imported by other modules.

Common mistake here can be forgetting to use the export keyword in the file you wish to export functions or data from. If export keyword is not used, the functions or data will not be available to other modules.

The import Keyword in ES6 Modules

The import keyword allows us to access exported members of another module.

To use the functions from calculator.js in another file, for example, main.js, we use the import keyword:

// main.js
import { add, subtract, multiply, divide } from './calculator.js';

console.log(add(5, 3));      // Output: 8
console.log(subtract(5, 3)); // Output: 2
console.log(multiply(5, 3)); // Output: 15
console.log(divide(5, 3));   // Output: 1.6666666666666667

Note the use of {} when importing named exports and the './' to point to the current directory.

A common mistake is not using correct case or spelling for the exported member names during import. It is important to remember that the named imports are case-sensitive, and hence, import { add } from './calculator.js' is not the same as import { Add } from './calculator.js'.

In conclusion, understanding the basic usage of ES6 modules plays a crucial role in your JavaScript programming journey. It provides a better way to organize and structure your code in a more readable and maintainable way. This article provides you with the basic understanding of how to use ES6 modules, how to make functions and data available to other modules using export, and how to use these functions or data in other parts of your application using import.

Types of Exports in ES6 Modules: Named and Default

ES6 modules introduced a more standardized system of managing and organizing JavaScript code, facilitating the process of breaking down complex applications into manageable parts. Two types of exports play a crucial role in the module system: named exports and default exports. Each type has its usage scenarios and properties.

Named Exports

Named exports allow you to export multiple items from a single module file. Each exported item, be it a variable, function, or an object, has a unique name attached to it. A named export can have zero or many exports in a module.

Let's look at a simple named export example:

// MathOperations.js
export const add = (a, b) => a + b;
export const subtract = (a, b) => a - b;

Subsequently, other modules can import these named exports:

// Calculator.js
import { add, subtract } from './MathOperations.js';

console.log(add(2, 3)); // Output: 5
console.log(subtract(2, 1)); // Output: 1

The main benefit of named exports lies in their flexibility. You can selectively import what you need, avoiding unnecessary imports and keeping memory usage lean. This, however, implies a need for careful naming since each export corresponds to a specific name.

One frequent coding mistake associated with named exports is misnaming upon import:

// Incorrect
import { addition, subtraction } from './MathOperations.js';

// Correct
import { add, subtract } from './MathOperations.js';

Default Exports

In contrast, default exports allow only one export per module file. This type of export does not require defining an export named within the module.

Here’s an example of a default export:

// MathOperations.js
const add = (a, b) => a + b;
export default add;

Other modules can then import this default export. It's notable that you can assign any name to this import:

// Calculator.js
import additionFunction from './MathOperations.js';

console.log(additionFunction(2, 3)); // Output: 5

The key advantage of default exports is their simplicity. They save us from memorizing exact export names - you can simply provide a name during the import. However, since there could only be one default export, they're less flexible compared to named exports.

A common mistake made with default exports revolves around using curly braces during import:

// Incorrect
import { additionFunction } from './MathOperations.js';

// Correct
import additionFunction from './MathOperations.js';

Combining Named and Default Exports

While there are distinct differences between named and default exports, both can be incorporated in a balanced way to enhance module functionality and code clarity. Nevertheless, using the two interchangeably can add complexity to the code, so consider your use case first.

In conclusion, the choice of named exports for fine-grained control and selective import, or default exports for simplicity and unique functionality, pivots on the requirements and scale of your project. ES6 modules offer both options in a flexible manner, allowing you to choose the most appropriate export style to maximize modularity, reusability, and readability. Make sure to explore and understand the various facets of ES6 Modules, including dynamic imports, to fully utilize their capabilities in your JavaScript codebase.

Comparing CommonJS and ES6 Modules: Differences and When to Use Each

CommonJS and ES6 modules, both widely adopted in the JavaScript community and used almost interchangeably, represent two key approaches to structuring and managing code in a JavaScript application. However, they harbor quite distinct characteristics, strengths, and weaknesses that should be kept in mind when selecting the most suitable one for a project at hand.

CommonJS Modules

CommonJS, initially introduced to bring JavaScript into a server-side environment (Node.js), utilizes a simplistic approach to managing modules. It operates in a synchronous manner, which makes it an ideal choice for server-side development where operations are carried out sequentially.

Let's examine an example of import and export in CommonJS:

// File calculator.js
// We're defining a module with two methods: add and subtract
module.exports = {
  add: function(a, b) { return a + b; }, 
  subtract: function(a, b) { return a - b; }

// File app.js
// We're importing the whole calculator module
var calculator = require('./calculator');
// Using the add method from the calculator module
console.log(calculator.add(5, 3)); // Outputs 8

A common mistake is attempting to partially import a module using CommonJS. Let's examine this pitfall:

var add = require('./calculator').add; // Incorrect

In CommonJS, you can't partially import a module. Here's the correct way to do it:

// Import the whole calculator module
var calculator = require('./calculator');
// Get the add method from the imported calculator module
var add = calculator.add; // Correct

ES6 Modules

ES6 modules, on the other hand, were built into the ECMAScript 6 (ES2015) standard as an intrinsic part of the language. Unlike CommonJS, they operate in an asynchronous manner, making them well-suited for browser environments.

Below is a demonstration of how you can export and import modules using ES6:

// File calculator.js
// We're exporting functions so they could be imported in other files
export const add = (a, b) => a + b;
export const subtract = (a, b) => a - b;

// File app.js
// We're importing the add method from the calculator module
import { add } from './calculator';
// Using the add method 
console.log(add(5, 3)); // Outputs 8

ES6 modules provide us with the ability to selectively import sections of a module, as long as the section in question is marked with the 'export' keyword:

// Here we're importing only the add function from the calculator module
import { add } from './calculator'; // Works as long as add is exported

However, if "add" isn't marked as the default export in calculator.js, attempting the following import will result in an error:

import add from './calculator'; // Will error if 'add' isn't the default export

Dynamic Imports in ES6 Modules

One of the distinguishing features of ES6 modules is the ability for dynamic importing. Dynamic imports enable modules to be loaded on-demand or conditionally, producing performance benefits in large applications.

Here's an example of dynamic importing in action:

// We're conditionally importing the calculator module
if (someCondition) {
  import('./calculator').then(calculator => {
    console.log(calculator.add(5, 3)); // Outputs 8

Remember that you can only use ES6 imports in ES6 modules, while CommonJS require function should be used in CommonJS modules. Mixing the two could lead to errors in your code.

Deciding Between CommonJS and ES6 Modules

Your decision between CommonJS and ES6 modules should be influenced by several factors:

  1. Environment: ES6 modules, due to their asynchronous nature, are generally more suitable for browser environments. In contrast, CommonJS modules with their synchronous operations could be a better choice for server-side coding.

  2. Support: Consider the environments in which your application will run. Despite having widespread support in modern browsers, ES6 might face implementation issues in older browsers.

  3. Features: Each of these module systems comes with unique features. For instance, ES6 modules facilitate static analysis and 'tree shaking', a performance optimization technique where unused exports are eliminated from the final bundle, thus reducing the size and improving loading speed.

Remember, many JavaScript environments are presently migrating towards ES6 support, including Node.js, marking a trend towards ES6 modules.

As you continue to work on your codebase, take some time to consider if you're making optimal use of modules. Could alterations in how you use modules enhance the scalability, maintainability, or performance of your application? Reflecting on these questions could illuminate ways to optimize your codebase, ensuring it remains scalable and efficient.

In summary, while ES6 modules provide more features and greater flexibility, CommonJS modules are straightforward and have extensive support, particularly in server-side applications. Your choice should depend on your specific project requirements, platform support, and future-proofing needs due to the ongoing shift towards ES6 modules.

Practical Usage of ES6 Modules: Dynamic Imports, Conditional Imports, Importing from Different Directories, Importing JSON Files, and Path Specifications

Let's dive deep into the practical applications of ES6 modules, unraveling the magic of dynamic imports, conditional imports, importing from diverse directories, importing JSON files, and mastering the art of path specifications in JavaScript.

Dynamic Imports

Dynamic imports, by virtue of their name, grant you the luxury of importing JavaScript modules dynamically, on an as-needed basis in your codebase, eschewing the norm of loading everything upfront. The performance uptick this can provide for your web application can be quite significant, particularly if you regularly work with hefty modules or libraries.

Suppose we are dealing with a chunky module aptly titled largeModule, we could efficiently and dynamically import it in a manner such as this:

let largeModule;
    .then((module) => {
        largeModule = module.default;

In the aforementioned snippet, the import() function makes a return with a promise that resolves neatly into the module as soon as it's loaded, basking in asynchronous glory.

Common Mistake: Falling into the trap of loading all modules upfront, causing your initial load time to hit a speed bump.

Conditional Imports

The power of conditional imports lies in their flexibility of importing module conditionally, meaning they only come into play when a given condition holds true. This dance is most commonly choreographed with dynamic imports.

Let’s dive into a use case of conditional imports dancing hand-in-hand with dynamic imports:

let requiredModule;
if (window.innerWidth > 1000) {
        .then((module) => {
            requiredModule = module.default;
} else {
        .then((module) => {
            requiredModule = module.default;

In the above scenario, we base our module import decision on the width of the window.

Common Mistake: Leaning on static upfront imports regardless of the use case or environment.

Importing from Different Directories

With ES6 you have the liberty to import modules from a myriad of directories which use either relative paths (like './module.js') or absolute paths (for instance, '/module.js').

For instance, if we happen to have a module myModule nestled in a sibling directory, we can proceed to import like so:

import myModule from '../sibling-dir/myModule.js';

Common Mistake:

import myModule from '/sibling-dir/myModule.js'; // WRONG 
import myModule from '../sibling-dir/myModule.js'; // CORRECT

Incorrectly setting the path, ushering in the dreaded Module not found error.

Importing JSON Files

An important note of mention is that you can import JSON files directly into your JavaScript, courtesy of ES6 modules.

Here's a practical example:

import serverConfig from './serverConfig.json';

In the above case, serverConfig metamorphoses into an object carrying the JSON data present in the serverConfig.json file.

Common Mistake:

import serverConfig from './serverConfig'; // WRONG 
import serverConfig from './serverConfig.json'; // CORRECT

Forgetting to include the .json extension in the import statement, inviting the unwelcome guest, Module not found error.

Path Specifications

In the realm of ES6 modules, you can choose between relative paths and absolute paths when importing modules.

Assuming myModule.js is residing in the same directory:

import myModule from './myModule.js';

And if myModule.js is lounging grandly in a parent directory:

import myModule from '../myModule.js';

In conclusion, becoming adept in the practical use of ES6 modules can vastly uncomplicate your JavaScript code, boost performance, and improve maintainability. Always keep an eye out for conversions of your import statements to optimize, and steer clear of the common pitfalls identified herein.

Are dynamic imports a regular feature in your coding routine? Have you observed a noticeable performance boost when switching from static to dynamic imports? I'm always enthusiastic to learn from your insights, so don't hesitate to share your experiences in the comments section!

Use of ES6 Modules with Various Frameworks: Node JS, React, and Angular

In this article section, we will delve into utilizing ES6 modules with popular JavaScript frameworks such as Node.js, React, and Angular. We will include practical examples and discuss common mistakes that can result from incorrect usage.

Node.js and ES6 Modules

Firstly, it's essential to note that ES6 module support in Node.js is different from how it is dealt with in the browser. Node.js uses the CommonJS (CJS) module system by default, but it also provides experimental support for ES6 modules.

However, please remember that you need to use the .mjs extension or set "type": "module" in your package.json to inform Node.js to treat your JavaScript files as ES6 modules.

// ES6 module in Node.js
import fs from 'fs';
const data = fs.readFileSync('/file/path', 'utf-8');

Common Mistake: Using Require

A common mistake when working with ES6 modules in Node.js is trying to use the require() function to import modules. require() is a function in Node.js's CommonJS system and is not available in ES6 modules.


// CommonJS style
const fs = require('fs');


// ES6 style
import fs from 'fs';

React and ES6 Modules

In React, ES6 modules are typically used for component-based development. Each React component is usually developed in a separate ES6 module and then imported when needed.

Let's look at how we can create a module for our component in React.

// WelcomeComponent.js
import React from 'react';

export default function WelcomeComponent() {
    return (
            <h1>Welcome to our application!</h1>

We'd then import WelcomeComponent in another file like this:

// App.js
import React from 'react';
import WelcomeComponent from './WelcomeComponent';

function App() {
    return (
        <div className='app'>
            <WelcomeComponent />

export default App;

Common Mistake: Incorrect Import

Remember, when you use export default, you must import without curly brackets {}. Trying to import a default export with {} is a common mistake.


// Incorrect import
import {WelcomeComponent} from './WelcomeComponent';


// Correct import
import WelcomeComponent from './WelcomeComponent';

Angular and ES6 Modules

Angular also uses ES6 module syntax. But, it additionally has its own modular system called "Angular Modules" or "NgModules". Angular's modules are different from JavaScript modules, as they are a way to group together specific types of classes with similar features.

Angular modules (NgModules) do embrace ES6 modules, though; you will import and export classes, functions, and other entities using ES6 syntax.

// app.component.ts
import { Component } from '@angular/core';

    selector: 'my-app',
    template: `<h1>Welcome to our Angular app!</h1>`
export class AppComponent { }

The Component decorator is imported from @angular/core and used to decorate our AppComponent. This is then typically imported into a separate NgModule.

Common Mistake: Mixing Up ES6 and Angular Modules

A common mistake when beginning to work with Angular is confusing Angular Modules (NgModules) with ES6 modules. While they both use similar syntax, they serve different purposes.


// Don't define an NgModule inside an ES6 module
import { NgModule, Component } from '@angular/core';

export class AppComponent { };


// Define Angular components and services in ES6 modules
// And then import them into Angular modules
import { NgModule, Component } from '@angular/core';

    selector: 'my-app',
    template: `<h1>Welcome to our Angular app!</h1>`
export class AppComponent { };

    declarations: [AppComponent],
    imports: [],
    providers: [],
    bootstrap: [AppComponent]
export class AppModule { };

In conclusion, while ES6 module syntax is fairly uniform across JavaScript platforms, the environment in which it is used can significantly alter its implementation rules and conventions. Now, how do you typically handle module management across different projects and frameworks?

Advanced Concepts: Module Singleton, Mixing CommonJS and ES6, Dynamic Module Loading, and the Advantages of Dynamic Loading

Module Singleton in ES6

A Module Singleton in ES6 refers to a distinct scenario when a module is booted only once during its first import. Any further import requests for this module will not execute it again, but will instead yield the already exported values. This characteristic imparts several benefits, particularly when you need to sustain a state across various areas of your application.

Think of a feature in an application where it is essential to retain user preference settings despite where they navigate. You could craft a settings module as a Singleton, and all parts of your application using these settings would share the same instance.

Here is an illustrative example of a module singleton:

// singleton.js
let count = 0;

// This function increment the count value
function increment() {

// This function returns the current count value
function getCount() {
    return count;

export { increment, getCount };
// main.js
import { increment, getCount } from './singleton';

console.log(getCount()); // Outputs: 1

This archetype of the singleton module highlights an easy to make mistake. Some developers expect a new import of the module to reset its state. However, the singleton nature of ES6 modules prevents this from happening.

// another.js
import { getCount } from './singleton';

console.log(getCount()); // Outputs: still 1, not 0

Given the singleton aspect, how might this be advantageous or restrictive in your projects?

Mixing CommonJS and ES6

In the sprawling field of modern JavaScript, you will occasionally need to integrate older code written using the CommonJS module system into your ES6 projects. They can coexist, but there are nuances to bear in mind.

Node.js, up until version 14, defaults to interpreting JavaScript files as CommonJS modules. Files ending with .mjs or those situated in a project where "type" is set to "module" in package.json are interpreted as ES6 modules. From version 14 onward, Node.js provides enhanced ES6 modules support. However, developers are often caught off guard, thinking they can directly translate ES6 import syntax into CommonJS require syntax.

For instance, if we have a CommonJS module with multiple exports:

module.exports = {
    a: 1,
    b: 2,
    c: 3

And we try to import it using ES6 syntax, we’ll face an unexpected behavior:

import * as numbers from './numbers';
console.log(numbers.a); // Outputs: Unexpectedly undefined instead of 1

When importing the module as default, it correctly retains the ES6 style syntax:

import numbers from './numbers';
console.log(numbers.a); // Outputs: 1

For consistency in the CommonJS realm, the module is typically required into a separate variable:

const numbers = require('./numbers');
console.log(numbers.a); // Outputs: 1

Have you ever faced any unexpected behavior when amalgamating ES6 and CommonJS, especially when these modules are mutually dependent?

Dynamic Module Loading

Dynamic module loading lets us implement a technique known as 'lazy loading'. In layman's terms, 'lazy loading' implies loading modules just when they are needed. It significantly improves application performance by reducing the initial bundle size, which in turn accelerates loading times.

We can achieve dynamic loading through JavaScript’s import() syntax. Here’s how:

button.addEventListener('click', async () => {
    const module = await import('./module');; // Assuming run() is an exported function in 'module'

However, there are common pitfalls you will want to sidestep when using dynamic imports. A common error is neglecting the fact that import() returns a Promise. The following shows this error in action:

button.addEventListener('click', () => {
    const module = import('./module');; // Throws: TypeError: is not a function

The correct way to handle this situation exploits .then(), async/await, or applies error handling with .catch().

Given the benefits and challenges, can you identify scenarios where dynamic loading would markedly benefit your projects?

Advantages of Dynamic Loading

A chief advantage of dynamic loading comes in the form of performance enhancement, apparent when dealing with large scale applications. Think of it in terms of bundles. Rather than creating a hefty initial bundle that takes ages to load, break your application into smaller chunks that can be loaded as needed.

For instance, if there's a module powering a rarely used feature, loading it as part of the initial bundle is unnecessary. Everyone would need to download and execute it, even if they never use the feature. With dynamic loading, you avoid this, resulting in faster load times and smoother user experiences.

Yet, while dynamic loading can boost performance, it also adds an additional layer of complexity to your applications and may detract from the user experience if misused. Developers should judiciously balance performance gains against potential user experience costs.

In conclusion, ES6 modules usher in a wave of modernity to JavaScript development by offering greater flexibility and efficiency. These enhancements comprise of singleton capabilities, seamless integration with the CommonJS module system, and dynamic imports for on-demand loading. Just remember to be aware of the common pitfalls associated with these features for a maintainable, efficient codebase.

Looking back at your past projects, how have ES6 modules influenced your development process and the way you structure your code? Has the introduction of ES6 modules changed your approach to handling larger codebases, or guided you towards specific design patterns?


The article delves into the detailed exploration of ES6 modules handling in the JavaScript world, going beyond the rudimentary knowledge to advanced concepts. It broaches the basic aspect of ES6 modules - defining and understanding their structure, elaborates on how to mark them as import or export, and highlights the distinct types of exports: named and default. It then proceeds to draw a comparison between CommonJS and ES6 modules, emphasizing when and how to use each, and casts light on the practical usage of ES6 modules, tackling dynamic and conditional imports, importing from different directories, and path specifications.

Furthermore, the piece ventures into using ES6 modules with various JavaScript frameworks such as Node.js, React, and Angular. Complications that may arise from importing CommonJS in ES6 projects are also discussed along with solutions. The article also introduces the concept of dynamic module loading, shedding light on the advantages of loading modules dynamically, complete with informative examples and common pitfalls.

For a technical exercise, explore the use of dynamic imports in your own JavaScript project. Implement it in a way that allows you to conditionally load different modules based on user interaction, such as clicking a button or navigating to a new page. This should be more than just changing the URL - aim to influence the logic flow of your application. This task will test your understanding of dynamic imports and also give you a sense of the performance enhancements that can be achieved through dynamic module loading.

Don't Get Left Behind:
The Top 5 Career-Ending Mistakes Software Developers Make
FREE Cheat Sheet for Software Developers