Science Knowings: JavaScript Course For Social Media

Constructor Function

Where We Left Off: Prototype Pattern

In our previous session, we explored the Prototype Pattern, a powerful technique for creating and managing object hierarchies and sharing behavior between different objects.

Introducing Constructor Functions

Today, we dive into Constructor Functions, another fundamental concept in JavaScript that enables us to create objects with defined properties and methods.

What is a Constructor Function?

A Constructor Function is a special function that serves as a blueprint for creating objects. It starts with an uppercase letter and is responsible for initializing and returning a newly created object.

Why Use Constructor Functions?

Constructor Functions provide several advantages:

  • Consistency: Ensure consistent object creation by defining a common template.
  • Reusability: Create multiple objects with similar properties and methods, saving time and effort.
  • Encapsulation: Protect internal object properties and methods from external access.

Creating Constructor Functions

To create a Constructor Function, follow these steps:

  1. Define a function with an uppercase first letter, e.g., `function Person() {}`.
  2. Use `this` keyword within the function to refer to the newly created object.
  3. Optionally, return the newly created object at the end of the function.

Using the `new` Keyword

To instantiate an object using a Constructor Function, use the `new` keyword followed by the function name. This creates a new object and invokes the Constructor Function.

var person = new Person();

Defining Properties and Methods

Inside the Constructor Function, you can define properties and methods for the newly created object:

function Person() { = 'John Doe';
this.greet = function() {
console.log("Hello, my name is " +;

Accessing Properties and Methods

Access properties and methods of the created object using dot notation or bracket notation:; // 'John Doe'
person['greet'](); // Logs "Hello, my name is John Doe"

Inheritance and Prototypal Inheritance

Constructor Functions support inheritance through prototypal inheritance. Child Constructors can inherit properties and methods from Parent Constructors.

function Parent() {}
function Child() {;
// Additional properties and methods for Child

Benefits of Using Constructor Functions

  • Encapsulation: Protect internal state and behavior.
  • Reusability: Share common properties and methods among similar objects.
  • Inheritance: Enable the creation of complex object hierarchies.
  • Flexibility: Allow for dynamic object creation and modification.

Drawbacks of Using Constructor Functions

  • Verbosity: Can be more verbose compared to ES6 classes.
  • Property Enumeration: Properties defined directly on the object are not enumerable by default.
  • Lack of Syntax Sugar: Not as concise as ES6 classes, which include syntactic features.

ES6 Classes vs Constructor Functions

ES6 introduced classes, a more modern and concise way to define and create objects. However, Constructor Functions still have their uses.

Feature Constructor Functions ES6 Classes
Syntax More verbose Concise, using class keyword
Encapsulation Supported, but not enforced Enforced by class syntax
Inheritance Supported through prototypal inheritance Supported using extends keyword
Flexibility More flexible in terms of object creation Less flexible, but more structured

When to Use Constructor Functions vs ES6 Classes

Use Constructor Functions when:

  • You need maximum flexibility in object creation.
  • You have legacy code that relies on Constructor Functions.
  • You prefer prototypal inheritance over class-based inheritance.

Use ES6 Classes when:

  • You want a more concise and modern syntax.
  • You need strong encapsulation.
  • You prefer class-based inheritance.

Examples of Constructor Functions in Practice

// Create a Person object
function Person(name, age) { = name;
this.age = age;
// Create a new Person object
var person = new Person("John Doe", 30);

Constructor Functions in Real-World Applications

  • Creating DOM elements in web development.
  • Defining reusable components in React or Angular.
  • Modeling data structures like linked lists or trees.
  • Building custom objects for specific business logic.

Next Topic: ES6+ Classes vs Prototype

In the next session, we'll dive into ES6+ Classes and compare them with Prototypal Inheritance. We'll explore why it's essential to understand both, along with their strengths and weaknesses. Follow us for more in-depth insights!