Unsubscribing and memory leaks in Angular - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ component_behavior

intermediate

What happens if you don't unsubscribe from an Observable in Angular?

Consider an Angular component that subscribes to an Observable but never unsubscribes. What is the most likely outcome?

Angular

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

@Component({
  selector: 'app-timer',
  template: `<p>Timer running</p>`
})
export class TimerComponent implements OnInit {
  ngOnInit() {
    interval(1000).subscribe(val => console.log(val));
  }
}

A The Observable will keep emitting values even after the component is destroyed, causing a memory leak.

B The Observable automatically stops emitting when the component is destroyed, so no memory leak occurs.

C Angular automatically unsubscribes from all Observables when the component is destroyed.

D The Observable will throw an error if not unsubscribed before component destruction.

💡 Hint

Think about what happens to subscriptions when components are removed from the DOM.

If you don't unsubscribe from an Observable, it keeps running in the background even if the component is gone. This causes memory leaks because resources are not freed.

📝 Syntax

intermediate

Which code snippet correctly unsubscribes from an Observable in Angular using ngOnDestroy?

Choose the code that properly unsubscribes from a subscription when the component is destroyed.

Angular

import { Component, OnInit, OnDestroy } from '@angular/core';
import { Subscription, interval } from 'rxjs';

@Component({
  selector: 'app-example',
  template: `<p>Example</p>`
})
export class ExampleComponent implements OnInit, OnDestroy {
  private sub?: Subscription;

  ngOnInit() {
    this.sub = interval(1000).subscribe();
  }

  ngOnDestroy() {
    // Unsubscribe here
  }
}

A ngOnDestroy() { this.sub.stop(); }

B ngOnDestroy() { this.sub = null; }

C ngOnDestroy() { this.sub.unsubscribe(); }

D ngOnDestroy() { this.sub.complete(); }

💡 Hint

Look for the method that stops the subscription safely.

The unsubscribe() method stops the subscription and frees resources. Setting to null or calling non-existent methods won't unsubscribe.

🔧 Debug

advanced

Why does this Angular component cause a memory leak?

Examine the code below. Why does it cause a memory leak?

Angular

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

@Component({
  selector: 'app-leaky',
  template: `<p>Leaky Component</p>`
})
export class LeakyComponent implements OnInit {
  ngOnInit() {
    interval(1000).subscribe(val => console.log(val));
  }
}

A Because the subscription is not stored and cannot be unsubscribed later.

B Because interval() emits only once and then completes.

C Because console.log causes the memory leak.

D Because ngOnInit is not called when the component is created.

💡 Hint

Think about how to stop an Observable subscription.

The subscription is anonymous and not saved to a variable, so it cannot be unsubscribed. This causes the Observable to keep running indefinitely.

🧠 Conceptual

advanced

What is the best practice to avoid memory leaks with multiple subscriptions in Angular?

You have multiple subscriptions in a component. Which approach best avoids memory leaks?

A Call unsubscribe on each subscription separately in ngOnDestroy without grouping.

B Store all subscriptions in a Subscription object and unsubscribe once in ngOnDestroy.

C Rely on Angular to automatically unsubscribe all subscriptions on component destroy.

D Use setTimeout to delay unsubscription until after component destruction.

💡 Hint

Think about managing multiple subscriptions efficiently.

Grouping subscriptions in a Subscription object and unsubscribing once is efficient and reduces errors. Angular does not auto-unsubscribe.

❓ state_output

expert

What is the console output after destroying this Angular component?

Consider this Angular component. What will be logged to the console after the component is destroyed?

Angular

import { Component, OnInit, OnDestroy } from '@angular/core';
import { interval, Subscription } from 'rxjs';

@Component({
  selector: 'app-test',
  template: `<p>Test Component</p>`
})
export class TestComponent implements OnInit, OnDestroy {
  private sub: Subscription = new Subscription();

  ngOnInit() {
    const sub1 = interval(500).subscribe(val => console.log('A', val));
    const sub2 = interval(700).subscribe(val => console.log('B', val));
    this.sub.add(sub1);
    this.sub.add(sub2);
  }

  ngOnDestroy() {
    this.sub.unsubscribe();
  }
}

A Only 'B' logs stop; 'A' logs continue after destruction.

B Logs 'A' and 'B' continue indefinitely after destruction.

C Only 'A' logs stop; 'B' logs continue after destruction.

D No logs appear after component destruction; all intervals stop.

💡 Hint

Consider what happens when you unsubscribe a Subscription that contains multiple subscriptions.

Unsubscribing the parent Subscription stops all child subscriptions, so no logs appear after destruction.