Forem: Tushar Koshti

Factory Design Pattern - Javascript

Tushar Koshti — Tue, 25 Aug 2020 18:18:49 +0000

Factory Design Pattern

Factory design pattern is one of the creational design patterns.
Factory design pattern describes how the object should be created.
It is used to separate the object creation logic from the rest of our code.
It has only one responsibility. i.e. to create objects only based on the provided inputs.
It simplifies the object creation logic by having the object creation logic at one place.

When to use Factory Design Pattern

When we need to keep the object creation logic in one place.
To separate out the responsibility of object creation from the code which uses these objects.

Code example

The shape is one of the examples which we can use in our code example.

class Shape {
    constructor(description) {
        this.description = description;
    }
}

class shapeFactory {
    createShape(shapeType) {
        switch(shapeType) {
            case 'square':
                return new Shape('Square shape');
            case 'rectangle':
                return new Shape('Rectangle shape');
            case 'circle':
                return new Shape('Circle shape');
        }
    }
}

const factory = new shapeFactory();
const circle = factory.createShape('circle');
const square = factory.createShape('square');
const rectangle = factory.createShape('rectangle');

console.log(circle); // Shape {description: 'Circle shape'}
console.log(square); // Shape {description: 'Square shape'}
console.log(rectangle); // Shape {description: 'Rectangle shape'}

In this example, you can see that the shapeFactory is a factory class that creates shape objects based on the shapeType provided.
You can find the code in the GitHub repository.

One Last Thing...

If you'd like to stay in the loop of Software Development then please subscribe to my newsletter. I will try my best to keep you informed about the latest trends and best practices for Software Development.
Please like and follow the blog post. Connect with me on Twitter and LinkedIn.

Let me know in the comments what you will like to learn next... Thanks for visiting the blog...

Singleton Design Pattern - Javascript

Tushar Koshti — Tue, 25 Aug 2020 09:59:00 +0000

Singleton Design Pattern

Singleton design pattern is one of the creational design patterns.
Singleton design pattern describes how the object should be created.
It ensures that the class has only one instance and provides a global access point to that instance.
Singleton design pattern is discovered because of bugs due to multiple instances where only one instance should be present.

When to use Singleton Design Pattern

We need to ensure only one instance of the class is present.
We need to provide a global access point to a class instance.

Code example

A logger is one of the real-world use cases in which we want to have a single instance globally.

let instance = null;

class Logger {
    constructor(logger_name) {
        if (!instance) {
            this.name = logger_name;
            instance = this;
        } else {
            return instance;
        }
    }
}

const logger_1 = new Logger('Logger1');
const logger_2 = new Logger('Logger2');

console.log(logger_1); // Logger {name: 'Logger1'}
console.log(logger_2); // Logger {name: 'Logger1'}

In this example, you can see that even if we try to create 2 different instances of the Logger class there will be only one instance of the Logger class.
You can find the code in the GitHub repository .

One Last Thing...

If you'd like to stay in the loop of Software Development then please subscribe to my newsletter. I will try my best to keep you informed about the latest trends and best practices for Software Development.
Please like and follow the blog post. Connect with me on Twitter and LinkedIn.

Let me know in the comments what you will like to learn next... Thanks for visiting the blog...

Get started with VS Code for Node.js development

Tushar Koshti — Tue, 25 Aug 2020 09:53:09 +0000

Code editor

As developers, there's one tool we all use much that is a code editor. So we always want a smart code editor that can help and make our work as a developer as easy as possible.

I personally use the VS Code for Node.js development purposes. I will share some tools and thoughts which I use to make Node.js development easier.

Node.js Extensions for VS Code

ESLint

ESLint is a popular extension for VS Code.
It's a pluggable and configurable linter tool for identifying and reporting on patterns in JavaScript.
It will detect problems in real-time like unused variables and incorrect variable names like errors easily.

Debugger for Chrome

Debugger for Chrome allows developers to debug javascript code with developer tools available in Chrome.
Features are breakpoints, variables values, etc can be used with this extension.

Prettier - Code Formatter

Prettier code formatter helps us to auto-format the Javascript code when we save the javascript files or using a shortcut(Ctrl + K, F - Windows, Cmd + K, F - Mac).
Prettier is a configurable code formatter. Helps us to make the code formatting consistent all over the project.

Visual Studio IntelliCode

Visual Studio IntellliCode provides AI-assisted code completion features for Javascript/Typescript, Python and other languages.
This tool also improves the productivity of the developer as it provides great code completion assistance to developers.

Code Spell Checker

Code Spell Checker is also a great tool that prevents silly mistakes like spelling mistakes and helps the developers to use proper names across your project.

One Last Thing...

If you'd like to stay in the loop of Software Development then please subscribe to my newsletter. I will try my best to keep you informed about the latest trends and best practices for Software Development.
Please like and follow the blog post. Connect with me on Twitter and LinkedIn.

Let me know in the comments what you will like to learn next... Thanks for visiting the blog...

Singleton Design Pattern

Tushar Koshti — Wed, 30 Oct 2019 04:42:44 +0000

Singleton design pattern makes sure that there should be only one instance of the specific class at a given time. Please refer to the example code for C# implementation.

Example

// Singleton class Customer
public class Customer
{
    private static readonly Lazy<Customer> _lazy = new Lazy<Customer>(() => new Customer());

    private Customer() { }

    public static Customer Instance
    {
        get
        {
            return _lazy.Value;
        }
    }
}