Forem: Abhishek sahni

What is Middleware in Express and How It Works

Abhishek sahni — Fri, 08 May 2026 11:19:04 +0000

Express is a widely used framework of Node.js for backend development. Express provides robust middleware support, which helps developers write reusable and maintainable code.

In this blog, we are diving deep into middleware. By the end of this blog, you will understand all the important concepts of middleware.

What is Middleware?

Middleware is a function that runs during the request-response cycle, sitting between the incoming request and the final route handler.

Every middleware function accepts three arguments:

req (request)
res (response)
next

`req` (Request)

The request object contains incoming data sent by the client.

`res` (Response)

The response object is used by the server to send data back to the client.

`next()`

The next() function passes control to the next middleware function. If there is no next middleware, the request moves to the final route handler.

Important Note

A middleware must either end the request-response cycle by sending a response using res.send() (or similar methods) or pass control using next(). Otherwise, the client request will remain hanging between the request and response cycle.

Types of Middleware :

Application-level middleware :

Application-level middleware is bound to the Express application instance using app.use() and app.METHOD() functions.

It runs for every incoming request to the server if a specific path is not provided.

The execution of middleware follows a top-to-bottom order. Middleware declared at the top runs first, followed by the next middleware in sequence.

For example, if multiple middleware functions are registered using app.use(), Express executes them one by one in the same order they are written in the code.

It has full access to the req (request) object, res (response) object, and the next() function throughout the request-response cycle
```
const express = require('express');
const app = express();

// 1. Without a mount path: Executes for every request
app.use((req, res, next) => {
  console.log('Time:', Date.now());
  next(); // Pass control to the next function
});

// 2. With a mount path: Executes for any request to /user/:id
app.use('/user/:id', (req, res, next) => {
  console.log('Request Type:', req.method);
  next();
});

// 3. With a method: Executes only for GET requests to /user/:id
app.get('/user/:id', (req, res, next) => {
  res.send('User Page');
});
```

Router-level middleware :

Router-level middleware is bound to the instance of router not in main application instance which allow use to apply middleware function to a specific router making our code more modular.

Router-level middleware runs for a specific request that match the path mount to the middleware . It not runs for every request.

const express = require('express');
const router = express.Router();

// This middleware is executed for every request to this router
router.use((req, res, next) => {
  console.log('Router-level request received at:', Date.now());
  next();
});

// Define routes within this router
router.get('/profile', (req, res) => {
  res.send('User Profile');
});

// Mount the router on a path in the main app
// Only requests starting with /user will trigger the router's middleware
const app = express();
app.use('/user', router);

Built-in :

Built-in middleware is bound to the instance of app. They are build in middleware of express we don't need the write logic from scratch.

The primary built-in middleware functions are:
express.json(): Parses incoming requests with JSON payloads. It makes the parsed data available under req.body.
express.urlencoded({ extended: true }): express.urlencoded() is a built-in middleware in Express.js used to parse incoming form data sent from the client.

When user submit HTML form data is usually send in this format :
```
application/x-www-form-urlencoded
```

This middleware converts that form data into a JavaScript object and stores it inside req.body.

Example :

app.use(express.urlencoded({ extended: true }));

express.static(): Serves static files such as images, CSS, and JavaScript from a specified directory (e.g., app.use(express.static('public'))).
express.text(): Parses incoming request payloads into a string.

Error-handling : Error handling is a specialized middleware used to catch and process errors in an Express application.

To create an error-handling middleware, you must define a function with four parameters:

(err, req, res, next)

err : Contains information about the error

Code example :

app.use((err, req, res, next) => {
  console.error(err.message);

  res.status(500).send("Something went wrong");
});

Now we understand the middleware with their types :

Let's dive into the execution order of middleware :

In express middleware run sequently in the order as they defined in code. When a request received express passes it through the middleware stack one by one until the response is send res.send() or stack become empty.

Execution Rules :

Definition Order : The order of app.use() and app.METHOD() (like app.get or app.post) calls determines the execution sequence.

next() function : Function: To move to the subsequent middleware, you must call next(). If you don't call it and don't send a response, the request will hang.

Terminating the Cycle: If a middleware sends a response (e.g., res.send() or res.json()), the request-response cycle ends, and subsequent middleware in the stack will not execute.

Real work example of middleware :

One of the real world use case of middleware is authentication used in real world applications like Instagram , Amazon etc.

Suppose user try to access dashboard

middleware checks :

is token valid
user is logged in or not
does the user have permission to access the dashboard

This checking logic written inside middleware.

function authMiddleware(req, res, next) {
  const isLoggedIn = true;

  if (!isLoggedIn) {
    return res.status(401).send("Please login first");
  }

  next();
}

app.get("/dashboard", authMiddleware, (req, res) => {
  res.send("Welcome to your dashboard");
});

How it works :

Client Request
      ↓
Authentication Middleware
      ↓
Route Handler
      ↓
Response

if user logged in middleware call next() and move the route handler otherwise middleware return response.

Summary : In this blog, we learned that middleware works like a middleman between the request and response cycle. We explored different types of middleware and understood how middleware execution order works in Express.

Arrow functions in JavaScript

Abhishek sahni — Wed, 06 May 2026 08:36:15 +0000

Arrow function Introduced in ES6. They provide concise syntax to write a standard function.

Standard Function :

function add (a , b){
    return a + b;
}

Arrow Function :

const add = (a, b) => a + b;

Arrow function are anonymous don't have name . You cannot give it a name during definition.

Assigned to Variables: To reuse or reference an arrow function, you must assign it to a variable (e.g., const myFunc = () => { ... };).

const greet = () => {
  console.log("Hello");
};

greet(); // reuse
greet(); // reuse again

They are design for inline code that and reduce syntax . It is very useful for callbacks.

Key Features :

Single Parameter (no parentheses needed): const square = x => x * x;

Implicit Return : Single line function automatically return without return keyword.

Callbacks/Array Methods : Ideal for callbacks and array method like .map() , .filter() and reduce() .

Arrow function with array method :

const numbers = [1, 2, 3, 4];

const doubled = numbers.map(num => num * 2);

console.log(doubled); // [2, 4, 6, 8]

Arrow function with setTimeout :

setTimeout(() => {
  console.log("Runs after 2 seconds");
}, 2000);

Implicit & Explicit return :

implicit return : Arrow function offers implicit return for single line expression. You can return without braces and return keyword.

const add = (a, b) => a - b;

Explicit return : Multi-line body needs braces and return keyword to return the value from function.

const add = (a, b) => {
  return a + b;
};

Characteristics :

No this binding : Arrow function does not have their own this it always inherit this from parent function .

const user = {
  name: "john",

  greet: () => {
    console.log(this.name);
  }
};

user.greet(); // output : undefined ❌

function outer() {
  const name = "john";

  const obj = {
    name: "smile",

    greet: () => {
      console.log(this.name);
    }
  };

  obj.greet();
}

outer(); //output: undefined

Arrow function takes this from lexical parent.

output : undefined

Why doesn’t arrow function take this of outer()

Because outer function does not have useful this to give.

outer() function called like standard function.

So its this = global object (or undefined in strict mode)

How to make it work :

function outer() {
  this.name = "john";

  const obj = {
    name: "smile",

    greet: () => {
      console.log(this.name);
    }
  };

  obj.greet();
}

outer(); // john ✅

outer() has this.name and arrow function inherits it.

No Object Parameter : In standard function you get special object called arguments. This object has all argument values even if you don't define in parameter.

function add() {
  console.log(arguments);
}

add(1, 2, 3);

output : [1, 2, 3]

But arrow function don't have arguments object Instead you can you ...args

const add = (...args) => {
  console.log(args);
};

add(1, 2, 3);

output : [1, 2, 3]

Summary : Arrow functions are a modern JavaScript feature introduced in ES6 that provide a shorter and cleaner way to write functions. They are especially useful for writing concise, inline logic and are widely used in callbacks such as map, filter, reduce, event handlers, and asynchronous operations.

Unlike standard functions, arrow functions do not have their own this or arguments object. Instead, they inherit this from their surrounding (lexical) scope, which makes them very helpful in scenarios like nested functions or asynchronous code. However, this behavior also means they are not suitable for object methods or constructors.

Another key advantage of arrow functions is their simplified syntax, including implicit return for single expressions, making the code more readable and maintainable.

Understanding Variables and Data Types in JavaScript

Abhishek sahni — Fri, 01 May 2026 07:12:11 +0000

In this blog we are going to learn basic fundamentals of programming. We are exploring variables and datatypes in javascript.

First we try to understand variables. So what are variables.

Variables : Variables are containers that stores and manage some data.

There are three ways to declare a variable in javaScript. let , var and const .

syntax to declare a variable :

let variableName = value;

var variableName = value;

const variableName = value;

You can use let ,var and const according to your use case.

What is scope : Scope defines where a variable can be access in program.

Global Scope : A variable declared outside any function can be access anywhere in the program.

Function Scope : A variable declared inside a function cannot be accessed outside that function.

Block Scope : Block scope was introduced in ES6.

Variables declared with let and const can only be accessed inside the block {} where they are declared.

Example : A variable declared with let or const inside an if-else statement is accessible only within that block.

But variables declared with var ignore block scope boundaries and are scoped to the nearest function.

Basic difference between var, let, and const :

var : var is function-scoped.

It can be re-declared and re-assigned (updated).

var x = 10;
var x = 20; // re-declaration allowed

x = 30;     // re-assignment allowed

console.log(x); // 30

let : let is block-scoped.

It can be re-assigned (updated), but cannot be re-declared in the same scope.

let y = 10;

// let y = 20; ❌ Error (cannot re-declare in same scope)

y = 30; // re-assignment allowed

console.log(y); // 30

const : const is also block-scoped.

It cannot be re-declared and cannot be re-assigned.

const z = 10;

// const z = 20; ❌ Error (cannot re-declare)
// z = 30;       ❌ Error (cannot re-assign)

console.log(z); // 10

Naming Rules (Identifiers) to declare a variable :

Variable names must follow these strict rules to be valid:

variable names must begin with letter , underscore (_) or dollar ($). Subsequent characters can also include digits.
variables name are case sensitive in javaScript means variable name age and Age are two different variables.
you cannot use reserved words like if-else , for loop and function.

Now you understand variables let's dive the datatypes :

Data types : From the name itself, you can understand that a data type means the type of data.

JavaScript is a dynamically typed language.

It means that data types are determined at runtime, not before the execution of the program. unlike many other language we don't need to declare data type first.

Lets take an example :

const data = 12

12 is a data it can be age of any person. But what is the type of 12. It is number.

Here, 12 is a piece of data. It can represent the age of a person.

But what is the type of 12? It is a number.

So, "number" is the data type of 12.

Data types are categorised into two types.

Primitive Data Types
Non-Primitive Data Types

Data types are categorised according to how it stores in memory and how we can access it.

Primitive Data Types : There are seven primitive data types.

Number : The Number data type is used to represent both integer and floating-point values.

Unlike many other languages, JavaScript does not have separate data types like int, float, or double.
```
const age = 21;       // integer
const price = 99.99;  // floating-point

console.log(typeof age);   // "number"
console.log(typeof price); // "number"
```
String : A String is used to represent a collection of characters (text data).

Immutability:

Once a string is created, it cannot be changed. Methods like toUpperCase() return a new string instead of modifying the original one.
```
const name = "john";

const upperName = name.toUpperCase();

console.log(name);       // "john" (original remains same)
console.log(upperName);  // "JOHN" (new string)
```
Boolean : The Boolean data type represents only two values: true or false.

These values are case-sensitive and must be written in lowercase.

TRUE or FALSE are not considered valid Boolean values.

const isLoggedIn = true;
const hasPermission = false;

console.log(typeof isLoggedIn);   // "boolean"
console.log(typeof hasPermission); // "boolean"

null : null is used to represent an intentional absence of value (empty).

It does not mean 0; it means that no value is assigned.

let user = null;

console.log(user);        // null
console.log(typeof user); // "object" (this is a known JavaScript quirk)

Undefined : From the name itself , you can understand it represent the value is not defined. When a variable is declared but not assigned any value. It is undefined.
```
let name;

console.log(name);        // undefined
console.log(typeof name); // "undefined"
```
BigInt : BigInt is used to represent very large integers that are beyond the limit of the normal Number type.

In JavaScript, the Number type can safely store integers only up to:

2^53 - 1

For values larger than this, we use BigInt.
```
const bigNumber = 1234567890123456789012345678901234567890n;

console.log(bigNumber);        // very large number
console.log(typeof bigNumber); // "bigint"
```
Symbol : symbol is used to represent unique value.

It is immutable once created It cannot be changed. It always return a unique value even if the description is same.

Non-Enumerable: When used as a key in an object, Symbols do not show up in standard loops like for...in or methods like Object.keys().
```
const sym1 = Symbol("id");
const sym2 = Symbol("id");

console.log(sym1 === sym2); // false (always unique)
```

Non-Primitive Data Types : There are two types of non-primitive data types.

Arrays and Objects are non-primitive. They are mutable because they share the reference in the memory. if we change in non-primitive data type it will affect original data.

Arrays : Arrays are collection of multiple data in contiguous order in a single variable.

const numbers = [1 , 2 , 3 , 4]

console.log(numbers);

// output : [1 , 2 , 3 , 4]

Arrays are dynamically sized can grow and shrink its length automatically when you add or remove a value from array.

Array can store multiple datatypes.

const multipleData = [1 , 2 , "email", true};

But in javaScript array is actually a type of object.

When you check its type using typeof, it returns "object".

const numbers = [1, 2, 3];

console.log(typeof numbers); // "object"

So how to check it is an array :

Since typeof() is not reliable for array you can use Array.isArray()

const arr = [1, 2, 3];

console.log(Array.isArray(arr)); // true

If return value is true it is an array otherwise it is not an array.

Objects : An Object in JavaScript is used to store data in the form of key–value pairs.

Each key (also called a property) is associated with a value, which can be of any data type.

const user = {
  name: "john",
  age: 21,
  isStudent: true
};

console.log(user.name); // "john"
console.log(user.age);  // 21

Values can be of any type (number, string, array, function, etc.)
You can access values using dot notation or bracket notation

Bracket notation Example :

const user = {
  name: "john",
  age: 21
};

console.log(user["name"]); // "john"

Summary : In this blog, we explored the fundamentals of JavaScript, starting with variables and their scope. We also understood the concept of dynamic typing and how JavaScript determines data types at runtime.

Further, we discussed variables using var, let, and const, along with their differences in scope, re-declaration, and re-assignment. The concept of scope—global, function, and block scope—was explained with simple examples to build a strong foundation.

We also explore primitive and non-primitive data types.

By the end of this blog, you should have a clear understanding of how JavaScript handles data and variables, which is essential for writing clean and error-free code.

Array Methods You Must Know

Abhishek sahni — Thu, 30 Apr 2026 08:01:31 +0000

In this blog we are going to learn most useful methods of arrays in javaScript. Javascript provides multiple built-in methods for common tasks so, that se don't need to write the logic from scratch.

push() and pop() : Both function perform very simple and common task.

push() : From the name you can guess it is used to push(add) new values in array at the end of the array and return new array length.

const fruits = ['apple', 'banana'];
const newLength = fruits.push('orange', 'mango'); 

console.log(fruits);    // ["apple", "banana", "orange", "mango"]
console.log(newLength); // 4

pop() : This method remove the last element from the array from original array.

it returns the removed element.

const fruits = ['apple', 'banana', 'cherry'];
const lastFruit = fruits.pop(); 

console.log(fruits);    // ["apple", "banana"] (original array modified)
console.log(lastFruit); // "cherry" (returned value)

shift() and unshift() : : Both methods are used to manipulate beginning of the array.

shift() : This method remove first element of the array and return that removed element. This method directly change into original array length and content.

If the array is empty it returns undefined.

let fruits = ["Apple", "Banana", "Cherry"];
let first = fruits.shift(); 
console.log(first);  // "Apple"
console.log(fruits); // ["Banana", "Cherry"]

unshift() : This method adds one or more elements at the beginning of the array.

Yes, it changes the original array. Always return the new length of array.

If you pass multiple arguments , they are inserted at the beginning in the same order they are provided.

let numbers = [3, 4];
let newLength = numbers.unshift(1, 2);
console.log(newLength); // 4
console.log(numbers);   // [1, 2, 3, 4]

Array map() :

map() is a method used to loop through all elements of an array.

Non-mutating:

It does not modify the original array; instead, it returns a new array.

Inside map(), we use a callback function. The first parameter of the callback represents the current element, and the second parameter represents the index of that element.

const numbers = [1, 2, 3];
const doubled = numbers.map((num) =>{
    return num * 2

}); 
console.log(doubled); // [2, 4, 6]

Let's understand the above code.

We have an array: [1, 2, 3]
We use .map() on this array
map() loops through each element one by one

In each iteration:

First iteration → num = 1
Second iteration → num = 2
Third iteration → num = 3

In every iteration, map() applies the logic inside the callback function and returns the result.

These results are collected into a new array.

Output :

[2, 4, 6] //new array

Array filter() :The filter() method loops through all elements of an array and returns a new array. It does not modify the original array.

It returns only those elements that pass a specific condition.

const numbers = [1, 2, 3, 4, 5];

const result = numbers.filter((num) => {
  return num > 2;
});

console.log(result); // [3, 4, 5]

Let's understand the above code.

filter() checks each element one by one
If the condition returns true, the element is included
If it returns false, the element is skipped

So, only elements that satisfy the condition are added to the new array.

Array reduce() : The reduce method runs a callback functions on each element of array and calculate result of each element into single variable based on the logic you provide.

array.reduce((accumulator, currentValue) => {
  // logic
}, initialValue);

accumulator → stores the result

currentValue → current element of the array

initialValue → starting value of the accumulator

Example :

const numbers = [1, 2, 3, 4];

const sum = numbers.reduce((acc, num) => {
  return acc + num;
}, 0);

console.log(sum); // 10

Errors: Calling reduce on an empty array without an initialValue throws a TypeError.

forEach() : forEach() is an in-built method for arrays that runs a callback function for each element of array.

Return value : It always return undefined. If you want to transform array you should use map() instead .

const numbers = [1, 2, 3];

numbers.forEach((num) => {
  console.log(num);
});

Output :

1
2
3

Important point : Unlike map() or filter(), forEach() does not return a new array. It simply performs an action on each element.

Purpose : It is used for "side effects" like logging data , updating variable outside the loop or DOM manipulation.

side effects : A side effect means doing something inside a function that affects things outside the function, instead of just returning a value.

Example of Side effect :

const arr = [1, 2, 3];

let sum = 0; // declared outside

arr.forEach((num) => {
  sum += num; // updating outside variable
});

console.log(sum); // 6

Summary : In this blog, we focused on the most common and widely used array methods in JavaScript. We studied each method in detail with practical code examples.

Control Flow in JavaScript: If, Else, and Switch Explained

Abhishek sahni — Wed, 29 Apr 2026 11:45:51 +0000

Understanding the control flow of a program is very important to understand the behaviour of code. This blog will help you understand control flow in JavaScript.

What does control flow mean in programming?

Control flow refers to the order in which statements in a program are executed, usually from top to bottom.

However, in many cases, we need to skip or repeat certain parts of the program based on conditions.

JavaScript provides control flow statements that allow us to control the execution of code and skip specific parts when needed.

The `if` statement :

The if statement is the most basic control flow statement. It simply checks whether a condition is true. If the condition is true, the code inside the if block runs; otherwise, the block is skipped.

Example :

let age = 18;

if (age >= 18) {
  console.log("You are eligible to vote");
}

In the above code, the condition is age >= 18.

The value of age is 18.

So, the condition becomes 18 >= 18, which evaluates to true. Therefore, the code inside the if block will run.

The `if-else` statement :

First, the if block checks the condition. If the condition evaluates to true, the code inside the if block runs; otherwise, the code inside the else block runs.

Example :

let age = 16;

if (age >= 18) {
  console.log("You are eligible to vote");
} else {
  console.log("You are not eligible to vote");
}

The `else if` ladder :

The if-else ladder is used when we need to check multiple conditions. It allows us to execute different blocks of code based on different conditions.

In an if-else ladder, conditions are checked one by one from top to bottom. As soon as one condition evaluates to true, its corresponding block runs, and the rest of the conditions are skipped.

If none of the conditions are true, the else block runs.

Example :

let marks = 75;

if (marks >= 90) {
  console.log("Grade A");
} else if (marks >= 75) {
  console.log("Grade B");
} else if (marks >= 50) {
  console.log("Grade C");
} else {
  console.log("Fail");
}

output: Grade B

The `switch` statement :

The switch statement works like an if-else ladder, but it is often more readable and clean when dealing with multiple conditions based on a single value.

In a switch statement, we define different case blocks. The value of the expression is compared with each case. If a match is found, the corresponding block of code runs.

If none of the cases match, the default block runs.

Break statement : The break statement is used to stop the execution of the switch block. Without break, the execution continues to the next case, even if a match is found.

Example :

let day = 2;

switch (day) {
  case 1:
    console.log("Monday");
    break;
  case 2:
    console.log("Tuesday");
    break;
  case 3:
    console.log("Wednesday");
    break;
  default:
    console.log("Invalid day");
}

When to use switch vs if-else :

switch:

Use the switch statement when you need to compare a single value with multiple fixed values.

Conditions are based on strict equality (===) checks.

(Refer to the above example.)

if-else:

Use if-else when you need to evaluate conditions that return true or false. Based on the result, the corresponding code block runs.

It is especially useful when working with:

ranges (e.g., >, <)
multiple conditions (&&, ||)
complex logic

Summary :

In this blog, we learned what control flow in a program is. We discussed how we can control the flow of code using control flow statements in JavaScript with practical examples.

We also explored the use of switch and if-else statements.

String Polyfills and Common Interview Methods in JavaScript

Abhishek sahni — Wed, 29 Apr 2026 11:43:53 +0000

Introduction

In this blog, you are going to learn how JavaScript built-in methods work internally. You will also learn how developers make JavaScript compatible with older browsers using polyfills.

What are polyfills :

A polyfill is a piece of JavaScript code that adds support for modern features in older browsers that don’t support them natively.

If the browser doesn’t have a feature, we create it ourselves.

Example :

Let's take an example that older browser doesn't support Array.prototype.includes.

We write polyfill like this

if (!Array.prototype.includes) {
  Array.prototype.includes = function (value) {
    for (let i = 0; i < this.length; i++) {
      if (this[i] === value) {
        return true;
      }
    }
    return false;
  };
}

What are Built-in methods?

Built-in methods are predefined functions provided by the JavaScript runtime environment that are used to perform specific tasks. We don’t need to write the logic from scratch. Conceptually, they are methods (functions) attached to the prototype of built-in objects.

const str = "hello world";

const result = str.toUpperCase();

console.log(result); // "HELLO WORLD"

toUpperCase() method is defined in String.prototype

we are just using it , not created it.

How they works internally

A method is a property of an object stored in standard built-in objects (e.g., String.prototype, Array.prototype, Math).

Example of a string method :

console.log(String.prototype.toUpperCase);

[Function: toUpperCase]

This shows that toUpperCase exists inside String.prototype.

Methods are on prototypes not on each string :

const str1 = "hello";
const str2 = "world";

console.log(str1.toUpperCase === str2.toUpperCase); // true

This means both str1 and str2 use the same function.

String.prototype.toUpperCase

That function lives here.

Internal Working :

When you do

"hello".toUpperCase()

JavaScript actually look like this .

String.prototype.toUpperCase.call("hello")

Calling same function for all string values.

If every string had its own copy:

str1.toUpperCase = function() {}
str2.toUpperCase = function() {}

Memory waste.

Important Question :

Technically , In javaScript primitive datatypes does not have their own methods and properties because they are not object.

String is also primitive data type. How can we use it like this? Because we can usually access values with dot notation (.) only in objects. But here, "hello" is a string.

"hello".toUpperCase()

However they behave as they have methods because of the process called auto boxing.

So, when we use a built-in method on any value, in this case a string, JavaScript internally does this:

new String("hello").toUpperCase()

Once the method is executed, the temporary object is destroyed and the result is returned.

Exceptions : Null and Undefined: These are the only primitives that do not have object wrappers. Attempting to access a method on null or undefined will result in a TypeError.

Now you understand how built- in method work internally.

Common interview string problems :

1. Reverse string :

function reverseString(str) {
  return str.split('').reverse().join('');
}

Interviews will ask this to solve without built-in methods

function reverseString(str) {
  let result = '';
  for (let i = str.length - 1; i >= 0; i--) {
    result += str[i];
  }
  return result;
}

2. Check Palindrome :

function isPalindrome(str) {
  let reversed = str.split('').reverse().join('');
  return str === reversed;
}

without built-in method

function isPalindrome(str) {
  let left = 0, right = str.length - 1;

  while (left < right) {
    if (str[left] !== str[right]) return false;
    left++;
    right--;
  }
  return true;
}

3. Longest Substring Without Repeating Characters :

Very Important

function longestUniqueSubstring(s) {
  let set = new Set();
  let left = 0;
  let maxLength = 0;

  for (let right = 0; right < s.length; right++) {
    while (set.has(s[right])) {
      set.delete(s[left]);
      left++;
    }

    set.add(s[right]);
    maxLength = Math.max(maxLength, right - left + 1);
  }

  return maxLength;
}

Summary :

In this blog, we learned why developers write polyfills. We also explored some built-in string methods and, most importantly, understood how these methods work internally.

This deeper understanding helps you grasp core JavaScript concepts and prepares you better for interviews.

Finally, we discussed three common string-based interview questions in JavaScript.

String Polyfills and Common Interview Methods in JavaScript

Abhishek sahni — Wed, 29 Apr 2026 08:11:03 +0000

Introduction

In this blog, you are going to learn how JavaScript built-in methods work internally. You will also learn how developers make JavaScript compatible with older browsers using polyfills.

What are polyfills :

A polyfill is a piece of JavaScript code that adds support for modern features in older browsers that don’t support them natively.

If the browser doesn’t have a feature, we create it ourselves.

Example :

Let's take an example that older browser doesn't support Array.prototype.includes.

We write polyfill like this

if (!Array.prototype.includes) {
Array.prototype.includes = function (value) {
for (let i = 0; i < this.length; i++) {
if (this[i] === value) {
return true;
}
}
return false;
};
}

What are Built-in methods?

const str = "hello world";

const result = str.toUpperCase();

console.log(result); // "HELLO WORLD"

toUpperCase() method is defined in String.prototype
we are just using it , not created it.

How they works internally

A method is a property of an object stored in standard built-in objects (e.g., String.prototype, Array.prototype, Math).

Example of a string method :

console.log(String.prototype.toUpperCase);

[Function: toUpperCase]

This shows that toUpperCase exists inside String.prototype.

Methods are on prototypes not on each string :

const str1 = "hello";
const str2 = "world";

console.log(str1.toUpperCase === str2.toUpperCase); // true

This means both str1 and str2 use the same function.

String.prototype.toUpperCase

That function lives here.

Internal Working :

When you do

"hello".toUpperCase()

JavaScript actually look like this .

String.prototype.toUpperCase.call("hello")

Calling same function for all string values.

If every string had its own copy:

str1.toUpperCase = function() {}
str2.toUpperCase = function() {}

Memory waste.

Important Question :

Technically , In javaScript primitive datatypes does not have their own methods and properties because they are not object.

String is also primitive data type. How can we use it like this? Because we can usually access values with dot notation (.) only in objects. But here, "hello" is a string.

"hello".toUpperCase()

However they behave as they have methods because of the process called auto boxing.

So, when we use a built-in method on any value, in this case a string, JavaScript internally does this:

new String("hello").toUpperCase()

Once the method is executed, the temporary object is destroyed and the result is returned.

Exceptions : Null and Undefined: These are the only primitives that do not have object wrappers. Attempting to access a method on null or undefined will result in a TypeError.

Now you understand how built- in method work internally.

Common interview string problems :

Reverse string :

function reverseString(str) {
return str.split('').reverse().join('');
}

Interviews will ask this to solve without built-in methods

function reverseString(str) {
let result = '';
for (let i = str.length - 1; i >= 0; i--) {
result += str[i];
}
return result;
}

Check Palindrome :

function isPalindrome(str) {
let reversed = str.split('').reverse().join('');
return str === reversed;
}

without built-in method

function isPalindrome(str) {
let left = 0, right = str.length - 1;

while (left < right) {
if (str[left] !== str[right]) return false;
left++;
right--;
}
return true;
}

Longest Substring Without Repeating Characters :

Very Important

function longestUniqueSubstring(s) {
let set = new Set();
let left = 0;
let maxLength = 0;

for (let right = 0; right < s.length; right++) {
while (set.has(s[right])) {
set.delete(s[left]);
left++;
}

set.add(s[right]);
maxLength = Math.max(maxLength, right - left + 1);

}

return maxLength;
}

Summary :

In this blog, we learned why developers write polyfills. We also explored some built-in string methods and, most importantly, understood how these methods work internally.

This deeper understanding helps you grasp core JavaScript concepts and prepares you better for interviews.

Finally, we discussed three common string-based interview questions in JavaScript.

String Polyfills and Common Interview Methods in JavaScript

Abhishek sahni — Mon, 27 Apr 2026 11:45:49 +0000

Introduction

In this blog, you are going to learn how JavaScript built-in methods work internally. You will also learn how developers make JavaScript compatible with older browsers using polyfills.

What are polyfills :

A polyfill is a piece of JavaScript code that adds support for modern features in older browsers that don’t support them natively.

If the browser doesn’t have a feature, we create it ourselves.

Example :

Let's take an example that older browser doesn't support Array.prototype.includes.

We write polyfill like this

if (!Array.prototype.includes) {
  Array.prototype.includes = function (value) {
    for (let i = 0; i < this.length; i++) {
      if (this[i] === value) {
        return true;
      }
    }
    return false;
  };
}

What are Built-in methods?

const str = "hello world";

const result = str.toUpperCase();

console.log(result); // "HELLO WORLD"

toUpperCase() method is defined in String.prototype

we are just using it , not created it.

How they works internally

A method is a property of an object stored in standard built-in objects (e.g., String.prototype, Array.prototype, Math).

Example of a string method :

console.log(String.prototype.toUpperCase);

[Function: toUpperCase]

This shows that toUpperCase exists inside String.prototype.

Methods are on prototypes not on each string :

const str1 = "hello";
const str2 = "world";

console.log(str1.toUpperCase === str2.toUpperCase); // true

This means both str1 and str2 use the same function.

String.prototype.toUpperCase

That function lives here.

Internal Working :

When you do

"hello".toUpperCase()

JavaScript actually look like this .

String.prototype.toUpperCase.call("hello")

Calling same function for all string values.

If every string had its own copy:

str1.toUpperCase = function() {}
str2.toUpperCase = function() {}

Memory waste.

Important Question :

Technically , In javaScript primitive datatypes does not have their own methods and properties because they are not object.

String is also primitive data type. How can we use it like this? Because we can usually access values with dot notation (.) only in objects. But here, "hello" is a string.

"hello".toUpperCase()

However they behave as they have methods because of the process called auto boxing.

So, when we use a built-in method on any value, in this case a string, JavaScript internally does this:

new String("hello").toUpperCase()

Once the method is executed, the temporary object is destroyed and the result is returned.

Exceptions : Null and Undefined: These are the only primitives that do not have object wrappers. Attempting to access a method on null or undefined will result in a TypeError.

Now you understand how built- in method work internally.

Common interview string problems :

1. Reverse string :

function reverseString(str) {
  return str.split('').reverse().join('');
}

Interviews will ask this to solve without built-in methods

function reverseString(str) {
  let result = '';
  for (let i = str.length - 1; i >= 0; i--) {
    result += str[i];
  }
  return result;
}

2. Check Palindrome :

function isPalindrome(str) {
  let reversed = str.split('').reverse().join('');
  return str === reversed;
}

without built-in method

function isPalindrome(str) {
  let left = 0, right = str.length - 1;

  while (left < right) {
    if (str[left] !== str[right]) return false;
    left++;
    right--;
  }
  return true;
}

3. Longest Substring Without Repeating Characters :

Very Important

function longestUniqueSubstring(s) {
  let set = new Set();
  let left = 0;
  let maxLength = 0;

  for (let right = 0; right < s.length; right++) {
    while (set.has(s[right])) {
      set.delete(s[left]);
      left++;
    }

    set.add(s[right]);
    maxLength = Math.max(maxLength, right - left + 1);
  }

  return maxLength;
}

Summary :

In this blog, we learned why developers write polyfills. We also explored some built-in string methods and, most importantly, understood how these methods work internally.

This deeper understanding helps you grasp core JavaScript concepts and prepares you better for interviews.

Finally, we discussed three common string-based interview questions in JavaScript.

Async/Await in JavaScript: Writing Cleaner Asynchronous Code

Abhishek sahni — Wed, 01 Apr 2026 11:36:10 +0000

“If you write asynchronous code using promises, this blog is for you.
In this blog, we explore Async/Await in JavaScript.”

What is Async/Await:

Async/Await keywords are used to write asynchronous code that looks like synchronous code. It makes your code more readable and clean.
They are just syntactic sugar over JavaScript promises.

Async keyword:

We can use the async keyword with any function. This keyword ensures that the function always returns a promise.
If a function returns a non-promise value, JavaScript automatically wraps it in a resolved promise.

Await keyword:

We use the await keyword with code that takes time to resolve.
The await keyword pauses the execution of the function until the promise is either resolved or rejected.
While the function is paused, the JavaScript thread is free to perform other tasks.

How Async/Await work together:
async creates a promise based function.
await wait for the promise to resolve inside that function.

Code Example of Async/Await

function fetchData() {
  return new Promise((resolve, reject) => {
    setTimeout(() => {
      resolve("Data fetched successfully!");
    }, 2000);
  });
}

// async function
async function getData() {
  console.log("Fetching data...");

  const result = await fetchData(); // waits here

  console.log(result);
}

getData();

output : 
Fetching data...
(Data comes after 2 seconds)
Data fetched successfully!

Same code Without Async/Await(Promises)

function fetchData() {
  return new Promise((resolve, reject) => {
    setTimeout(() => {
      resolve("Data fetched successfully!");
    }, 2000);
  });
}

function getData() {
  console.log("Fetching data...");

  fetchData().then((result) => {
    console.log(result);
  });
}

getData();

.then() callback style.
await easy to read and understand.

Error handling with async code :

Error handling in asynchronous code ensures that failures (like database errors) are handled without crashing the application.

Try-Catch is the standard way to handle errors in modern JavaScript.
You use the await keyword inside the try block. If any error occurs, the catch block executes and handles the error.

async function getData() {
  try {
    const result = await fetchData(); // if promise rejects, control goes to catch
    console.log(result);
  } catch (error) {
    console.log("Error:", error);
  }
}

Conclusion :

In this blog, we learned how to write cleaner and more readable asynchronous code using the Async/Await keywords. We also explored error handling using try-catch inside an asynchronous function.

Understanding this keyword in javaScript

Abhishek sahni — Tue, 31 Mar 2026 10:26:22 +0000

If you work in JavaScript, you have probably seen the this keyword many times. Many developers have a basic understanding of it, but there is still a lot of confusion around it because its behaviour changes depending on the current context.

What is `this` keyword :

Let’s understand the this keyword with an example. Think of this as an actor. An actor changes their role in every movie depending on the context of the movie.

Similarly, the this keyword also behaves like an actor because it changes its behaviour according to the current context in JavaScript.

Definition of this word :

this keyword is reference to the object of currently executing functions. its value is not static. It is determined at runtime based on how a function is called.

Now let's see behaviour of this keyword in various different context .

`this` in Global context :

In browser :this in the global context refers to the window object.

In Node.js, when you use this in the global context (at the top of a file, outside all functions), it refers to the module.exportsobject.

This happens because, before executing your file, Node.js wraps your code inside a function. So, it is not truly running in the global scope like in the browser.

Node.js internally wraps your code like this:

(function (exports, require, module, __filename, __dirname) {
  // your code here
});

So this is equal to module.exports

but when you print this at the top of the file (in global context).

console.log(this);

//output : {} output will be an empty object.

Because by default :

module.exports = {};

`this` inside objects :

When this is used inside an object method, it refers to the object that is calling the function.

Code example :

const user = {
  name: "John",
  greet: function () {
    console.log(this.name);
  }
};

user.greet();
// output : John

because user calling the function. this = user

so when you write this.name it is equal to user.name.

it clear that who is calling the function that is this .

const user = {
  name: "John",
  greet: function () {
    console.log(this);
  }
};

user.greet();
//output : { name: "Abhi", greet: [Function] }
// this = whole object.

this inside Nested Function : this is undefined inside nested functions .

const user = {
  name: "John",
  greet: function () {
    function inner() {
      console.log(this.name);
    }
    inner();
  }
};

user.greet();
//output : undefined

Detached Function : When you extract method from an object and call it separately.

const user = {
  name: "John",
  greet: function () {
    console.log(this.name);
  }
};

const fn = user.greet; // function detached

fn(); // called independently

// output : undefined

when you extract the method from object. this is lost because you call that method without any object.

This inside Functions :

Regular Function (using function keyword) : Behaviour of this is depend on how the function is called.

this refers to the global object (window in browsers, globalin Node.js).

but it is undefined in "strict mode".

Function inside object:

const user = {
  name: "John",
  greet: function () {
    function inner() {
      console.log(this);
    }
    inner();
  }
};

user.greet();

Output: Browser → window Node.js → undefined

Because inner is a normal function not called by object.So this lost again.

Constructor call : when you call a constructor using new keyword this always refers to the newly created instance .

Arrow Functions : Arrow functions does not have their own this . they inherit their this from parent scope where it is defined.

const user = {
  name: "John",
  greet: function () {
    const inner = () => {
      console.log(this.name);
    };
    inner();
  }
};

user.greet();

Conclusion :

In this blog, we explored the behavior of the this keyword across different JavaScript environments. We also understood how this works inside functions, arrow functions, and objects.

Array flattening in javaScript (basic to advance)

Abhishek sahni — Mon, 30 Mar 2026 06:51:50 +0000

Before taking the dive into the concept of array flattening let's understand what are nested arrays.

Nested arrays are nothing just an array inside another array. Nested arrays are used to handle complex data in organise way that cannot be represented by a linear array.

Code Example :

const numbers = [1, 2, [3, 4], 5];

console.log(numbers[2]);      // [3, 4]
console.log(numbers[2][0]);   // 3
console.log(numbers[2][1]);   // 4

how above code work

index 2 gives -> [ 3 , 4 ]

[2][0] gives -> 3

So , now we understand nested arrays but what is array flattening ?

Array flattening is a process to combine multi-dimensional (nested) arrays by extracting all sub-arrays into a singe main array.

what is the use case of array flattening ?

Api response : when real world data arrive from sever it may be a nested array. So we combine multiple array into one single array to simplify the response.

const users = [
  { name: "Abhi", skills: ["HTML", "CSS"] },
  { name: "Rahul", skills: ["JS", "React"] }
];

const allSkills = users.map(user => user.skills).flat();

console.log(allSkills);
// ["HTML", "CSS", "JS", "React"]

It makes search and filter easy.

Form Data Processing :

const formSections = [
  ["name", "email"],
  ["password", "confirmPassword"]
];

const allFields = formSections.flat();

console.log(allFields);
// ["name", "email", "password", "confirmPassword"]

Now we can perform data validation easily .

Matrix / Grid Problems : It simply calculations and makes searching and filtering easy.

const matrix = [
  [1, 2],
  [3, 4],
  [5, 6]
];

const flatMatrix = matrix.flat();

console.log(flatMatrix);
// [1, 2, 3, 4, 5, 6]

Now you get the idea how you can use the concept of array flattening.

There are different approaches to flatten array Let's see the one by one.

Different approaches to flatten array :

Build in methods : JavaScript provides built-in methods to flatten arrays that are optimized and easy to use.

`flat()` Method:

.flat() is a built-in method that combines elements of all sub-arrays into a single array.

It performs single-level flattening by default.

.flat(2) → Performs flattening up to depth level 2

.flat(Infinity) → Flattens all sub-arrays into a single array

`flatMap()` Method:

flatMap() is a combination of map() and flat().

It removes the extra array layer from the return value of map().

It is slightly more optimized than using map() and flat() separately.

Code Example :

without flatMap()

const arr = [1, 2, 3];

const result = arr.map(num => [num * 2]);

console.log(result);
// [[2], [4], [6]]   nested array

const final = result.flat();

console.log(final);
// [2, 4, 6]

with flatMap()

const arr = [1, 2, 3];

const result = arr.flatMap(num => [num * 2]);

console.log(result);

// [2, 4, 6]

Using `foreach()` loop :

Loop through array

Check: element is array or not

If array → add all elements

If not → push directly

const arr = [1, [2, 3], [4, 5]];
let result = [];

arr.forEach(item => {
  if (Array.isArray(item)) {
    item.forEach(val => result.push(val));
  } else {
    result.push(item);
  }
});

console.log(result);

Common Interview Scenarios :

Flatten Infinite Nested Array :

//input  :  [1, [2, [3, [4]]]]

//expected output : [1, 2, 3, 4]

1 → not array → push

[2, [3, [4]]] → array → call again

function flatten(arr) {
  let result = [];

  for (let item of arr) {
    if (Array.isArray(item)) {
      result = result.concat(flatten(item)); // recursion
    } else {
      result.push(item);
    }
  }

  return result;
}

Stack Approach (Iterative) :

Put all elements into a stack

Process one by one

If array → break it and push back

If value → add to result

function flatten(arr) {
  let stack = [...arr];
  let result = [];

  while (stack.length) {
    let item = stack.pop();

    if (Array.isArray(item)) {
      stack.push(...item);
    } else {
      result.push(item);
    }
  }

  return result.reverse();
}

Why interviewer ask this ? :

Recursion understanding : can you solve a problem that repeat itself .

Problem Breakdown : Can you handle unknown depth?

Edge Cases : Empty arrays and mixed datatypes .

Conclusion :

In this blog, we learned what nested arrays are and how to convert them into a single array.

We also explored the use cases and interview perspectives of array flattening with practical code examples.

Spread vs Rest Operator In JavaScript

Abhishek sahni — Thu, 26 Mar 2026 13:19:25 +0000

It is very confusing to use spread and rest operator in javaScript because both have same syntax (...) but working is totally different .

Let's see the difference between them.

Spread Operator : The spread operator is used to expand or spread individual values of an array or properties of an object.

Code Example :

const arr = [1, 2];
console.log(...arr); // 1 2

It takes [1, 2] and spread values of array and return 1 2.

Function Example :

with spread operator

function add (a , b){
    return a+b;
}

const arr = [3 , 4];

console.log(add(...arr)); // 3 ,4 we spread the values of array.

Same function without spread operator

function add(a, b)
 { 
    return a + b; 
 }

const arr = [3, 4];

console.log(add(arr[0], arr[1])); // 7

Rest Operator : It is opposite of spread operator. It collect all remaining properties from an object or array in a new array or object.

with rest operator

function sum(...nums)
 { 
    console.log(nums);
 }

sum(1, 2, 3); // [1, 2, 3]

without rest operator

function sum() 
{ 
    const nums = Array.from(arguments); 
    console.log(nums); 
}

sum(1, 2, 3); // [1, 2, 3]

Now you understand the basic working of spread and rest operator. Let's the use cases of both operators.

Use Cases of Spread Operator :

Copy an array :

const arr1 = [1, 2, 3];
const arr2 = [...arr1];

console.log(arr2); // [1, 2, 3]

Merge arrays :

const a = [1, 2];
const b = [3, 4];

const result = [...a, ...b];

console.log(result); // [1, 2, 3, 4]

Add Element in array :

const arr = [1, 2];

const newArr = [...arr, 3, 4];

console.log(newArr); // [1, 2, 3, 4]

Copy Object :

const user = { name: "Abhi", age: 20 };

const newUser = { ...user };

console.log(newUser);

Merge Objects :

const obj1 = { a: 1 };
const obj2 = { b: 2 };

const result = { ...obj1, ...obj2 };

console.log(result); // { a: 1, b: 2 }

Override Values :

const user = { name: "Abhi", age: 20 }; // age = 20

const updated = { ...user, age: 25 };

console.log(updated); // age updated now age = 25

Shallow Copy : A shallow copy creates a new array or object by copying only the first level of data. Nested objects and arrays are not copied; they remain shared by reference with the original.

Conclusion :

In this blog, we explored the core concepts of destructuring, rest, and spread operators in JavaScript. We understood how destructuring helps extract values in a clean and readable way, while the spread operator expands data and the rest operator collects it efficiently.

We also learned important concepts like shallow copy and how nested objects and arrays are still shared by reference.

Forem: Abhishek sahni

What is Middleware in Express and How It Works

What is Middleware?

req (Request)

res (Response)

next()

Important Note

Types of Middleware :

Let's dive into the execution order of middleware :

Real work example of middleware :

Arrow functions in JavaScript

Understanding Variables and Data Types in JavaScript

Array Methods You Must Know

Control Flow in JavaScript: If, Else, and Switch Explained

The if statement :

The if-else statement :

The else if ladder :

The switch statement :

Example :

When to use switch vs if-else :

Summary :

String Polyfills and Common Interview Methods in JavaScript

Introduction

What are polyfills :

Example :

What are Built-in methods?

How they works internally

Methods are on prototypes not on each string :

Important Question :

Summary :

String Polyfills and Common Interview Methods in JavaScript

String Polyfills and Common Interview Methods in JavaScript

Introduction

What are polyfills :

Example :

What are Built-in methods?

How they works internally

Methods are on prototypes not on each string :

Important Question :

Summary :

Async/Await in JavaScript: Writing Cleaner Asynchronous Code

Code Example of Async/Await

Same code Without Async/Await(Promises)

Error handling with async code :

Conclusion :

Understanding this keyword in javaScript

What is this keyword :

this in Global context :

this inside objects :

This inside Functions :

Conclusion :

Array flattening in javaScript (basic to advance)

Code Example :

what is the use case of array flattening ?

Different approaches to flatten array :

flat() Method:

flatMap() Method:

Code Example :

Using foreach() loop :

Common Interview Scenarios :

Stack Approach (Iterative) :

Why interviewer ask this ? :

Conclusion :

Spread vs Rest Operator In JavaScript

Code Example :

Function Example :

Use Cases of Spread Operator :

Conclusion :

`req` (Request)

`res` (Response)

`next()`

The `if` statement :

The `if-else` statement :

The `else if` ladder :

The `switch` statement :

What is `this` keyword :

`this` in Global context :

`this` inside objects :

`flat()` Method:

`flatMap()` Method:

Using `foreach()` loop :