JavaScript Modules Explained - Best Ways to Create, Export and Imports Modules

JavaScript Modules Explained - Best Ways to Create, Export and Imports Modules


Let's imagine you're building a web application with hundreds of interrelated functions, variables, and classes. Without the right structure, this codebase will look like a scattered jigsaw, difficult to understand or modify without causing a significant problem for the application. This is where JavaScript modules come in to save the day.

In this article, we're going to delve into JavaScript modules. I show you the best ways to create, export, and import modules in JavaScript. You'll learn the ins and outs of JavaScript modules. By the end of this article, you'll have gained a solid understanding of:

  • What a JavaScript module is

  • How to create modules in JavaScript

  • The best way to export modules

  • How to import modules

  • And some best practices for working with JavaScript modules.

I want to assume you already have a basic understanding of JavaScript, including variables, functions, and objects. If you're new to JavaScript, you need to grasp the fundamentals well before reading further.

Now, let's get started!

What Are JavaScript Modules?

JavaScript modules are ways to organize code into reusable, self-contained units. They allow you to break your code into smaller, manageable pieces, making it more organized and easier to maintain.

To help you understand it better, let's consider a Javascript module for a simple e-commerce application that handles product data. We'll create a module for managing product information.

// Module Name: productModule.js

// Define variables to store product data
const products = [
  { id: 1, name: "Smartphone", price: 499.99 },
  { id: 2, name: "Laptop", price: 899.99 },
  { id: 3, name: "Headphones", price: 79.99 },

// Function to retrieve a product by their IDs
function getProductById(productId) {
  return products.find(product => === productId);

// Function to add a new product
function addProduct(newProduct) {

// Function to calculate the total price of products in the cart
function calculateTotalPrice(cart) {
  let totalPrice = 0;
  cart.forEach(item => {
    const product = getProductById(item.productId);
    if (product) {
      totalPrice += product.price * item.quantity;
  return totalPrice;

// Exporting functions and data as named exports
export { getProductById, addProduct, calculateTotalPrice };

In the example above:

  1. We created a JavaScript module named productModule.js.

  2. Inside the module, we define an array products to store product data and three functions: getProductById, addProduct, and calculateTotalPrice.

  3. The getProductById function retrieves a product by its ID from the products array.

  4. The addProduct function allows us to add new products to the products array.

  5. The calculateTotalPrice function calculates the total price of items in a shopping cart, based on the products' prices and quantities.

Now, this module holds all the product-related functionality. This prevents the variables and functions from affecting the global scope. Other parts of the application can easily import and use these functions and data as needed.

Let's look at an example of how you might use this module in another JavaScript file:

// app.js

import { getProductById, addProduct, calculateTotalPrice } from './productModule.js';

const newProduct = { id: 4, name: "Tablet", price: 299.99 };

const cart = [
  { productId: 1, quantity: 2 },
  { productId: 3, quantity: 1 },

const total = calculateTotalPrice(cart);
console.log("Total Price:", total);

const product = getProductById(2);
console.log("Product:", product);

In the above example, we import the functions and data from the productModule.js module and use them to manage products and calculate the total price of items in a shopping cart within the app.js file.

Benefits of Using Modules

JavaScript modules offer several advantages:

  • Code Organization: Modules allow you to group related code together, making it easier to locate and understand.

  • Reusability: Modules can be reused across different parts of your application or in entirely different projects.

  • Maintainability: Breaking your code into smaller modules makes it easier to update and debug, as you only need to focus on a specific piece of functionality at a time.

  • Encapsulation: Variables and functions defined within a module are scoped to that module, reducing the risk of naming conflicts.

How to Create JavaScript Module Files

Your ability to create a good file structure is essential for working with modules. Consider implementing the following best practices next time you're working with modules.

1. Organize Your Directory Structure: Structure your project by creating directories or folders that reflect functionality or logical grouping.

For instance:

  • /src for keeping your source codes.

  • /modules or /components to store module-specific files e.g. Header, About, Testimonials, etc.

  • /utils for containing utility functions that can be shared across modules.

2. Adhere to File Naming Conventions: Maintain consistency in your file naming conventions. Utilize lowercase letters and separate words with hyphens or underscores.

Look at some examples:

  • user-authentication.js

  • data-fetching-utils.js

3. Establish a Main Entry Point: Select a main entry point for your application, typically designated as main.js or index.js. This particular file will serve as the entry point where you import and initialize your modules.

Ways to Export JavaScript Modules

JavaScript modules can be exported in different ways. Let's briefly at each of them and their use cases.

1. Default Exports

Default exports are used to export a single value, object, or function from a module. They become handy when a module has a clear, primary export that should be easy to import without specifying a name.

// In module.js
const myValue = 42;
export default myValue;

// In another file
import myValue from './module.js';
console.log(myValue); // Output: 42

Please note that you can only use one default export in a JavaScript file. In addition, You can also export before the declaration, like in this example:

// In module.js
export default myValue;
const myValue = 42;

// In another file
import myValue from './module.js';
console.log(myValue); // Output: 42

2. Named Exports

Named exports allow you to export multiple values, functions, or objects from a module. They are useful when a module contains several related items, and you want to import them selectively by name.

Here's an example:

// In module.js
export const myFunction = () => { /* ... */ };
export const myVariable = 42;

// In another file
import { myFunction, myVariable } from './module.js';

Please note that, unlike default export, when using named export, you must enclose the variables or functions in curly brackets when importing.

3. Combining Default and Named Exports

There are cases where you may need to combine default and named exports. This approach becomes necessary when you want to provide a clear, primary export using a default export, while also allowing the import of additional functionalities using named exports.

// In module.js
export default function() { /* ... */ }
export const helperFunction = () => { /* ... */ };

// In another file
import myFunction, { helperFunction } from './module.js';

Note: You can also re-export modules (i.e. export functionalities from one module in another module) in JavaScript.

How to Import Modules

Once you've created and exported modules in JavaScript, you'll need to import them into your code to make use of the functionality they provide. There are various ways to import modules in JavaScript.

1. Importing Default Exports

When a module exports a single item as its default export, you can import it using the import statement.

Here's the syntax:

import moduleName from 'modulePath';

You can refer to the bottom of the export examples above for examples.

2. Importing Named Exports

Named exports allow you to export multiple variables, functions, or classes from a module. To import them, you specify the name of the exported item within curly braces.

Look at the syntax:

import { exportName1, exportName2 } from 'modulePath';

3. Renaming Imported Modules

Sometimes, you may want to rename imported modules or exports to avoid naming conflicts or for clarity. You can use the as keyword to give imported items new names during the import process:

The syntax is simple:

import { originalName as newName } from 'modulePath';

Let's look at an example:

Suppose you have two modules with conflicting export names:

// moduleA.js
export function sayHello() {
  return 'Hello from module A';

// moduleB.js
export function sayHello() {
  return 'Hello from module B';

To avoid naming conflicts, you can rename the imported functions:

import { sayHello as sayHelloA } from './moduleA';
import { sayHello as sayHelloB } from './moduleB';

console.log(sayHelloA()); // Output: Hello from module A
console.log(sayHelloB()); // Output: Hello from module B

4. Importing All Exports

If you want to import all exports from a module into a single object, you can use the * syntax:

import * as moduleName from 'modulePath';

Here's an example:

Let's say you have a module named geometry with multiple named exports:

// geometry.js
export function calculateArea() { /* ... */ }
export function calculatePerimeter() { /* ... */ }
export const shapeName = 'Rectangle';

You can import all exports into a single object:

import * as geometry from './geometry';

console.log(geometry.shapeName); // Output: Rectangle

Keep in mind that while importing all exports is convenient, it may lead to namespace pollution if the module contains many exports.


JavaScript modules are a crucial aspect of modern web development that offers code organization, reusability, and maintainability. Throughout this article, we've explored the fundamentals of modules, including how module files are created, various ways of exporting modules, and best practices for importing modules in JavaScript.

Modules help you create cleaner code, reduce naming conflicts, and enhance collaboration in larger teams.