Karim Aya

Karim Aya


7 Best JavaScript Design Patterns You Should Know

In this tutorial, I'll explore seven best and most popular JavaScript design patterns, which of course most of them will fall under three categories namely; creation design patterns, structural design patterns and behavioral design patterns. 

Design patterns in JavaScript are reusable solutions applied to commonly occurring problems in writing JavaScript web applications.

1. Constructor Design Pattern

2. Prototype Pattern

3. Module Design Pattern

4. Singleton Pattern

5. Factory Pattern

6. Observer Pattern

7. Command Pattern

Read Also: JavaScript Cheatsheet - Comprehensive PDF Included


It is quite appropriate to refer JavaScript design patterns as templates to provide solutions to problems but not quite to say that these patterns can replace the developers.

Design patterns help combine experiences of many developers to structure the codes in an optimized manner that meet the problems we are seeking solutions to, and gives common vocabulary used to describe solutions to our problems than describing the syntax and semantics of our code.

JavaScript design patterns assist developers to write organized, beautiful and well-structured codes. Although design patterns, when used can easily be re-used, they can never supplement developers, rather they only support them by preventing minor issues that could lead to major problems on the web application development by providing generalized solutions that are not tied to a specific problem.

They decrease the overall codebase by doing away with unnecessary repetitions, thus makes our code more robust than the ad-hoc solutions.

In this article, I will explore seven best and most popular JavaScript design patterns, which of course most of them will fall under three categories namely; creation design patterns, structural design patterns and behavioral design patterns. A pattern is something like the following image; just to acquaint you into the context.

1. Constructor Design Pattern.

This is a special method that is used to initialize the newly created objects once a memory is allocated. Since JavaScript is typically object-oriented, it deals with objects most, therefore I intend to delve in to object constructors. There are three ways to create new objects in JavaScript:

The following is one way to create a constructor design pattern.

// This creates a new empty Object

var newObject = {};

// This creates a new empty Object

var newObject = Object.create(Object.prototype);

var newObject = newObject();

To access the properties of a function, you need to initialize the object.

const object = new ConstructorObject();

Whereby the new keyword above tells JavaScript that aconstructorObjectshould act as a constructor. Inheritance is one thing this design pattern does not support. 

Read Also: 12 Concepts That Will Level Up Your JavaScript Skills

2. Prototype Pattern

The prototype pattern is based on prototypical inheritance whereby objects created to act as prototypes for other objects. In reality, prototypes act as a blueprint for each object constructor created.


var myCat= {
name:"Ford Escort",
console.log("Stop! I am applying brakes");
Panic : function (){
console.log ( "wait. how do you stop thuis thing?")
// use objec create to instansiate a new car
var yourCar= object.create(myCar);
//You can now see that one is a prototype of the other
console.log (yourCar.name);]

Read Also: 127 Useful JavaScript Snippets You Can Understand in 30 Seconds

3. Module Design Pattern

In the module design pattern, there is an improvement from the prototype pattern. The different types of modifiers (both private and public) are set in the module pattern. You can create similar functions or properties without conflicts. There is the flexibility of renaming functions publicly. The daunting part of this is the inability to override the created functions from the outside environment.


function AnimalContainter () {

const container = [];

function addAnimal (name) {

function getAllAnimals() {
return container;

function removeAnimal(name) {
const index = container.indexOf(name);
if(index < 1) {
throw new Error('Animal not found in container');
container.splice(index, 1)

return {
add: addAnimal,
get: getAllAnimals,
remove: removeAnimal

const container = AnimalContainter();

console.log(container.get()) //Array(3) ["Hen", "Goat", "Sheep"]
console.log(container.get()); //Array(2) ["Hen", "Goat"]

Read Also: Top 35 JavaScript Shorthands for Beginners

4. Singleton Pattern

It is essential in a scenario where only one instance needs to be created, for example, a database connection. It is only possible to create an instance when the connection is closed or you make sure to close the open instance before opening a new one. This pattern is also referred to as strict pattern, one drawback associated with this pattern is its daunting experience in testing because of its hidden dependencies objects which are not easily singled out for testing.


function DatabaseConnection () {

let databaseInstance = null;

// tracks the number of instances created at a certain time
let count = 0;

function init() {
console.log(`Opening database #${count + 1}`);
//now perform operation
function createIntance() {
if(databaseInstance == null) {
databaseInstance = init();
return databaseInstance;
function closeIntance() {
console.log('closing database');
databaseInstance = null;
return {
open: createIntance,
close: closeIntance

const database = DatabseConnection();
database.open(); //Open database #1
database.open(); //Open database #1
database.open(); //Open database #1
database.close(); //close database

Read Also: Top 10 JavaScript Array Methods You Should Know

5. Factory Pattern

It is a creational concerned with the creation of objects without the need for a constructor. It provides a generic interface for creating objects, where we can specify the type of factory objects to be created. Therefore, we only specify the object and the factory instantiates and returns it for us to use. It is wise for us to use factory pattern when the object component set up has a high level of complexity and when we want to create different instances of objects easily depending on the environment we are in. We can also use factory pattern when working with many small objects sharing the same properties and when composing objects that need decoupling.


// Dealer A

DealerA = {};

DealerA.title = function title() {
return "Dealer A";

DealerA.pay = function pay(amount) {
`set up configuration using username: ${this.username} and password: ${
return `Payment for service ${amount} is successful using ${this.title()}`;

//Dealer B

DealerB = {};
DealerB.title = function title() {
return "Dealer B";

DealerB.pay = function pay(amount) {
`set up configuration using username: ${this.username}
and password: ${this.password}`
return `Payment for service ${amount} is successful using ${this.title()}`;

//@param {*} DealerOption
//@param {*} config

function DealerFactory(DealerOption, config = {}) {
const dealer = Object.create(dealerOption);
Object.assign(dealer, config);
return dealer;

const dealerFactory = DealerFactory(DealerA, {
username: "user",
password: "pass"

const dealerFactory2 = DealerFactory(DealerB, {
username: "user2",
password: "pass2"

Read Also: Best JavaScript Frameworks, Libraries and Tools to Use

6. Observer Pattern

The observer design pattern is handy in a place where objects communicate with other sets of objects simultaneously. In this observer pattern, there is no unnecessary push and pull of events across the states, rather the modules involved only modify the current state of data.


function Observer() {
this.observerContainer = [];

Observer.prototype.subscribe = function (element) {

// the following removes an element from the container

Observer.prototype.unsubscribe = function (element) {

const elementIndex = this.observerContainer.indexOf(element);
if (elementIndex > -1) {
this.observerContainer.splice(elementIndex, 1);

* we notify elements added to the container by calling
* each subscribed components added to our container
Observer.prototype.notifyAll = function (element) {
this.observerContainer.forEach(function (observerElement) {

7. Command Pattern

To wrap up, I would say the command design pattern ends my 7 best sums of JavaScript design patterns. The command design pattern encapsulates method invocation, operations or requests into a single object so that we can pass method calls at our discretion. The command design pattern gives us an opportunity to issue commands from anything executing commands and delegates responsibility to different objects instead. These commands are presented in run() and execute() format.


var carManager = {

//information requested
requestInfo: function( model, id ){
return "The information for " + model + " with ID " + id + " is foo bar";

// now purchase the car
buyVehicle: function( model, id ){
return "You have successfully purchased Item " + id + ", a " + model;

// now arrange a viewing
arrangeViewing: function( model, id ){
return "You have successfully booked a viewing of " + model + " ( " + id + " ) ";

Read Also: 16 JavaScript Tricks You Should Know


It is beneficial for JavaScript developers to use design patterns. Some major advantages of using design patterns include project maintainability and also cuts off unnecessary work on the development cycle. Even though JavaScript design patterns can provide solutions to complex problems, needless to say, rapid development and productivity, it is improper to conclude that these design patterns can replace the developers.

#javascript #programming #js #designpatterns

What is GEEK

Buddha Community

7 Best JavaScript Design Patterns You Should Know

jaya reddy


 thank you very much

Teyki Code



bindu singh

bindu singh


Procedure To Become An Air Hostess/Cabin Crew

Minimum educational required – 10+2 passed in any stream from a recognized board.

The age limit is 18 to 25 years. It may differ from one airline to another!


Physical and Medical standards –

  • Females must be 157 cm in height and males must be 170 cm in height (for males). This parameter may vary from one airline toward the next.
  • The candidate's body weight should be proportional to his or her height.
  • Candidates with blemish-free skin will have an advantage.
  • Physical fitness is required of the candidate.
  • Eyesight requirements: a minimum of 6/9 vision is required. Many airlines allow applicants to fix their vision to 20/20!
  • There should be no history of mental disease in the candidate's past.
  • The candidate should not have a significant cardiovascular condition.

You can become an air hostess if you meet certain criteria, such as a minimum educational level, an age limit, language ability, and physical characteristics.

As can be seen from the preceding information, a 10+2 pass is the minimal educational need for becoming an air hostess in India. So, if you have a 10+2 certificate from a recognized board, you are qualified to apply for an interview for air hostess positions!

You can still apply for this job if you have a higher qualification (such as a Bachelor's or Master's Degree).

So That I may recommend, joining Special Personality development courses, a learning gallery that offers aviation industry courses by AEROFLY INTERNATIONAL AVIATION ACADEMY in CHANDIGARH. They provide extra sessions included in the course and conduct the entire course in 6 months covering all topics at an affordable pricing structure. They pay particular attention to each and every aspirant and prepare them according to airline criteria. So be a part of it and give your aspirations So be a part of it and give your aspirations wings.

Read More:   Safety and Emergency Procedures of Aviation || Operations of Travel and Hospitality Management || Intellectual Language and Interview Training || Premiere Coaching For Retail and Mass Communication |Introductory Cosmetology and Tress Styling  ||  Aircraft Ground Personnel Competent Course

For more information:

Visit us at:     https://aerofly.co.in

Phone         :     wa.me//+919988887551 

Address:     Aerofly International Aviation Academy, SCO 68, 4th Floor, Sector 17-D,                            Chandigarh, Pin 160017 

Email:     info@aerofly.co.in


#air hostess institute in Delhi, 

#air hostess institute in Chandigarh, 

#air hostess institute near me,

#best air hostess institute in India,
#air hostess institute,

#best air hostess institute in Delhi, 

#air hostess institute in India, 

#best air hostess institute in India,

#air hostess training institute fees, 

#top 10 air hostess training institute in India, 

#government air hostess training institute in India, 

#best air hostess training institute in the world,

#air hostess training institute fees, 

#cabin crew course fees, 

#cabin crew course duration and fees, 

#best cabin crew training institute in Delhi, 

#cabin crew courses after 12th,

#best cabin crew training institute in Delhi, 

#cabin crew training institute in Delhi, 

#cabin crew training institute in India,

#cabin crew training institute near me,

#best cabin crew training institute in India,

#best cabin crew training institute in Delhi, 

#best cabin crew training institute in the world, 

#government cabin crew training institute

Samanta  Moore

Samanta Moore


Builder Design Pattern

What is Builder Design Pattern ? Why we should care about it ?

Starting from **Creational Design Pattern, **so wikipedia says “creational design pattern are design pattern that deals with object creation mechanism, trying to create objects in manner that is suitable to the situation”.

The basic form of object creations could result in design problems and result in complex design problems, so to overcome this problem Creational Design Pattern somehow allows you to create the object.

Builder is one of the** Creational Design Pattern**.

When to consider the Builder Design Pattern ?

Builder is useful when you need to do lot of things to build an Object. Let’s imagine DOM (Document Object Model), so if we need to create the DOM, We could have to do lot of things, appending plenty of nodes and attaching attributes to them. We could also imagine about the huge XML Object creation where we will have to do lot of work to create the Object. A Factory is used basically when we could create the entire object in one shot.

As **Joshua Bloch (**He led the Design of the many library Java Collections Framework and many more) – “Builder Pattern is good choice when designing the class whose constructor or static factories would have more than handful of parameters

#java #builder #builder pattern #creational design pattern #design pattern #factory pattern #java design pattern

Giles  Goodwin

Giles Goodwin


7 JavaScript Design Patterns Every Developer Should Know

A template for every project? Sounds amazing, isn’t it?

That’s also a level of coding I’m striving for.

One of the ways to achieve it is using design patterns, which help to write well-structured, beautiful, and organized codes.

In this story, we will discover some of the common design patterns used in JavaScript. Let’s get into it.

1. Constructor Pattern

You are familiar with constructors as functions that initialize objects with specific properties and methods.

The constructor pattern is similar to that definition. We use this pattern to create multiple instances of the same object.

There are many ways to create a new object in JavaScript. Take a look at the examples below:

// Using {} to create empty objects:
let person = {};

// Using Object() to create empty objects:
let person = new Object();
// Using function constructor:
function Person(name, age) {
  this.name = name;
  this.age = age;
  this.showName = () => console.log(this.name);
let person = new Person(‘Amy’, 28);

#javascript-development #design-patterns #javascript-tips #javascript #coding

Madyson  Reilly

Madyson Reilly


JavaScript — Build your object a builder!

Design Patterns

Before we will go over the builder design pattern, let’s briefly go over design patterns in general.

What is a Design Pattern?

A design pattern is a general and reusable solution for common problems you may encounter when designing your software. Each design pattern solves a different problem and can be customized to your use case with much ease.

Why do we need them?

One of the main reasons we need design patterns is to make our software very changeable, so it will be maintainable and will support future changes.

All software programs have to change and modify or they will cease to exist. The amount of time we spend on maintaining a software program is bigger than the amount of time it takes us to develop the program.

#javascript #javascript-tips #design-patterns #javascript-design-pattern #javascript-development

Best Office Interior Designers in Gurgaon | Delhi | India

Office Interiors by Interia knows how to make your office look spacious and luxurious all at the same time. Our best office interior designers in Delhi, Gurgaon are aware of the best utilization of office spaces. In short, you should consider spending on office interior designing because it increases your business’s profit. A beautiful office designed by an interior designer in Gurgaon, Delhi should look up to international standards in quality, be spacious, bright, maximum utilization of wasted space, etc.

#best office interior designers in gurgaon #office interior designers in gurgaon #best office interior designers in delhi #office interior designers in delhi #best office interior designers in india #office interior designers in india