Skip to main content

Modules: Import and Export

Understanding ES6 Modules

ES6 modules provide a native way to modularize JavaScript code. Unlike CommonJS or AMD, ES6 modules are static, meaning imports and exports are defined at compile time. This allows for optimizations like tree shaking, where unused code can be excluded from the final bundle.

Benefits of Using ES6 Modules

  • Code Organization and Reusability: Modules encourage better organization of code and facilitate the reuse of code across different parts of an application or across projects.
  • Scope Management: Each module has its own scope, preventing global namespace pollution.
  • Performance Optimizations: Tools can easily analyze module dependencies for optimizations like tree shaking and lazy loading.

Exporting in ES6 Modules

Named Exports

Named exports allow you to export multiple values from a module. Each export can be imported by other modules using the same name.

// Exporting individual features
export const myConstant = 123;
export function myFunction() {}

// Exporting multiple features at once
const anotherConstant = 456;
function anotherFunction() {}
export { anotherConstant, anotherFunction };

Default Exports

Default exports let you specify a single value that is exported from the module. This is useful when a module is designed to export one main functionality.

// Exporting a single value as the default export
export default function myDefaultFunction() {}

Comparing Named and Default Exports

  • Named Exports: Ideal for modules that export multiple functions or variables. Enhances import clarity by specifying exactly what is being imported.
  • Default Exports: Best suited for modules that export a single entity, like a class or utility function.

Importing in ES6 Modules

Importing Named Exports

You can import specific named exports from a module, either individually or all at once.

// Importing individual named exports
import { myConstant, myFunction } from './myModule.js';

// Importing all named exports as an object
import * as myModule from './myModule.js';

Importing Default Exports

Default exports are imported without braces and can be named arbitrarily by the importer.

// Importing the default export from a module
import myDefaultFunction from './myDefaultModule.js';

Mixing Named and Default Imports

It’s possible to import both named and default exports in a single statement.

// How to import both named and default exports in a single statement
import defaultExport, { namedExport } from './module.js';

Comparing ES6 Modules to CommonJS, AMD, and UMD with Examples

The JavaScript ecosystem has evolved various module systems to address the challenges of code organization and reusability. Here’s a comparative look at ES6 Modules, CommonJS, AMD, and UMD, highlighting their key differences and providing small examples for each.

ES6 Modules vs. CommonJS

  • ES6 Modules:
    • Environment: Primarily for the browser, but also supported in Node.js.
    • Syntax: Uses import/export.
    • Loading: Static analysis allows for tree-shaking, optimizing bundles by removing unused code.
    • Example:
// Exporting
export const add = (a, b) => a + b; 
// Importing
import { add } from './math.js';
  • CommonJS:
    • Environment: Node.js.
    • Syntax: Uses require() for imports and module.exports for exports.
    • Loading: Synchronous, which can lead to performance bottlenecks in the browser.
    • Example:
// Exporting
module.exports = { add: (a, b) => a + b, };
// Importing
const { add } = require('./math');

ES6 Modules vs. AMD

  • AMD (Asynchronous Module Definition):
    • Environment: Browser.
    • Syntax: Uses define for module definition and require for loading modules.
    • Loading: Asynchronous, allowing for dynamic loading of modules.
    • Example:
// Defining a module
define(['dependency'], function(dependency) { const add = (a, b) => a + b; return { add }; });
// Loading a module 
require(['math'], function(math) { console.log(math.add(1, 2)); });

ES6 Modules vs. UMD

  • UMD (Universal Module Definition):
    • Environment: Both browser and Node.js.
    • Syntax: Combines patterns from AMD and CommonJS to support both.
    • Loading: Adapts to the environment, supporting both synchronous and asynchronous loading.
    • Example:
(function(root, factory) { 
if (typeof define === 'function' && define.amd) {
  // AMD
  define(['dependency'], factory);
} else if (typeof exports === 'object') { 
  // Node, CommonJS-like
  module.exports = factory(require('dependency'));
} else { 
  // Browser globals (root is window) 
  root.returnExports = factory(root.dependency);
} }(this, function(dependency) { 
  // Actual module code here
  const add = (a, b) => a + b; return { add }; 

Advanced Module Features

Dynamic Imports Using import()

Dynamic imports introduce a powerful capability to ES6 modules, allowing you to load modules on demand. This feature is particularly useful for code splitting and lazy loading, enabling more efficient applications by loading code only when it’s needed.


// Dynamically importing a module
button.addEventListener('click', async () => {
  const module = await import('./dynamicModule.js');

Re-exporting Features

Re-exporting helps streamline module structures and simplifies imports in consuming modules. It allows a module to export features it has imported from other modules, making it easier to manage dependencies and extend modules.


// Re-exporting an imported value
export { default as User } from './User.js';
export { login, logout } from './auth.js';

Practical Use Cases and Examples

Organizing a Project with ES6 Modules

Adopting ES6 modules encourages the development of small, maintainable modules, each focused on a single responsibility. This modular architecture enhances code readability, maintainability, and testability.

Structuring a Project into Small, Maintainable Modules

Consider a project structure where functionality is divided into logical modules, such as:

  • Components: UI components for user interaction.
  • Utilities: Helper functions and shared utilities.
  • Services: Data fetching and application logic.

Example Project Structure:

    - Button.js
    - Navbar.js
    - apiService.js
    - helpers.js

Real-world Scenarios Where Modules Enhance Development

Building a Library of Reusable Components

ES6 modules are ideal for creating libraries of reusable UI components. By exporting each component from its module, you can easily import them into different parts of your application or share them across projects.

// Button.js
export default function Button() { /* Implementation */ }

// Usage in another module
import Button from './components/Button.js';

Modularizing Backend Code in Node.js with ES6 Modules

With Node.js v12 and later supporting ES6 modules, you can now organize backend code into modules, improving the structure and modularity of server-side code.

// userService.js
export async function getUser(id) {
  // Fetch user from database

// server.js
import * as userService from './services/userService.js';

app.get('/user/:id', async (req, res) => {
  const user = await userService.getUser(;

Exercise 1: Implement Dynamic Import in a Web Application

Create a simple web application that displays user information fetched from a mock API. Use dynamic imports to load the module responsible for fetching data only when the user clicks a button. This simulates a scenario where you might not need to load all your JavaScript upfront, improving the initial load time of your application.


  1. Create a module userData.js that exports a function to fetch user data from a mock API (you can use for testing).
  2. In your main script file, add an event listener to a button. When clicked, dynamically import userData.js and call the function to fetch user data.
  3. Display the fetched user data on the page.

Exercise 2: Re-exporting for a Cleaner Import Path

Imagine you have a project with several utility functions spread across multiple files in a /utils directory. Create a single module that re-exports all these utilities, allowing other parts of your application to import them from a single location.


  1. Create multiple modules in the /utils directory, each exporting one or more utility functions (e.g., stringUtils.js, mathUtils.js).
  2. In an index.js file within the /utils directory, re-export all the utilities from these modules.
  3. In another part of your application, import multiple utilities through the single index.js re-export file and use them in a function or component.

FAQ for “Modules: Import and Export”

Q: What is the main advantage of using ES6 modules over CommonJS or AMD? A: ES6 modules provide static import and export syntax, allowing for compile-time analysis. This supports tree shaking to eliminate unused code, and they are natively supported in modern browsers, making them more efficient for front-end development.

Q: Can I use both named and default exports in the same module? A: Yes, a module can have both named and default exports. However, it can have only one default export, while it can have multiple named exports.

Q: How can I dynamically import a module? A: Use the import() function to dynamically import a module. This returns a promise, allowing the module to be loaded asynchronously, which is useful for code-splitting and reducing initial load time.

Q: What are some common use cases for re-exporting features in ES6 modules? A: Re-exporting is useful for creating a single entry point to multiple modules, simplifying imports for consumers of your modules, or when you want to aggregate and export features from several modules together.

Q: Is it possible to use ES6 modules in Node.js? A: Yes, starting from Node.js version 12, ES6 modules are supported. You can use them by adding "type": "module" in your package.json or using the .mjs extension for your module files.

Q: Can I mix ES6 module syntax with CommonJS in the same project? A: While it’s technically possible, mixing module systems can lead to complexity and issues with module resolution. It’s recommended to stick to one module system per project or clearly separate parts of your project that use different systems.

Q: What should I consider when deciding to use named exports vs. default exports? A: Use named exports when you need to export multiple values or when you want to explicitly specify what is being imported/exported for clarity. Default exports are useful when a module is designed to export a single entity, like a class or a library.

Q: How do dynamic imports help with performance optimization? A: Dynamic imports allow you to load modules only when they’re needed, rather than loading all scripts at the start. This can significantly reduce the amount of code loaded upfront, improving initial load times and overall performance, especially in large applications.