# The new Keyword in JavaScript

JavaScript is often described as a prototype-based language, but many developers first encounter object creation through constructor functions and the `new` keyword. Understanding how `new` works is important because it explains how JavaScript creates object instances, connects prototypes, and enables reusable object behavior.

At first glance, `new` may seem like a simple keyword that creates objects automatically. In reality, it performs several internal steps behind the scenes. Once you understand those steps, constructor functions and prototypes become much easier to reason about.

## What the `new` Keyword Does

The `new` keyword is used when calling a constructor function. It tells JavaScript to create a brand-new object based on that constructor.

Example:

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

const user1 = new User("Pritam");

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

Output:

```javascript
Pritam
```

Here, `new User("Pritam")` creates a new object and assigns `"Pritam"` to the `name` property. Without `new`, the function behaves like a normal function call.

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

const user1 = User("Pritam");

console.log(user1);
```

In strict mode, this can throw an error because `this` becomes `undefined`. In non-strict mode, it may accidentally attach properties to the global object, which is dangerous and unpredictable.

The `new` keyword prevents that problem by creating a proper instance object automatically.

## Constructor Functions

A constructor function is simply a regular function intended to create objects. By convention, constructor function names start with a capital letter.

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

Using the constructor:

```javascript
const car1 = new Car("Toyota", "Corolla");
const car2 = new Car("Honda", "Civic");

console.log(car1.brand);
console.log(car2.model);
```

Output:

```javascript
Toyota
Civic
```

Each object gets its own separate data. Constructor functions became common before ES6 classes existed. Even today, classes internally rely on the same prototype system and object creation behavior.

## Object Creation Process

When JavaScript encounters the `new` keyword, it performs several internal operations automatically.

### Step 1: Create an Empty Object

When this code runs:

```javascript
const person = new Person("Alex");
```

JavaScript first creates an empty object internally.

Conceptually:

```javascript
const obj = {};
```

At this point, the object exists but has no properties.

### Step 2: Link the Prototype

JavaScript then connects the object to the constructor’s prototype.

Conceptually:

```javascript
obj.__proto__ = Person.prototype;
```

This step is critical because it enables prototype inheritance.

### Step 3: Bind `this`

Inside the constructor function, `this` now refers to the newly created object.

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

Equivalent idea:

```javascript
obj.name = name;
```

### Step 4: Execute the Constructor

The constructor function runs normally.

```javascript
Person.call(obj, "Alex");
```

Any properties or methods assigned using `this` are added to the object.

### Step 5: Return the Object

Finally, JavaScript returns the newly created object automatically.

```javascript
return obj;
```

So:

```javascript
const person = new Person("Alex");
```

ends up producing a fully initialized object.

## How `new` Links Prototypes

One of the most important roles of `new` is prototype linking. Every constructor function automatically has a `prototype` object.

Example:

```javascript
function Animal(type) {
  this.type = type;
}

Animal.prototype.sound = function () {
  console.log("Some sound");
};
```

Now create an instance:

```javascript
const dog = new Animal("Dog");

dog.sound();
```

Output:

```javascript
Some sound
```

Even though `sound()` is not directly inside `dog`, JavaScript finds it through the prototype chain.

The lookup process works like this:

1.  Check if `dog` has `sound`
    
2.  If not found, check `Animal.prototype`
    
3.  Execute the method if found
    

This mechanism allows multiple objects to share the same methods instead of duplicating them.

## Why Prototype Linking Matters

Imagine creating methods directly inside the constructor:

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

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

Every instance gets its own separate copy of `greet`.

```javascript
const u1 = new User("A");
const u2 = new User("B");
```

This wastes memory because identical functions are recreated repeatedly.

A better approach:

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

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

Now all instances share one method through the prototype chain. This is more memory-efficient and scales better.

## Instances Created from Constructors

Objects created using `new` are called instances.

```javascript
function Laptop(brand) {
  this.brand = brand;
}

const l1 = new Laptop("Dell");
const l2 = new Laptop("Lenovo");
```

Both `l1` and `l2` are instances of `Laptop`. JavaScript provides the `instanceof` operator to verify this relationship.

```javascript
console.log(l1 instanceof Laptop);
```

Output:

```javascript
true
```

This works because `new` linked the object to `Laptop.prototype`.

## Conclusion

The `new` keyword is much more than a shortcut for creating objects. It controls the full object instantiation process in JavaScript.

When used with constructor functions, `new`:

*   Creates a fresh object
    
*   Connects it to a prototype
    
*   Binds `this`
    
*   Executes initialization code
    
*   Returns the instance
    

This process forms the foundation of JavaScript’s object-oriented behavior.

Understanding how `new` works also makes prototypes, inheritance, constructor functions, and ES6 classes easier to understand. Instead of memorizing syntax, you begin to see the underlying mechanics that power object creation in JavaScript.