In software development programming languages Modules are an integral unit of an application architecture and typically help to isolate units of code for a project both cleanly separated and organized.A module is a software component or part of a program that contains one or more routines. One or more independently developed modules make up a program.

An enterprise-level software application may contain several different modules, and each module serves unique and separate business operations.Modules make a programmer’s job easy by allowing the programmer to focus on only one area of the functionality of the software application. Modules are typically incorporated into the program through interfaces.

In this tutorial we’ll explore the JavaScript Module design pattern.  We’ll discuss in detail why it is an important pattern to master and its relevant use cases.

Code available on Github

In a previous post I discussed , JavaScript Arrays,  and made use of Fibonacci.js module to return a Fibonacci sequence of numbers.

The Fibonacci.js is an example of the JavaScript Module Pattern. In this post I will discuss the JavaScript Module pattern, in more depth and provide reasons why it is the one of the most important JavaScript Design Pattern you should learn to improve the quality of the JavaScript software development and applications.


What is the JavaScript Module Pattern ?

The module pattern is probably the most widely used JavaScript Design Pattern due to the fact that it helps to provide structure and organisation to code bases.

Traditional Object Oriented programming languages like Java, C#, C++ , Python etc, make use of the Class  object to create self contained and decoupled units of code, which can be treated as block boxes of functionality which can be enhanced, added and removed according to requirements.

A Module can be considered as similar to a Singleton Class in an object oriented language.

In a Module, all the variables defined are visible only in the module. Methods in a module have scope and access to the shared private data and private methods. Thus implementing a closure, as discussed later

The methods defined in a JavaScript Module are also known as Privileged methods.


JavaScript does not have a special syntax or object for this purpose, at least for language version prior to JavaScript 6. The module pattern provides us with an easy way to deal with scoping and convenient way to modularize our code.

Essentially the module pattern is a combination of several JavaScript design patterns:

  • Namespaces
  • Immediate functions
  • Private and public methods

Using the module pattern you can with very little code, effectively namespace related methods and properties, organise and create privacy for entire modules of code and minimise global scope pollution.


The Javascript module pattern enables the implementation of the closure principle providing the control of privacy in your methods so that third party applications or modules cannot access data in variables or overwrite it.

The JavaScript Module pattern privileged methods have scope to the other private variables and methods of the module.

What is a closure ?

In JavaScript all variables are accessible in global scope except variables that are declared within a function using the var keyword.

Variables declared in a function have access to the global scope and every other scope above the function that you are in. In other words an inner function has access to the variables that are within the function that wraps it.

Closures are a construct in the JavaScript language. In JavaScript, closures are created every time a function is created. Closures are useful because they let you associate some data with a function that operates on that data. Similar to object-oriented programming, where objects enable the association of data with one or more methods.

A closure is the combination of a function and the lexical environment within which that function was declared.

Creating a JavaScript Module

To understand the module pattern you’ll need to understand the Immediately Invoked Function Expression (IIFE), which the function creates privacy. JavaScript doesn’t really have privacy but creating a new scope emulates this when we wrap all our function logic inside them. The goal is then to only return only the parts we need, leaving other code out of the global scope.

What we have done here is declare a function, which essentially calls itself immediately.  This creates a new scope in which we can wrap all our function logic in, and we return only that parts we need.


After we have created a new scope , we can create a namespace for our anonymous Module.  In my example I will be creating a Module to return a Fibonacci sequence of numbers, so I will create a Fibonacci namespace.

Advantages of JavaScript Module Pattern

  • Reduces clutter with the global namespace
  • suports private data
  • Cleaner code for developers
  • Enables unit testability of code

Disadvantages of JavaScript Module Pattern


  • private methods are not accessible outside the module
  • Private methods are not extensible


Private Methods

JavaScript does not really have private methods, but by using the Module Pattern we can create them.   Private methods are any functions that you don’t necessarily want others to see or call outside of the scope they are declared in. Although you might think this about protection of your code, but in JavaScript this is not necessarily the concept.  It has more to do with naming conflicts. 

JavaScript makes it easy to define global variables that can hold all of the assets of your application.  Unfortunately, global variables weaken the resiliency of programs and should be avoided.

To declare a private function in a Module, we create a function which is locally declared inside the new scope. Attempting to access the function outside of the module , will result in an error to be thrown and the JavaScript application will break.

Featured Book Review

JavaScript: The Good Parts

JavaScript: The Good Parts

Douglas Crockford

Price: £14.20

Using return

Typically Modules will use return and return an object to the Module, which will enable methods to bound to the object and accessible from the modules namespace. Essentially we return an Object Literal and we can call them exactly the same way.

Locally scoped object literal

When developing a module, you may want some means to identify when you’re calling external public methods and internal private methods.  This can be really handy when you’re developing large Modules i.e. Modules that that exceed 100 lines of code.

You may want to identify private method without have to check the return statement.  In this instance we can create a locally scoped namespace within our Module.


Stacked locally scope Object Literal

Virtually the same as the previous example, but it uses more of traditional single object literal notation:

Using a technique called theRevealing Module Pattern which is an enhanced design pattern to ensure all methods and variables are kept private until they are explicitly exposed

Revealing Module Pattern

The Revealing Module Pattern is an enhanced design pattern to ensure all methods and variables are kept private until they are explicitly exposed.

The methods are usually exposed through an object literal returned by the closure from which it’s defined.

Advantages of the Revealing Module Pattern

  • Cleaner Approach
  • Support for private data
  • Reduces global noise
  • Localization of functions and variables through closures
  • concise syntax
  • Explicitly defined public methods and variables


We have examined the fundamental building blocks of a JavaScript application, the JavaScript Module Pattern. Mastering these patterns are essential to JavaScript Development as they allow you to break up your code in smalled managable modules.

The goal of modules is to allow large programs to be assembled using code from disparate sources, and for all the code to run correctly even in the presence of code the inital module developer did not anticipate. Majority of JavaScript frameworks are developed using the Module Pattern .

The above syntax is much more declarative and clearly defines the intent of the module. When developing larger JavaScript modules using the module pattern will enable to structure your code and clearly document it. The pattern also enables easier unit testing of the code.

Gary Woodfine

Freelance Full Stack Developer at
Helps businesses by improving their technical proficiencies and eliminating waste from the software development pipelines.

A unique background as business owner, marketing, software development and business development ensures that he can offer the optimum business consultancy services across a wide spectrum of business challenges.

Affiliate Disclaimer

Disclosure: Please note that some of the links included in the blog posts are affiliate links, which means I will earn a commission if you decide to make a purchase.

I only include affiliate links to products, services and companies that I have personal experience and have actually used. I only recommend them because they are helpful and useful, not because of the small commissions I make if you decide to buy something.

Please do not spend any money on these products unless you feel they are relevant, suitable and will help you achieve your goals.

Buying anyone of these products and the commisions earned will not make me an overnite multi millionaire, but they will help to cover the hosting costs and compensate for the countless hours and effort I put in to create meaningful and valuable free content I provide to help others succeed.

You've also undoubtedly noticed that I also use various advertising networks - unless of of course you're using an Ad blocker, this is also an attempt to reduce my monthly deficit I experience in providing free relevant, valuable and on occassion insightful content for the benefit of others.

I only really make some money if people click on the ads, unless of course you consider 1c per 1000 impressions real money!

Bear in mind just how many impressions I need to make before I can cover my £20 hosting costs a month!

If you are using an adblocker and guilt stricken you can of course donate using any of the buttons below, but I won't be holding my breath.

Buy me a coffeeBuy me a coffee