Call Parent Function Which Is Being Overridden By Child During Constructor Chain In Javascriptes6 Duplicate

In JavaScript ES6, understanding how parent functions overridden by child functions work during the constructor chain is key to ensuring your code functions as expected. Let's delve into this concept and learn how to call a parent function that is being overridden by a child function.

When a child class overrides a method present in its parent class, the original functionality of the parent's method is replaced by the child's method. However, there are scenarios where we might want to invoke the parent's method from within the child's method. This is especially common when you still need the parent's functionality alongside your custom logic.

To achieve this, we can use the `super` keyword. The `super` keyword is used to call corresponding methods of a superclass. In this case, we use it to call the parent's method that has been overridden by the child.

Here is an example to illustrate this concept:

class Parent {
    constructor() {
        console.log('Parent constructor');
    }

    parentMethod() {
        console.log('Parent method');
    }
}

class Child extends Parent {
    constructor() {
        super();
        console.log('Child constructor');
    }

    parentMethod() {
        super.parentMethod(); // Calls the parent's method
        console.log('Child method');
    }
}

const child = new Child();
child.parentMethod();

In the above code snippet, we have a `Parent` class with a `parentMethod` and a `Child` class that extends `Parent`. Inside the `Child` class, by using `super.parentMethod()`, we are calling the parent's `parentMethod` from within the child's `parentMethod`.

When you run this code, the output will be:

Parent constructor
Child constructor
Parent method
Child method

This demonstrates that we were able to call the parent's method even though it was overridden by the child.

It is crucial to remember that the `super` keyword should be used within the constructor if you want to call the parent's constructor and within other methods to call the parent's methods that are being overridden.

By utilizing this technique, you can efficiently manage the constructor chain in JavaScript ES6 and ensure that your code functions smoothly. Remember, understanding the relationship between parent and child classes is fundamental in object-oriented programming.

I hope this article has shed light on how to call parent functions that are being overridden by child functions during the constructor chain in JavaScript ES6. Happy coding!