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:
ngOnChangesngOnInitngDoCheckngAfterContentInitngAfterContentCheckedngAfterViewInitngAfterViewCheckedngOnDestroy
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.
In our next article, we’ll dive deeper into how these hooks work together in a real-world Angular application, showing examples of more complex lifecycles and interactions.
SOCIAL SHARE CARD GENERATOR