SF Learners Hub


Understanding Decorators and Lifecycle Hooks in Lightning Web Components (LWC)

Share This Post


Lightning Web Components (LWC) have revolutionized the way we build user interfaces in Salesforce. They offer a powerful way to create interactive and responsive web applications on the Salesforce platform. In this blog post, we'll dive into two essential aspects of LWC development: decorators and lifecycle hooks.

Demystifying Decorators

Decorators in LWC are a set of JavaScript annotations that provide metadata to your components. They influence how your components interact with the DOM, handle data, and communicate with the Salesforce platform. Let's briefly explore some of the most commonly used decorators:

  • @api:
    • This decorator marks a property or method as public, allowing it to be accessible from parent components.
    • Exposes properties and methods for use in parent components, facilitating communication between components.
<c-child-component message="Hello from parent"></c-child-component>
import { LightningElement, api } from 'lwc';

export default class ChildComponent extends LightningElement {
    @api message;

    handleClick() {
  • @track:
    • Used to create reactive properties that automatically trigger component re-renders when their values change.
    • Marks a property as reactive, meaning the component will re-render when the property changes.
import { LightningElement, track } from 'lwc';

export default class ComputedPropertyExample extends LightningElement {
    @track firstName = 'John';
    @track lastName = 'Doe';

    get fullName() {
        return `${this.firstName} ${this.lastName}`;
  • @wire:
    • Enables the easy retrieval of data from Salesforce, allowing you to declaratively wire up your component to receive data from a data source.
    • Connect your component to data from Salesforce. It's a powerful way to fetch and handle data without manual HTTP requests.
import { LightningElement, wire } from 'lwc';
import getOpportunities from '@salesforce/apex/OpportunityController.getOpportunities';

export default class WireExample extends LightningElement {
    @wire(getOpportunities) opportunities;

Delving into Lifecycle Hooks:

Lifecycle hooks are an integral part of LWC components. They allow you to execute code at specific stages in a component's lifecycle, such as when it's created, inserted into the DOM, updated, or removed. Understanding these hooks is crucial for managing component behavior. Let's take a detailed look at some key lifecycle hooks:

  • constructor(): This is the component's constructor, where you can initialize properties and resources.
import { LightningElement } from 'lwc';

export default class ConstructorExample extends LightningElement {
    constructor() {
        super(); // Always call super() first
        this.message = 'Hello from constructor';
  • connectedCallback(): Executes when the component is added to the DOM. It's often used for initial setup or fetching data.
import { LightningElement } from 'lwc';

export default class ConnectedCallbackExample extends LightningElement {
    connectedCallback() {
        // Perform actions when the component is added to the DOM
        console.log('Component is connected to the DOM');
  • renderedCallback(): Called after the component has been rendered or re-rendered. Use this hook for any post-render actions.
import { LightningElement } from 'lwc';

export default class RenderedCallbackExample extends LightningElement {
    renderedCallback() {
        // Perform post-render actions or interact with the DOM
        console.log('Component has been rendered');
  • disconnectedCallback(): Invoked when the component is removed from the DOM. Clean up resources or perform cleanup tasks here.
import { LightningElement } from 'lwc';

export default class DisconnectedCallbackExample extends LightningElement {
    disconnectedCallback() {
        // Perform cleanup actions when the component is removed from the DOM
        console.log('Component is disconnected from the DOM');
  • errorCallback(): Handles errors that occur during rendering, allowing you to gracefully manage errors and provide feedback to users.
import { LightningElement } from 'lwc';

export default class ErrorCallbackExample extends LightningElement {
    errorCallback(error, stack) {
        // Handle errors gracefully
        console.error('An error occurred:', error);
        console.error('Stack trace:', stack);


Decorators and lifecycle hooks are fundamental concepts in Lightning Web Components that empower developers to create efficient, reactive, and responsive components. Understanding how to use decorators and when to leverage lifecycle hooks can significantly enhance your LWC development skills. Harness the power of these features to create interactive and performant Salesforce applications.

I hope you like this blog and if you want any help let me know in the comment section.

Stay tuned, there is way more to come! Follow me on LinkedInInstagram, and Twitter. So you won’t miss out on all future articles.

Leave a Reply

Your email address will not be published. Required fields are marked *

Subscribe To Our Newsletter

Get updates and learn from the best

More To Explore

The Power of Salesforce Integration

What You’ll Learn What Is Salesforce Integration? Salesforce integration involves combining the data and features of Salesforce with another application, creating a cohesive experience for