Observable vs Promise mental model in Angular - Performance Comparison

Performance: Observable vs Promise mental model

MEDIUM IMPACT

This concept affects how asynchronous data is handled, impacting interaction responsiveness and rendering updates in Angular apps.

Handling multiple asynchronous data updates in Angular

Angular

fetchData(): Observable<Data> {
  return this.http.get<Data>(url);
}

ngOnInit() {
  this.fetchData().subscribe(data => {
    this.data = data;
    // UI updates reactively on each emission
  });
}

Observables allow multiple emissions and lazy evaluation, enabling smoother UI updates and better interaction responsiveness.

📈 Performance GainNon-blocking updates; incremental rendering; improved INP by reacting to data streams.

Handling multiple asynchronous data updates in Angular

Angular

fetchData(): Promise<Data> {
  return this.http.get<Data>(url).toPromise();
}

ngOnInit() {
  this.fetchData().then(data => {
    this.data = data;
    // No further updates possible
  });
}

Promises resolve once and cannot handle multiple or streaming updates, causing UI to miss later data changes.

📉 Performance CostBlocks UI update until Promise resolves; no incremental rendering; can cause delayed INP.

Performance Comparison

Pattern	DOM Operations	Reflows	Paint Cost	Verdict
Promise (single resolution)	Single DOM update	1 reflow	1 paint	[OK] Good for single async data
Observable (multiple emissions)	Multiple DOM updates	Multiple reflows	Multiple paints	[!] OK if managed
Observable without throttling	Many DOM updates	Many reflows	High paint cost	[X] Bad if unthrottled

Rendering Pipeline

Promises trigger a single update after resolution, causing one render pass. Observables can emit multiple values, triggering multiple render passes but allowing incremental UI updates.

→JavaScript Execution

→Style Calculation

→Layout

→Paint

⚠️ BottleneckMultiple Observable emissions can cause repeated Layout and Paint operations if not managed carefully.

Core Web Vital Affected

INP

This concept affects how asynchronous data is handled, impacting interaction responsiveness and rendering updates in Angular apps.

Optimization Tips

1Use Observables for multiple or streaming async data to keep UI responsive.

2Throttle or debounce Observable emissions to reduce layout thrashing.

3Use Promises for simple, single async operations to keep code simple.

Performance Quiz - 3 Questions

Which async pattern allows multiple UI updates over time in Angular?

A Observable

B Promise

C Callback

D Synchronous function

DevTools: Performance

How to check: Record a session while triggering async data updates; look for multiple Layout and Paint events after Observable emissions.

What to look for: Frequent Layout and Paint spikes indicate multiple reflows; check if debouncing or throttling reduces these.

Practice

1. Which statement best describes the difference between an Observable and a Promise in Angular?

easy

A. Observable is synchronous; Promise is asynchronous.

B. Promise handles a single future value; Observable can handle multiple values over time.

C. Promise can be cancelled; Observable cannot be cancelled.

D. Observable handles a single future value; Promise can handle multiple values over time.

Solution

1. Step 1: Understand the nature of Promise

   A Promise represents a single future value or error that will be resolved once.

2. Step 2: Understand the nature of Observable

   An Observable can emit multiple values over time and can be stopped or cancelled.

3. Final Answer:

   Promise handles a single future value; Observable can handle multiple values over time. -> Option B

4. Quick Check:

   Promise = single value, Observable = multiple values [OK]

Hint: Promise = one value, Observable = many values over time [OK]

Common Mistakes:

• Thinking Promise can emit multiple values
• Believing Observable cannot be cancelled
• Confusing synchronous and asynchronous behavior

2. Which of the following is the correct way to create a Promise that resolves with the value 42 in Angular?

easy

A. const p = new Promise((resolve, reject) => reject(42));

B. const p = new Promise(resolve => reject(42));

C. const p = new Promise((resolve, reject) => resolve(42));

D. const p = new Promise(() => 42);

Solution

1. Step 1: Check Promise constructor syntax

   The Promise constructor takes a function with two parameters: resolve and reject.

2. Step 2: Verify correct usage to resolve with 42

   Calling resolve(42) inside the function correctly resolves the Promise with 42.

3. Final Answer:

   const p = new Promise((resolve, reject) => resolve(42)); -> Option C

4. Quick Check:

   Promise constructor needs resolve and reject parameters [OK]

Hint: Promise constructor needs (resolve, reject) parameters [OK]

Common Mistakes:

• Omitting reject parameter in Promise constructor
• Calling reject instead of resolve to return value
• Returning value directly without resolve

3. Consider this Angular code snippet:

const obs = new Observable(subscriber => {
  subscriber.next(1);
  subscriber.next(2);
  subscriber.complete();
});

obs.subscribe(value => console.log(value));

What will be printed to the console?

medium

A. 1 2

B. 1

C. 2

D. No output

Solution

1. Step 1: Analyze Observable emissions

   The Observable emits two values: 1 and 2, then completes.

2. Step 2: Understand subscription behavior

   The subscriber logs each emitted value, so both 1 and 2 are printed.

3. Final Answer:

   1 2 -> Option A

4. Quick Check:

   Observable emits multiple values, all logged [OK]

Hint: Observable emits all next() values until complete [OK]

Common Mistakes:

• Assuming only first value is logged
• Thinking complete() emits a value
• Confusing Observable with Promise single value

4. What is wrong with this Promise usage in Angular?

const p = new Promise((resolve, reject) => {
  setTimeout(() => resolve('done'), 1000);
});
p.then(result => console.log(result));
p.catch(error => console.error(error));
p.cancel();

medium

A. Promises do not have a cancel() method, so calling it causes an error.

B. The Promise should use reject() instead of resolve() inside setTimeout.

C. The then() method should come after catch(), not before.

D. The Promise constructor is missing the reject parameter.

Solution

1. Step 1: Check Promise API for cancellation

   Promises do not support cancellation; there is no cancel() method.

2. Step 2: Identify error cause

   Calling p.cancel() will cause a runtime error because cancel() is undefined.

3. Final Answer:

   Promises do not have a cancel() method, so calling it causes an error. -> Option A

4. Quick Check:

   Promise cancellation is not supported [OK]

Hint: Promises cannot be cancelled; no cancel() method exists [OK]

Common Mistakes:

• Thinking Promise supports cancel() like Observable
• Confusing resolve and reject usage
• Believing then() must come after catch()

5. You want to fetch user data that updates every 5 seconds and be able to stop the updates when the user navigates away. Which approach fits best in Angular?

hard

A. Use an Observable but do not unsubscribe; it stops automatically.

B. Use a Promise that resolves with user data every 5 seconds.

C. Use a Promise and call cancel() to stop fetching data.

D. Use an Observable that emits new user data every 5 seconds and unsubscribe on navigation.

Solution

1. Step 1: Identify need for multiple values over time

   Fetching user data every 5 seconds means multiple values over time, which suits an Observable.

2. Step 2: Understand cancellation requirement

   Observables can be unsubscribed to stop receiving updates, fitting the need to stop on navigation.

3. Final Answer:

   Use an Observable that emits new user data every 5 seconds and unsubscribe on navigation. -> Option D

4. Quick Check:

   Multiple updates + cancel = Observable with unsubscribe [OK]

Hint: Multiple updates + cancel = Observable with unsubscribe [OK]

Common Mistakes:

• Using Promise for multiple repeated values
• Assuming Promise supports cancel()
• Not unsubscribing Observable causing memory leaks