How to Mimic extends and super in Prototypes in JavaScript

Learn how to effectively mimic `extends` and `super` using JavaScript prototypes. This guide covers how to properly access parent classes' methods in child classes through prototypes.
---

Visit these links for original content and any more details, such as alternate solutions, latest updates/developments on topic, comments, revision history etc. For example, the original title of the Question was: How to mimic extends and super in prototypes?

If anything seems off to you, please feel free to write me at vlogize [AT] gmail [DOT] com.
---
How to Mimic extends and super in Prototypes in JavaScript

JavaScript offers a variety of ways to create objects and establish an inheritance structure. With the introduction of ES6 classes, many developers found these new features easier to use compared to traditional prototype-based inheritance. However, understanding how to achieve the same effects using functions and prototypes is critical for seasoned developers. In this article, we explore how to "mimic" the class behavior of extends and super within the prototype-based inheritance model of JavaScript.

The Problem

The issue arises when trying to access a method from the parent prototype inside the child constructor. In class syntax, using super() allows us to access parent class methods easily, but this built-in capability isn't directly available when using the traditional prototype chain. Consequently, we need to establish prototype inheritance and ensure that the child class can access its parent's prototype methods.

Example Using Classes

Let's consider an example to clarify how classes make use of extends and super. This highlights how you can easily access methods from the parent class:

[[See Video to Reveal this Text or Code Snippet]]

In this example, the Employee class extends Person, perfectly demonstrating how methods can be accessed from the parent class.

Solution Using Function and Prototypes

To mimic this structure using function expressions, we must manually set up the prototype chain. Here's a step-by-step breakdown of how to achieve this:

Step 1: Define the Parent Constructor and Prototype Method

Start by defining the parent constructor function and its methods as follows:

[[See Video to Reveal this Text or Code Snippet]]

Step 2: Define the Child Constructor

Next, create the child constructor function and use call to inherit properties from the parent:

[[See Video to Reveal this Text or Code Snippet]]

Step 3: Establishing the Prototype Chain

To properly connect the child class to the parent, you will need to set its prototype to be an instance of the parent’s prototype:

[[See Video to Reveal this Text or Code Snippet]]

Step 4: Defining Child Prototype Methods

Finally, add any methods specific to the Employee prototype:

[[See Video to Reveal this Text or Code Snippet]]

Full Example in Action

Putting it all together, we have:

[[See Video to Reveal this Text or Code Snippet]]

Conclusion

By following these steps, you can successfully mimic the behavior of extends and super in JavaScript's prototype-based system. This hands-on approach helps reinforce the idea of prototypal inheritance while allowing you to leverage the flexibility of function expressions in your JavaScript applications.

Understanding the prototype chain is crucial for any developer working with Javascript, especially when you need to manage complex inheritance structures. By mastering these techniques, you will gain more control over your JavaScript code and its underlying architecture.