You’ve probably seen code like this:

const user = new User("Adarsh", 21);

It looks simple.

But behind the scenes, JavaScript is doing multiple steps automatically.

So the real question is:

What does new actually do?

Let’s break it down in the simplest way possible.

Why do we need new?

Imagine you want to create multiple similar objects:

const user1 = { name: "Adarsh", age: 21 };
const user2 = { name: "Rahul", age: 22 };

This works… but:

• Repetitive ❌

• Not scalable ❌

We need a blueprint.

🏗️ Constructor functions

A constructor function is like a blueprint for creating objects.

function User(name, age) {
  this.name = name;
  this.age = age;
}

Now we can create objects easily:

const user1 = new User("Adarsh", 21);
const user2 = new User("Rahul", 22);

Real-life analogy

Think of a factory :

• Constructor function → factory design

• new → machine that builds products

• Object → final product

🔍 What does new actually do?

When you write:

const user = new User("Adarsh", 21);

JavaScript secretly does 4 steps:

1️⃣ Creates a new empty object

const user = {};

2️⃣ Links it to the constructor’s prototype

user.__proto__ = User.prototype;

This allows the object to access shared methods.

3️⃣ Calls the constructor function

User.call(user, "Adarsh", 21);

this now refers to the new object

4️⃣ Returns the object

return user;

Visual flow

User Constructor
      ↓
 new keyword used
      ↓
Empty object created {}
      ↓
Linked to prototype
      ↓
Constructor runs (this = object)
      ↓
Object returned

Simple example with methods

function Car(brand) {
  this.brand = brand;
}

Car.prototype.drive = function () {
  console.log(`${this.brand} is driving`);
};

const car1 = new Car("BMW");
car1.drive(); // BMW is driving

What’s happening here?

• car1 gets brand from constructor

• drive() comes from prototype

How new links prototypes

This is the most important part.

car1.__proto__ === Car.prototype // true

That’s why car1 can use drive()

Analogy for prototype

Think of it like:

• Prototype = shared toolbox

• Every object gets access to it

Instead of duplicating methods, they share one copy

nstances created from constructors

Each time you use new, you get a new instance.

const user1 = new User("Adarsh", 21);
const user2 = new User("Rahul", 22);

• Different objects

• Same structure

• Shared methods via prototype

Why this is powerful

• Saves memory

• Keeps code organized

• Makes object creation scalable

What happens without new?

const user = User("Adarsh", 21);

Problems:

• this may point to global object

• No new object created

Always use new with constructor functions

Modern alternative (just a note)

Today, we mostly use classes, but internally they still use new.

class User {
  constructor(name) {
    this.name = name;
  }
}

const user = new User("Adarsh");

👉 new is still doing the same work.

🎯 Key takeaway

The new keyword creates a new object, links it to a prototype, runs the constructor, and returns the object.

🏁 Final thoughts

At first, new looks like just a keyword.

But once you understand it:

• You understand how JavaScript creates objects

• You understand prototypes better

• You write cleaner, scalable code