Lifecycle Hooks in Mounting Phase in LWC

There are 3 phase of LWC component

1. Mounting
A. constructor, B. connnectedCallback C. render D. renderedCallback

2. UnMounting
A. disconnectedcallback

3. Error
A.errorcallback

Note - render is not lifecycle hook, it is protected method of Lightning element class.

Mounting Phase

In Lightning Web Components (LWC), the lifecycle hooks are methods that allow you to control and perform actions at various stages of a component's lifecycle. There are several lifecycle hooks available, and they can be especially useful when dealing with parent-child component relationships during the mounting phase.

Here's an overview of the lifecycle hooks in the mounting phase for both parent and child components:

Parent Component Lifecycle Hooks (Mounting Phase):

constructor(): This is the first method that runs when a component is created. It's used for initializing variables and setting up initial state.
connectedCallback(): This method is called when the component is inserted into the DOM. It's commonly used for tasks like fetching data from a server or initializing child components.
renderedCallback(): This hook is invoked after the component's template has been rendered. It's often used for DOM manipulation, such as interacting with elements rendered by child components.

constructor(): The constructor() method fires when a component instance is created. Don’t add attributes to the host element during construction. You can add attributes to the host element in any other lifecycle hook.The constructor flows from parent to child.

These requirements from the HTML: Custom elements spec apply to the constructor().

The first statement must be super() with no parameters. This call establishes the correct prototype chain and value for this. Always call super() before touching this.
Don’t use a return statement inside the constructor body, unless it is a simple early-return (return or return this).
Don’t use the document.write() or document.open() methods.
Don’t inspect the element’s attributes and children, because they don’t exist yet.
Don’t inspect the element’s public properties, because they’re set after the component is created.
Don’t Add Attributes to Host Element During Construction
You can add attributes to the host element during any stage of the component lifecycle other than construction.
This example is illegal, because it adds an attribute to the host element in the constructor().
Don’t inspect the element’s public properties, because they’re set after the component is created.
Don’t Add Attributes to Host Element During Construction
Host element can be accessed through "this. template" inside constructor method.

constructor(){
        super(); // This is mandatory
        console.log('parent component constructor called ');
        //var elements = this.template.querySelector('.demo'); // We cant do this coz component 
is not loaded yet. however we can add event listener to whole component
       // console.log('elements..',elements);
    }

constructorExp.html

constructorExp.js

 import { LightningElement } from 'lwc';
export default class ConstructorExp extends LightningElement {
    constructor() {
        super();
        this.classList.add('new-class');
        console.log('In Constructor');
    }
}

connectedCallback()

This hook is called when a component is added to the DOM. It is typically used for performing any DOM manipulations or event listeners that are needed by the component.

This method Called when the element is inserted into a document. In this phase, the hook flow executes from parent to child. You can’t access child elements in the component body because they don’t exist.

Hook that fires when a component instance is created.
You have to call super() in the first line.
At that point, the component properties won’t be ready yet.
It flows from parent to child.
The equivalent in Aura is the init() event. the init() Aura event flows from child to parent

Fires when a component is inserted into the DOM.
The component properties will be ready, but the child elements won’t be yet.
It can fire more than once.
It flows from parent to child.
There is no equivalent to connectedCallback() in Aura components.

connectedCallBack Method

This method called when component is inserted into DOM and It flows from parent to child component.
Can’t access any child component property because it’s not exists yet.
Host element can be accessed through “this. template” inside this method.
Use connectedCallBack to perform initialization task such as fetch data, set up caches,listen to publish-subscribe events or call apex method.
Dont use this method to change the state of component properties loading values or setting properties. Use getters and setters instead.

        
connectedCallback(){
        console.log('parent component connectedCallback called ');
       
 }

renderedCallback Method

This method called when component is rendered and It flows from child to parent component.
It can fired more than once, any changes made to component invokes this method again and again which impact performance
When component re-renders all expression used in the template are reevaluated
Don’t use renderedCallback to change the state or update property of a component
Do not use rerenderedCallback to update wire adapter configuration object property, it will result infinite loop.

renderedCallback(){
        console.log('parent component renderedCallback called ');
       
}

UNMounting Phase

disconnectedCallback Method

This method called when component is removed from DOM
It flows from Parent to child and it is specific Lightning Web component.

disconnectedCallback(){
        console.log('parent component disconnectedCallback called');
    }

Uses

1. disconnectedCallback can be used for performance improvement and memory leakage issue. for example, If event listener or set Interval of window property set, then It will be running behind the scene, we can remove (removeEventlistner or clearInterval) in this method.

Error Phase

disconnectedCallback Method This method called when descended component throw an error. errorCallBack have 2 arrgurment error object and stack argument as String

errorCallback(error,stack){
        console.log('stack',stack);
        console.log('error',error);
        console.log('error message',error.message);
 }

render Method

render method is a protected method of Lighting Element Class.

This method tells the lightning engine which template to load based on some condition, The return type of this method is reference of template. We dont have to keep writing all html code in html file, we can segregate to different html file. By using render method we can load. Importing html file.

       
import secondHTML from './second.html';
import firstHTML from './first.html';

render(){

        return this.htmlFileName === 'secondHTML' ? :firstHTML;
       
    }