Definition

In JavaScript, every object that is created using a constructor function has a special property called constructor. This property references the function that was used to construct or create the instance of the object. The constructor property is particularly useful for identifying the type of an object and creating new instances of the same type.

Code Example

Here is an example demonstrating the constructor property:

// Constructor function to create Person objects
function Person(firstName, lastName, age) {
  this.firstName = firstName;
  this.lastName = lastName;
  this.age = age;
}

// Creating an instance of Person
const person1 = new Person('John', 'Doe', 30);

// Checking the constructor property
console.log(person1.constructor); // Output: [Function: Person]

// Using the constructor property to create a new instance
const person2 = new person1.constructor('Jane', 'Smith', 25);

console.log(person2); // Output: Person { firstName: 'Jane', lastName: 'Smith', age: 25 }
console.log(person2.constructor); // Output: [Function: Person]

Major Uses

1. Identifying the Constructor of an Object:

   • You can use the constructor property to identify the constructor function that created an instance.

   function Animal(name, species) {
     this.name = name;
     this.species = species;
   }
   
   const dog = new Animal('Rex', 'Dog');
   const cat = new Animal('Whiskers', 'Cat');
   
   console.log(dog.constructor); // Output: [Function: Animal]
   console.log(cat.constructor); // Output: [Function: Animal]
   
   

2. Creating New Instances Dynamically:

   • The constructor property can be used to create new instances of the same type dynamically.

   function Product(name, price) {
     this.name = name;
     this.price = price;
   }
   
   const product1 = new Product('Laptop', 1200);
   const product2 = new product1.constructor('Smartphone', 800);
   
   console.log(product1); // Output: Product { name: 'Laptop', price: 1200 }
   console.log(product2); // Output: Product { name: 'Smartphone', price: 800 }
   
   

3. Prototype Inheritance and Chain Checking:

   • The constructor property is useful in prototype inheritance to check and maintain the chain.

   function Vehicle(type, wheels) {
     this.type = type;
     this.wheels = wheels;
   }
   
   function Car(make, model) {
     Vehicle.call(this, 'Car', 4);
     this.make = make;
     this.model = model;
   }
   
   Car.prototype = Object.create(Vehicle.prototype);
   Car.prototype.constructor = Car; // Correcting the constructor reference
   
   const myCar = new Car('Toyota', 'Camry');
   
   console.log(myCar.constructor); // Output: [Function: Car]
   console.log(myCar instanceof Car); // Output: true
   console.log(myCar instanceof Vehicle); // Output: true
   
   

4. Maintaining the Constructor Chain:

   • When setting up inheritance using Object.create, the constructor property needs to be reset to ensure the correct reference.

   function Shape() {
     this.type = 'Shape';
   }
   
   function Circle(radius) {
     Shape.call(this);
     this.radius = radius;
   }
   
   Circle.prototype = Object.create(Shape.prototype);
   Circle.prototype.constructor = Circle; // Setting the correct constructor
   
   const myCircle = new Circle(5);
   
   console.log(myCircle.constructor); // Output: [Function: Circle]
   console.log(myCircle instanceof Circle); // Output: true
   console.log(myCircle instanceof Shape); // Output: true
   
   

Summary

The constructor property in JavaScript is a reference to the function that created an instance of an object. It is useful for identifying the type of an object, creating new instances dynamically, maintaining prototype chains, and ensuring correct constructor references in inheritance hierarchies. Understanding and utilizing the constructor property enhances the management and manipulation of object instances in JavaScript.