Before diving into lifecycle hooks, it's essential to have a foundational understanding of a few core topics. According to the Angular documentation:

Prerequisites

Before working with lifecycle hooks, you should have a basic understanding of the following:

• TypeScript programming
• Angular app-design fundamentals, as described in Angular Concepts

Once you're comfortable with these prerequisites, you're ready to explore the powerful lifecycle hooks Angular provides.

Angular component lifecycles are the core of how Angular components are created, updated, and destroyed. Understanding these lifecycles allows developers to control the behavior of components throughout their lifespan, enhancing both functionality and user experience. In this article, we’ll break down the Angular component lifecycle hooks, providing examples and explaining their typical use cases.

What are Lifecycle Hooks in Angular?

Angular provides several lifecycle hooks that developers can leverage to execute specific code at different stages of a component’s lifecycle. From initializing the component to destroying it, these hooks help manage the component’s state, behavior, and resource cleanup.

Here’s a list of all lifecycle hooks in Angular:

1. ngOnChanges
2. ngOnInit
3. ngDoCheck
4. ngAfterContentInit
5. ngAfterContentChecked
6. ngAfterViewInit
7. ngAfterViewChecked
8. ngOnDestroy

Each hook has a specific purpose and is called at a specific time during the component's lifecycle. Let’s dive into each one.

1. ngOnChanges

Purpose: Called when an input property changes.

This is the first lifecycle hook to be called after the component is constructed. The ngOnChanges method is triggered every time an input property’s value changes. It’s particularly useful when you want to execute code in response to changes in component-bound input properties.

Example:

import { Component, Input, OnChanges, SimpleChanges } from '@angular/core';

@Component({
  selector: 'app-sample',
  template: `<p>{{ data }}</p>`
})
export class SampleComponent implements OnChanges {
  @Input() data: string;

  ngOnChanges(changes: SimpleChanges): void {
    console.log('Data changed:', changes.data.currentValue);
  }
}

2. ngOnInit

Purpose: Called once, after the component’s first ngOnChanges.

The ngOnInit hook is where most of the initialization code goes. It’s a great place to initialize properties, set up any required subscriptions, or make HTTP calls that the component depends on.

Example:

import { Component, OnInit } from '@angular/core';

@Component({
  selector: 'app-sample',
  template: `<p>{{ info }}</p>`
})
export class SampleComponent implements OnInit {
  info: string;

  ngOnInit(): void {
    this.info = 'Component initialized!';
  }
}

3. ngDoCheck

Purpose: Called during every change detection run.

The ngDoCheck hook allows you to implement your own change detection algorithm. This can be useful for tracking deep changes in objects that Angular doesn’t natively detect. However, use it cautiously as it can affect performance if not used properly.

Example:

import { Component, DoCheck } from '@angular/core';

@Component({
  selector: 'app-sample',
  template: `<p>{{ count }}</p>`
})
export class SampleComponent implements DoCheck {
  count: number = 0;

  ngDoCheck(): void {
    console.log('Change detection running');
    this.count++;
  }
}

4. ngAfterContentInit

Purpose: Called once, after the first ngDoCheck.

This hook is invoked after Angular has projected external content into the component. It's especially useful in components that use to include external content in their template.

Example:

import { Component, AfterContentInit } from '@angular/core';

@Component({
  selector: 'app-sample',
  template: `<ng-content></ng-content>`
})
export class SampleComponent implements AfterContentInit {
  ngAfterContentInit(): void {
    console.log('Content projected');
  }
}

5. ngAfterContentChecked

Purpose: Called after every check of projected content.

The ngAfterContentChecked lifecycle hook is executed every time Angular checks the content projected into the component. It’s similar to ngAfterContentInit but runs after each change detection cycle.

Example:

import { Component, AfterContentChecked } from '@angular/core';

@Component({
  selector: 'app-sample',
  template: `<ng-content></ng-content>`
})
export class SampleComponent implements AfterContentChecked {
  ngAfterContentChecked(): void {
    console.log('Projected content checked');
  }
}

6. ngAfterViewInit

Purpose: Called once, after the first ngAfterContentChecked.

This lifecycle hook is used to perform actions after the component’s view (and any child views) have been initialized. It’s commonly used to manipulate or read properties of the view’s children after Angular has rendered them.

Example:

import { Component, AfterViewInit, ViewChild, ElementRef } from '@angular/core';

@Component({
  selector: 'app-sample',
  template: `<p #textElement>Hello, world!</p>`
})
export class SampleComponent implements AfterViewInit {
  @ViewChild('textElement') textElement: ElementRef;

  ngAfterViewInit(): void {
    console.log('View initialized:', this.textElement.nativeElement.textContent);
  }
}

7. ngAfterViewChecked

Purpose: Called after every check of the component’s view.

This hook is called after Angular checks the component’s view for updates. It’s similar to ngAfterViewInit but runs after every change detection cycle. This can be used to apply logic that depends on updates in the view.

Example:

import { Component, AfterViewChecked } from '@angular/core';

@Component({
  selector: 'app-sample',
  template: `<p>Hello, Angular!</p>`
})
export class SampleComponent implements AfterViewChecked {
  ngAfterViewChecked(): void {
    console.log('View checked');
  }
}

8. ngOnDestroy

Purpose: Called just before Angular destroys the component.

The ngOnDestroy hook is the place to perform cleanup tasks, such as unsubscribing from observables, detaching event handlers, or releasing resources that might otherwise cause memory leaks.

Example:

import { Component, OnDestroy } from '@angular/core';

@Component({
  selector: 'app-sample',
  template: `<p>Component loaded</p>`
})
export class SampleComponent implements OnDestroy {
  ngOnDestroy(): void {
    console.log('Component is about to be destroyed');
  }
}

Conclusion

Understanding and using these lifecycle hooks effectively can give you fine-grained control over your Angular applications. From initializing data in ngOnInit to cleaning up resources in ngOnDestroy, lifecycle hooks provide the essential control needed for dynamic applications.