The new Keyword — How JavaScript Builds Objects

What Does the new Keyword Do?

When you write new before a function call, you are telling JavaScript: "Don't just run this function use it as a blueprint to create a brand new object."

Without new, a constructor function behaves like any other function. With new, JavaScript quietly does four things behind the scenes that turn that function into an object factory.

A useful mental model: Think of a constructor function as a cookie cutter, and new as the act of pressing it into dough. Each press produces a separate, independent cookie — the same shape, but its own thing

Here is the simplest possible demonstration of what new gives you:

function Car() {
  this.color = "red";
}

// WITHOUT new — just a normal function call
Car(); // returns undefined, this = window

// WITH new — creates a fresh object
const myCar = new Car();
console.log(myCar.color); // "red"

Constructor Functions

A constructor function is just a regular JavaScript function, but written with a specific purpose: to describe what every object created from it should look like.

By convention, constructor functions are named with a capital letter like Person, Car, or Product. This is not required by JavaScript, but it is a universally respected signal that says "call me with new."

Inside the constructor, this refers to the new object being created. Every property you attach to this becomes a property of that new object.

// Constructor function — the blueprint
function Person(name, age) {
  this.name = name; // each object gets its own name
  this.age = age;
  this.greet = function() {
    console.log("Hi, I'm " + this.name);
  };
}

// Creating objects (instances) from the blueprint
const alice = new Person("Alice", 30);
const bob = new Person("Bob", 25);

alice.greet(); // "Hi, I'm Alice"
bob.greet(); // "Hi, I'm Bob"

Notice: alice and bob are completely separate objects. Changing alice.age has zero effect on bob.age. The constructor described the shape, but each instance owns its own data.

1.The Object Creation Process — Step by Step

When you write new Person("Alice", 30), JavaScript silently performs four steps in order. Understanding these steps removes all the mystery from new.

2. A brand new empty object is created

JavaScript creates {} in memory. This is the object that will eventually be returned to you.

3.The prototype is linked

The new object's internal [[Prototype]] is connected to Person.prototype. This gives the object access to shared methods. (More on this in section 4.)

4.The constructor runs with this = new object

The function body executes. Every this.something = ... line adds a property to the new object created in step 1.

5.The new object is returned automatically

Unless you explicitly return a different object, JavaScript hands back the newly created object. You don't need to write return this.

How new Links Prototypes

This is where things get really interesting. When JavaScript creates a new object with new, it doesn't just fill in properties — it also connects the object to a shared pool of methods called the prototype.

Every function in JavaScript automatically has a property called .prototype. When you add a method to Person.prototype, every object created by new Person() can use that method — without each object storing its own copy of it. This saves memory and keeps things organized.

function Person(name, age) {
  this.name = name; // stored ON the object (own property)
  this.age = age;
}

// Shared method — stored on the prototype, not each object
Person.prototype.greet = function() {
  console.log("Hi, I'm " + this.name);
};

const alice = new Person("Alice", 30);
const bob = new Person("Bob", 25);

alice.greet(); // works! looks up prototype chain
bob.greet(); // also works! same shared method

// greet lives on the prototype, not on alice or bob
console.log(alice.hasOwnProperty("name")); // true
console.log(alice.hasOwnProperty("greet")); // false

How lookup works: When you call alice.greet(), JavaScript first looks on alice itself. It's not there. So it follows the prototype link up to Person.prototype, finds greet there, and calls it. This is called the prototype chain.

Instances Created from Constructors

Every object you create with new is called an instance of that constructor. Each instance is independent — its own properties, its own data — but they all share the same prototype methods.

You can confirm an object's origin using instanceof, which checks whether the object was created from a given constructor:

function Person(name, age) {
  this.name = name;
  this.age = age;
}
Person.prototype.greet = function() {
  console.log("Hi, I'm " + this.name);
};

const alice = new Person("Alice", 30);
const bob = new Person("Bob", 25);
const carol = new Person("Carol", 28);

// Each is its own independent object
alice.age = 31; // only changes alice
console.log(bob.age); // still 25 — unaffected

// instanceof confirms their origin
console.log(alice instanceof Person); // true
console.log(alice instanceof Object); // also true!

Here's a side-by-side look at two instances in memory — same shape, completely separate data:

Note: Modern JavaScript introduced the class keyword, which looks cleaner but does the exact same thing underneath — it still uses constructor functions and prototype linking. Understanding new at this level means you truly understand how JavaScript classes work too.

Quick recap: new triggers four silent steps — create an empty object, link it to the constructor's prototype, run the function with this pointing to that object, then return it. Constructor functions are blueprints named with a capital letter. Each call to new produces an independent instance with its own data, but all instances share methods via the prototype chain — keeping memory lean and behavior centralized.