Observable (RxJS లైబ్రరీ నుండి) సమయానికి సంబంధించిన విలువల స్ట్రీమ్ను సూచిస్తుంది, దానికి మీరు సబ్స్క్రైబ్ చేయవచ్చు. Angular RxJS ను విస్తృతంగా ఉపయోగిస్తుంది — HTTP అభ్యర్థనలు, రూటర్ ఈవెంట్లు, ఫారమ్లు మరియు EventEmitter అన్నీ Observable-ఆధారితమైనవి — కాబట్టి వాటిని అర్థం చేసుకోవడం ఆవశ్యకమైనది.
Promise: a SINGLE future value, eager, can't cancel
Observable: ZERO-to-MANY values over time, lazy (runs on subscribe), CANCELLABLE
Observables బహుళ విలువలను విడుదల చేయగలవు, సబ్స్క్రైబ్ చేసినప్పుడు మాత్రమే నిర్వహించబడతాయి మరియు అన్సబ్స్క్రైబ్ చేయవచ్చు (రద్దు చేయవచ్చు) — ఇవి ఇভెంట్లు, స్ట్రీమ్లు మరియు HTTP కోసం ఆదర్శవంతమైనవి, వీటిని మీరు రద్దు చేయాలనుకోవచ్చు.
import { HttpClient } from "@angular/common/http";
this.http.get<User[]>("/api/users").subscribe({
next: (users) => this.users = users, // each emitted value
error: (err) => console.error(err), // on error
complete: () => console.log("done"), // stream finished
});
మీరు .subscribe() చేసే వరకు ఏమీ జరగదు — Observable సోమరితనంతో ఉంటుంది.
import { map, filter, debounceTime } from "rxjs/operators";
this.searchInput.valueChanges.pipe(
debounceTime(300), // wait for typing to pause
filter(text => text.length > 2), // ignore short queries
map(text => text.trim()), // transform
).subscribe(query => this.search(query));
ఆపరేటర్లు (.pipe() లోపల చేపట్టిన) ప్రకటనపూర్వకంగా స్ట్రీమ్ను రూపాంతరం చేస్తాయి — debounce, filter, map మొదలైనవి — సాధారణ అసిక్రోనస్ సమస్యలను (వెతుకు-మీరు-టైప్-చేసినట్లుగా) సొగసగా పరిష్కరిస్తాయి.
import { Subscription } from "rxjs";
private sub = new Subscription();
ngOnInit() { this.sub = this.data$.subscribe(...); }
ngOnDestroy() { this.sub.unsubscribe(); } // ❗ prevent leaks
మాన్యువల్ సబ్స్క్రిప్షన్లను ngOnDestroy లో శుభ్రపరచాలి, లేదా కాంపోనెంట్ పోయిన తరువాత కూడా అవి నడుస్తూ ఉంటాయి — మెమరీ లీక్. సాధారణ పరిష్కారాలు: async పైప్ (స్వయంచాలకంగా అన్సబ్స్క్రైబ్ చేస్తుంది) లేదా takeUntilDestroyed().
<!-- ✅ the async pipe handles subscription AND cleanup for you -->
<li *ngFor="let user of users$ | async">{{ user.name }}</li>
RxJS Observables Angular అంతటా నేయబడ్డాయి — HttpClient, రియాక్టివ్ ఫారమ్లు లేదా రూటర్ లేకుండా మీరు వాటిని ఉపయోగించలేరు.
సబ్స్క్రిప్షన్, ఆపరేటర్లు మరియు ముఖ్యంగా అన్సబ్స్క్రిప్షన్ (లేదా async పైప్ ఉపయోగించి మానవ నిర్వహణను నివారించడానికి) అర్థం చేసుకోవడం కీలకమైనది: ఇది అసింక్రోనస్ డేటా కోసం Angular యొక్క శక్తి యొక్క వనరు మరియు దాని అత్యంత సాధారణ ఆపతలలో ఒకటి (మరిచిపోయిన సబ్స్క్రిప్షన్ల నుండి లీక్లు).