# Understanding the new Keyword and Constructor Functions in JavaScript

As you start creating multiple objects in JavaScript, you may notice that writing the same structure again and again becomes repetitive. This is where **constructor functions** and the `new` **keyword** help us create objects efficiently.

They allow us to define a **template** and generate multiple objects from it, similar to how a blueprint creates real-world items.

In this article, we will explore:

*   What the `new` keyword does
    
*   What constructor functions are
    
*   The object creation process step by step
    
*   How `new` links prototypes
    
*   Instances created from constructors
    

All explanations are simple and beginner-friendly.

* * *

## Why Do We Need Constructor Functions?

Imagine creating multiple users like this:

```javascript
let user1 = { name: "Shivam", age: 21 };
let user2 = { name: "Rahul", age: 25 };
let user3 = { name: "Aman", age: 20 };
```

This works, but:

*   code is repetitive
    
*   difficult to scale
    
*   harder to maintain
    

Instead, we can define a **constructor function** and reuse it.

* * *

## What is a Constructor Function?

A **constructor function** is a special function used to create objects.

By convention:

*   its name starts with a capital letter
    
*   it is used with the `new` keyword
    

Example:

```javascript
function Person(name, age) {
  this.name = name;
  this.age = age;
}
```

This function acts as a **blueprint for creating objects**.

* * *

## What Does the `new` Keyword Do?

When you use `new`, JavaScript performs several steps automatically.

Example:

```javascript
let person1 = new Person("Shivam", 21);
```

* * *

## Object Creation Process (Step-by-Step)

When `new Person()` is called, JavaScript does the following:

### Step 1: Creates a new empty object

```javascript
{}
```

* * *

### Step 2: Sets `this` to the new object

Inside the constructor:

```javascript
this → {}
```

* * *

### Step 3: Assigns properties

```javascript
this.name = "Shivam";
this.age = 21;
```

Now the object becomes:

```javascript
{ name: "Shivam", age: 21 }
```

* * *

### Step 4: Links the object to the prototype

The new object is connected to:

```javascript
Person.prototype
```

* * *

### Step 5: Returns the object

Finally, the new object is returned and stored in `person1`.

* * *

## Constructor → Instance Flow

```text
Person (Constructor)
        |
        | new
        v
   New Object Created
        |
        v
person1 (Instance)
```

* * *

## Creating Multiple Instances

Once the constructor is defined, we can create multiple objects easily.

```javascript
let person1 = new Person("Shivam", 21);
let person2 = new Person("Rahul", 25);

console.log(person1);
console.log(person2);
```

Output:

```javascript
Person { name: "Shivam", age: 21 }
Person { name: "Rahul", age: 25 }
```

Each object is called an **instance** of the constructor.

* * *

## Adding Methods Using Prototype

Instead of adding methods inside the constructor (which duplicates them), we attach them to the prototype.

```javascript
Person.prototype.greet = function() {
  console.log("Hello, my name is " + this.name);
};
```

Now every instance can use this method:

```javascript
person1.greet();
person2.greet();
```

Output:

```plaintext
Hello, my name is Shivam
Hello, my name is Rahul
```

* * *

## How `new` Links Prototypes

When an object is created using `new`, it is automatically linked to the constructor’s prototype.

Visual:

```text
person1
   |
   v
Person.prototype
   |
   v
Object.prototype
```

This allows all instances to share common methods.

* * *

## Why This is Important

Without prototype sharing:

*   each object would have its own copy of methods
    
*   memory usage increases
    
*   code becomes inefficient
    

With prototypes:

*   methods are shared
    
*   memory is saved
    
*   code is cleaner
    

* * *

## Example: Car Constructor

```javascript
function Car(brand, speed) {
  this.brand = brand;
  this.speed = speed;
}

Car.prototype.showDetails = function() {
  console.log(this.brand + " runs at " + this.speed + " km/h");
};
```

Create objects:

```javascript
let car1 = new Car("Toyota", 180);
let car2 = new Car("Honda", 200);

car1.showDetails();
car2.showDetails();
```

Output:

```plaintext
Toyota runs at 180 km/h
Honda runs at 200 km/h
```

* * *

## Assignment (Practice Exercise)

Try this in your console.

### 1) Create a Constructor Function

```javascript
function Student(name, age) {
  this.name = name;
  this.age = age;
}
```

* * *

### 2) Create Multiple Instances

```javascript
let s1 = new Student("Aman", 20);
let s2 = new Student("Riya", 22);
```

* * *

### 3) Add a Method Using Prototype

```javascript
Student.prototype.printDetails = function() {
  console.log(this.name + " is " + this.age + " years old");
};
```

* * *

### 4) Call the Method

```javascript
s1.printDetails();
s2.printDetails();
```

* * *

## Prototype Linking Visualization

```text
s1 ---------\
             \
              → Student.prototype → Object.prototype
             /
s2 ---------/
```

All instances share the same prototype.

* * *

## Final Thoughts

The `new` keyword and constructor functions provide a structured way to create multiple objects using a single template. They help reduce repetition and make your code more organized.

By understanding:

*   how constructor functions work
    
*   what the `new` keyword does internally
    
*   how objects are created step by step
    
*   how prototypes link instances
    

you build a strong foundation for understanding **object creation and inheritance in JavaScript**.

As you practice, try creating constructors for real-world entities like **Users, Products, or Orders**. This will help you see how powerful and reusable this pattern can be.