# The new Keyword in JavaScript


JavaScript without `new` is like assembling IKEA furniture without reading the manual. Technically possible. Emotionally dangerous.

A lot of beginners use `new` without understanding what it actually does behind the scenes. They know:

```js
const person = new Person();
```

But internally, JavaScript performs multiple hidden steps like a tiny factory worker building your object.

Let’s break it down properly.

* * *

# What Does the `new` Keyword Do?

The `new` keyword is used to create an object from a constructor function.

When you write:

```js
const user = new User("Gagan");
```

JavaScript automatically performs 4 major steps:

1.  Creates a brand new empty object `{}`
    
2.  Links that object to the constructor's prototype
    
3.  Executes the constructor function with `this` pointing to the new object
    
4.  Returns the newly created object
    

Most developers memorize syntax. Very few understand the actual execution pipeline.

* * *

# Constructor Functions

Before ES6 classes existed, JavaScript mainly used constructor functions to create objects.

Example:

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

Now create instances:

```js
const user1 = new User("Gagan", 19);
const user2 = new User("Rahul", 20);

console.log(user1);
console.log(user2);
```

Output:

```js
User { name: 'Gagan', age: 19 }
User { name: 'Rahul', age: 20 }
```

* * *

# Why Constructor Functions Exist

Without constructors, you would manually create objects repeatedly:

```js
const user1 = {
    name: "Gagan",
    age: 19
};

const user2 = {
    name: "Rahul",
    age: 20
};
```

Now imagine doing this hundreds or thousands of times.

Constructor functions solve this by acting like reusable blueprints for object creation.

* * *

# Step-by-Step: What Happens Internally?

Consider this code:

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

const car1 = new Car("BMW");
```

Internally, JavaScript roughly performs the following operations.

* * *

## Step 1: Create an Empty Object

```js
const obj = {};
```

* * *

## Step 2: Link the Prototype

JavaScript connects the new object to `Car.prototype`.

Conceptually:

```js
obj.__proto__ = Car.prototype;
```

This allows the object to access shared methods.

* * *

## Step 3: Bind `this`

The constructor function executes with `this = obj`

```js
Car.call(obj, "BMW");
```

Inside the constructor:

```js
this.brand = brand;
```

becomes:

```js
obj.brand = "BMW";
```

* * *

## Step 4: Return the Object

Finally:

```js
return obj;
```

So this:

```js
const car1 = new Car("BMW");
```

is approximately equivalent to:

```js
const obj = {};
obj.__proto__ = Car.prototype;

Car.call(obj, "BMW");

return obj;
```

That’s the actual machinery behind `new`.

* * *

# Prototype Linking

Every constructor function automatically gets a `prototype` object.

Example:

```js
function User(name) {
    this.name = name;
}

User.prototype.sayHello = function () {
    console.log(`Hello, I am ${this.name}`);
};
```

Now:

```js
const user1 = new User("Gagan");

user1.sayHello();
```

Output:

```js
Hello, I am Gagan
```

But `user1` itself does not directly contain `sayHello`.

So how does it access the method?

Because of prototype linking.

* * *

# How Prototype Lookup Works

When JavaScript cannot find a property directly on an object:

```js
user1.sayHello
```

it checks:

1.  Inside `user1`
    
2.  Then inside `user1.__proto__`
    
3.  Which points to `User.prototype`
    

That’s why the method works.

* * *

# Constructor → Instance Relationship

Check this:

```js
console.log(user1 instanceof User);
```

Output:

```js
true
```

Because:

```js
user1.__proto__ === User.prototype
```

This prototype chain is what connects instances to constructors.

* * *

# Shared Methods vs Duplicate Methods

Bad approach:

```js
function User(name) {
    this.name = name;

    this.greet = function () {
        console.log("Hello");
    };
}
```

Every object gets its own copy of `greet`.

If you create 10,000 users, you create 10,000 duplicate functions.

Better approach:

```js
function User(name) {
    this.name = name;
}

User.prototype.greet = function () {
    console.log("Hello");
};
```

Now all objects share one method through the prototype.

Efficient and scalable.

* * *

# What Happens If You Forget `new`?

This is where beginners accidentally create chaos.

```js
function User(name) {
    this.name = name;
}

const user1 = User("Gagan");
```

Without `new`:

*   No object gets created
    
*   `this` may point to the global object
    
*   Unexpected bugs can happen
    

In strict mode:

```js
"use strict";
```

JavaScript throws:

```js
TypeError
```

because `this` becomes `undefined`.

* * *

# Modern Alternative: Classes

ES6 introduced classes:

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

    greet() {
        console.log(`Hello ${this.name}`);
    }
}
```

Usage:

```js
const user1 = new User("Gagan");
```

But internally, classes still use prototypes.

`class` is mostly cleaner syntax over constructor functions and prototype-based inheritance.

The engine still performs the same fundamental operations.

* * *

# Constructor → Instance Creation Flow

```text
new User("Gagan")
        ↓
Create empty object {}
        ↓
Link object to User.prototype
        ↓
Bind this to object
        ↓
Execute constructor
        ↓
Return object
```

* * *

# Prototype Linking Visual

```text
user1
  ↓
__proto__
  ↓
User.prototype
  ↓
Object.prototype
  ↓
null
```

This chain is the foundation of JavaScript inheritance.

* * *

# Final Thoughts

The `new` keyword is not just object creation syntax.

It combines:

*   object creation
    
*   prototype linking
    
*   context binding
    
*   automatic object return
    

all inside one keyword.

Once you understand this process, JavaScript’s object system starts making logical sense instead of feeling random.

And suddenly concepts like:

```js
prototype
__proto__
instanceof
constructor functions
prototype chain
```

stop looking like ancient cursed artifacts from Stack Overflow.

* * *

# Specification Section

## Core Concepts to Master

| Concept | Meaning |
| --- | --- |
| Constructor Function | Function used to create objects |
| `new` Keyword | Automates object creation |
| `this` | Refers to the current object instance |
| Prototype | Shared object containing methods |
| Instance | Object created from constructor |
| Prototype Chain | Lookup system for properties and methods |

* * *

## Memory Optimization Insight

This:

```js
this.greet = function(){}
```

creates a new function for every object.

This:

```js
User.prototype.greet = function(){}
```

creates one shared function.

Huge difference at scale.

* * *

## Real Mental Model

Whenever you see:

```js
new Something()
```

mentally translate it to:

```js
Create object → Attach prototype → Run constructor → Return object
```

That’s the actual pipeline.

Not magic. Just hidden automation.

* * *

## Interview-Level Questions You Should Now Understand

*   Difference between constructor functions and classes
    
*   Difference between `prototype` and `__proto__`
    
*   How `instanceof` works
    
*   Why methods should live on prototypes
    
*   What happens if `new` is omitted
    
*   How inheritance works internally
    

If these concepts still feel confusing, revisit prototype linking. That is the central nervous system of JavaScript objects.