RxJS中observer.complete()的作用及observer.next()后调用它的具体行为

Awesome questions—let's unpack these one by one, since getting a grip on Observable lifecycle is critical to working effectively with RxJS.

1. What does observer.complete() do? #

At its core, observer.complete() is RxJS's way of signaling to all subscribed observers that the Observable has finished emitting all intended values. It’s a key part of the Observable contract: an Observable can emit 0 to N values via next(), then must terminate either with complete() (a clean, successful finish) or error() (a failure state). Once complete() is called, that Observable is permanently done—no more values will ever be emitted from it.

2. What happens when you call observer.next() followed by observer.complete() in RxJS? #

Let’s break down the step-by-step behavior with a concrete example to make it clear:

First, here’s a sample snippet to illustrate:

import { Observable } from 'rxjs';

const demoObservable = new Observable((observer) => {
  observer.next('First data point');
  observer.next('Second data point');
  observer.complete(); // Trigger completion
  observer.next('Third data point'); // This will NEVER be processed
});

demoObservable.subscribe({
  next: (value) => console.log('Received:', value),
  complete: () => console.log('✅ Observable finished successfully!')
});

When you run this code, here’s exactly what happens:

• The observer.next('First data point') and observer.next('Second data point') calls fire first, pushing those values to the subscriber’s next handler. You’ll see those two "Received:" logs in the console.
• Immediately after the second next(), observer.complete() is invoked. This triggers the subscriber’s complete handler, so you’ll see the "✅ Observable finished successfully!" log.
• The final observer.next('Third data point') is completely ignored—once complete() is called, the Observable enters a terminated state, which locks it from emitting any more values.
• Behind the scenes, RxJS automatically cleans up all active subscriptions to this Observable. This means any resources tied to it (like timers, network requests, or event listeners) are released, preventing memory leaks.
• Any operators in the Observable chain (think map, filter, debounceTime) will also receive the termination signal and stop executing any further logic.

The output of the snippet above will be:

Received: First data point
Received: Second data point
✅ Observable finished successfully!

内容的提问来源于stack exchange，提问作者Karan Hudia