# The new Keyword in JavaScript

In this article we'll learn about another magical keyword of JavaScript, the `new` keyword. The `new` keyword is used to create objects from constructor functions. Instead of manually creating an object every time, `new` helps automate the process and gives you a clean way to create multiple similar objects.

At a high level, when you use `new`, JavaScript does a few things behind the scenes:

*   creates a brand new empty object
    
*   links that object to a prototype
    
*   runs the constructor function with `this` pointing to that new object
    
*   returns the object
    

This is why `new` is so powerful — it bundles multiple steps into one simple line.

## Constructor functions

A constructor function is just a normal function, but by convention it starts with a capital letter and is meant to be used with `new`.

Example:

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

This function doesn’t return anything explicitly, but when used with `new`, it will create and return an object.

## Object creation process

Let’s say we do this:

```javascript
const user1 = new User("Alex", 25);
```

Here’s what actually happens step by step:

1.  JavaScript creates an empty object:
    

```javascript
{}
```

2.  It sets the prototype of this object to `User.prototype`
    
3.  It calls the constructor:
    

```javascript
User.call(newObject, "Alex", 25);
```

So inside the function:

```javascript
this.name = "Alex";
this.age = 25;
```

4.  Finally, it returns the object
    

So `user1` becomes:

```javascript
{
  name: "Alex",
  age: 25
}
```

## How `new` links prototypes

This is where things get interesting.

Every function in JavaScript has a `prototype` property. When you use `new`, the created object is internally linked to that prototype.

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

Now:

```javascript
const user1 = new User("Alex", 25);
user1.greet();
```

Even though `greet` is not inside the object itself, JavaScript looks up the prototype chain and finds it.

So the link looks like this:

```javascript
user1 -> User.prototype -> Object.prototype
```

This is called the prototype chain.

## Instances created from constructors

Each time we use `new`, we create a new instance.

```javascript
const user1 = new User("Alexa", 25);
const user2 = new User("Sam", 30);
```

Both are separate objects:

```javascript
user1 !== user2
```

But they share the same prototype:

```plaintext
user1.__proto__ === user2.__proto__
```

This is efficient because methods are not duplicated for every object -- they live in one place (the prototype).

## Final understanding

The `new` keyword is basically a shortcut for creating objects in a structured way. It handles object creation, sets up the prototype chain, binds `this`, and returns the object automatically. Constructor functions define the blueprint, and each call with `new` creates a new instance that follows that blueprint while sharing common behaviour through prototypes.