紀錄工作經驗、相關知識,解決技術相關問題。

Javascript

RxJS Observable vs Promise 差異:非同步資料流與單次請求的抉擇

RxJS Observable vs Promise 差異:非同步資料流與單次請求的抉擇 特色圖片

RxJS Observable vs Promise 的差異,簡單說就是「一次結果」與「持續資料流」:Promise 代表一個非同步作業最終的單一結果,Observable 則是能在一段時間內發送多個值的資料流。

兩者都能處理非同步運算,但在執行時機、能否取消與可串接的操作上設計不同。本文用語法對照、本機執行輸出與常見問題,協助你判斷該用哪一個。

若需要複習基礎的網路傳輸規範,可先參考 淺談 HTTP 請求方法 (HTTP Request Methods):GET、POST、PUT、DELETE 基礎概念與 Fetch 入門。

一、 核心語法速查與規格對照

RxJS 官方文件把 Observable 定義為「multiple values 的 lazy Push collection」,並說明 Promise 是「可能(也可能不會)最終回傳單一值的計算」。以下為兩者在基本建立與訂閱行為上的程式碼範例:

// Promise 範例:單次非同步請求
const fetchUserData = () => {
  return new Promise((resolve, reject) => {
    setTimeout(() => {
      resolve({ id: 1, name: "Sean" });
    }, 1000);
  });
};

fetchUserData().then(data => console.log(data));

// RxJS Observable 範例:多值資料流
import { Observable } from 'rxjs';

const dataStream$ = new Observable(subscriber => {
  subscriber.next('資料載入中...');
  setTimeout(() => {
    subscriber.next({ id: 1, name: "Sean" });
    subscriber.complete();
  }, 1000);
});

const subscription = dataStream$.subscribe({
  next: value => console.log(value),
  complete: () => console.log('串流結束')
});

上面兩段程式碼用 Node.js v22 與 RxJS 7.8.2 執行時,可以看到兩者的執行時機不同:Promise 的 executor 在建立時就同步執行,Observable 的 subscribe 函式要等到 subscribe() 被呼叫才會執行。

Node.js v22、RxJS 7.8.2 執行 Promise 與 Observable 範例的終端輸出,Promise executor 在 then 之前已執行,Observable 的 subscribe 函式在訂閱時才執行

下表整理了 RxJS Observable 與 Promise 在核心維度上的規格對照,協助團隊評估架構設計:

比較維度PromiseRxJS Observable
資料回傳次數單次(Single Value),只會 fulfilled 或 rejected 其中一種結果。多次(Multiple Values),可在生命週期內持續發送資料。
執行時機Eager(MDN 描述 Promise 代表「已經在進行中」的處理程序,建立時 executor 即執行)。Lazy(需等到被 subscribe 訂閱時才會開始執行)。
取消機制Promise 本身沒有一級(first-class)的取消協定,可改為取消底層作業,例如搭配 AbortController。內建支援(呼叫 unsubscribe() 取消執行)。
發送方式以 then 等處理器接收結果。官方文件指出可同步或非同步發送值。
操作子支援提供 .then()、.catch() 與 Promise.all() 等靜態組合方法。豐富的 operators 轉換(如 map、filter、debounceTime 等)。

二、 關鍵機制與跨情境細部拆解

1. 單次回傳與不可取消特性的取捨

櫃台上放著一個封好的單一包裹,代表 Promise 只交付一次結果,交出後便不會再有第二個值。
圖:Promise 像一次性交付的單一包裹

Promise 適合代表單次的非同步作業(如 AJAX 請求或檔案讀取)。MDN 指出 Promise 本身沒有一級的取消協定,若要取消,得直接取消底層的非同步作業,通常是搭配 AbortController。

因此,Promise 建立後,即使呼叫端的元件已經被銷毀,沒有另外中斷底層作業時,它仍會照常執行到結束。處理高頻率觸發的事件(如搜尋框自動補全)時,舊請求的結果可能晚於新請求回來,造成畫面顯示過時資料。

2. 多值串流與 operators 轉換的優勢

傳送帶載著一排包裹依序通過多道隔板,代表 Observable 持續發送多個值並由 operators 逐步過濾與轉換。
圖:Observable 像持續運轉的傳送帶與分揀閘門

相較之下,RxJS 將時間軸上的事件視為可被觀察的資料流,並提供 operators 對資料流進行過濾、合併與延遲處理。例如處理使用者輸入時,可以結合 debounceTime 與 distinctUntilChanged,減少不必要的 API 請求次數。

3. 取消請求:AbortController 與 unsubscribe 的實際行為

下面的腳本在本機起一個延遲 500 毫秒才回應的測試伺服器,分別觀察三件事:fetch 搭配 AbortController、RxJS 的 fromFetch 搭配 unsubscribe(),以及搜尋事件流搭配 switchMap。

import { fromFetch } from 'rxjs/fetch';
import { Subject, switchMap, map, debounceTime, distinctUntilChanged } from 'rxjs';

// 1. Promise 版:用 AbortController 中止 fetch
const ac = new AbortController();
fetch(`${base}/?q=abortController`, { signal: ac.signal })
  .then((r) => r.json())
  .catch((e) => console.log(e.name)); // AbortError
ac.abort();

// 2. Observable 版:unsubscribe 即中止
const sub = fromFetch(`${base}/?q=unsubscribe`).subscribe({
  next: () => console.log('收到回應'),
});
sub.unsubscribe();

// 3. 搜尋事件流:新輸入進來時,switchMap 取消前一次尚未完成的請求
const input$ = new Subject();
input$
  .pipe(
    debounceTime(50),
    distinctUntilChanged(),
    switchMap((q) => fromFetch(`${base}/?q=${q}`).pipe(switchMap((r) => r.json()))),
    map((j) => j.q)
  )
  .subscribe((q) => console.log('畫面更新:', q));

fromFetch 的原始碼註解說明,它在訂閱終止時會透過內部的 AbortController 中止底層的 fetch;因此兩種寫法最後都是靠 AbortController 中斷連線,差別在於 RxJS 把中斷動作包進了 unsubscribe()。

Node.js v22、RxJS 7.8.2 的終端輸出:fetch 搭配 AbortController 與 fromFetch 呼叫 unsubscribe 後,伺服器皆顯示連線被客戶端中斷;搜尋事件流中前一次請求被 switchMap 取消,畫面只更新最後一次的結果

三、 常見問題與排錯(Q&A)

1. 為什麼 Promise 實例建立後無法中途主動取消?在進行 HTTP 請求時會造成什麼資源浪費?

  • 問題原因:MDN 說明 Promise 本身沒有一級的取消協定,它代表的是已經在進行中的處理程序。Promise 建立後,底層的非同步任務(例如大型資料傳輸)仍會持續,即便前端已經不需要該結果,也不會自動停止。
  • 解法:搭配原生 Fetch API 與 AbortController,把 signal 傳給 fetch(),需要時呼叫 abort() 中止請求(MDN 指出 abort() 能中止 fetch 請求);若專案已導入 RxJS,則可改用 Observable 並透過 unsubscribe() 取消執行,作法見上方第二節第 3 點。

2. RxJS Observable 的 unsubscribe 機制是如何運作的?與 AbortController 處理 Promise 的差異為何?

  • 問題原因:開發者常混淆兩者的中斷手段。
  • 解法:RxJS 官方文件說明,只要呼叫 unsubscribe() 就能取消 Observable 的執行,而每個 Observable 要在建立時自行定義如何釋放該次執行的資源(例如清除計時器)。AbortController 則是 Web API:它透過 AbortSignal 與非同步作業溝通,abort() 可中止 fetch 請求。兩者的封裝層級不同:unsubscribe() 是訂閱端的退訂動作,AbortController 是針對支援 signal 的底層作業發出中止訊號,RxJS 的 fromFetch 就是把後者包在前者裡面。

3. Cold Observable 與 Hot Observable 在資料發送時機上有何本質上的不同?

  • 問題原因:不清楚資料流的廣播特性導致重複發送請求。
  • 解法:RxJS 官方術語表(Glossary)對兩者的定義如下:RxJS 文件也說明,一般的 Observable 是 unicast(每個訂閱的 Observer 各自擁有獨立的執行),而 Subject 是 multicast。Node.js v22、RxJS 7.8.2 的終端輸出:兩個訂閱者訂閱同一個 cold Observable 時各建立一個生產者;Subject 的後訂閱者收不到訂閱前的值
    • Cold Observable:在每次 subscribe 時都建立新的生產者(producer)。Angular HttpClient 的請求 Observable 就是例子,官方文件指出對同一個 Observable 多次訂閱會觸發多次後端請求。
    • Hot Observable:生產者是在 subscribe 動作之外建立的,多個訂閱者共享同一個資料來源。Subject 是最常見的例子,後加入的訂閱者收不到加入之前已發送的值(見下圖輸出)。

4. 當專案中需要處理連續且頻繁的事件流(如搜尋框 Input 監聽與自動補全),為何 Promise 無法勝任?

  • 問題原因:Promise 只能處理單次回傳,無法將「一連串隨著時間發生的事件」封裝為單一物件進行連續加工。
  • 解法:改用 Observable 接收輸入事件流,並串接 switchMap 運算子,自動取消前一次尚未完成且過時的 API 請求,確保畫面資料的一致性。

5. 如何將現有的 Promise 轉換為 Observable?何時適合使用 from 或是 bindCallback 運算子?

  • 問題原因:在漸進式導入 RxJS 的專案中,常需將既有的 Promise 函式納入資料流管線。
  • 解法:RxJS 的 from() 可將 Array、Promise、iterable 等輸入建立成 Observable,例如 from(fetchData())。from() 只是把 Promise 的結果包成 Observable,不會讓 Promise 變得可取消:Promise 在建立時已經開始執行,要中止底層請求仍需 AbortController。回呼函式則用 bindCallback,它把回呼 API 轉成回傳 Observable 的函式。若是 Node.js 風格、第一個參數為錯誤的回呼,官方文件說明 bindCallback 會把它和其他回呼一視同仁,錯誤會被當成一般的值;這類函式應使用有錯誤處理的 bindNodeCallback。

6. 在 Angular 或 React 架構中,非同步資料流未妥善取消訂閱會引發哪些記憶體流失(Memory Leak)問題?

  • 問題原因:元件銷毀後,訂閱若仍在背景執行,訂閱端持有的參考可能讓元件實例無法被垃圾回收(Garbage Collection)。
  • 解法:Angular 官方文件指出,async pipe 在元件銷毀時會自動退訂。React 則在 useEffect 的 setup 函式中回傳清理函式,React 會在元件從 DOM 移除後執行它。三種清理策略的完整比較、takeUntil 與 takeUntilDestroyed 的範例,請參考延伸文章 RxJS memory leak unsubscribe takeUntil 記憶體流失排查與生命週期管理實務,本文不重複說明。

7. 面對單一 API 請求時,全面採用 RxJS Observable 是否會增加不必要的程式碼複雜度?

  • 問題原因:過度設計(Over-engineering)導致團隊維護成本上升。
  • 解法:若只是單純的「發送請求 ➔ 接收單次回應 ➔ 渲染畫面」,使用 Promise 或 async/await 更加直觀且輕量。只有在需要處理複雜的事件組合、取消機制、輪詢(Polling)或多重資料流合併時,才建議引入 RxJS Observable。

8. 需要 Promise 的 API 時,如何把 Observable 轉回 Promise?

  • 問題原因:部分函式庫或 async/await 流程只接受 Promise,而手上的資料來源是 Observable。
  • 解法:使用 firstValueFrom():它訂閱 Observable,在第一個值到達時兌現 Promise,隨後關閉訂閱。若 Observable 在發出任何值之前就結束,Promise 會以 EmptyError 拒絕(除非指定預設值)。官方警告只能搭配確定會發出值或會結束的 Observable 使用,否則 Promise 可能永遠不會結束。
import { firstValueFrom, EMPTY, interval, take } from 'rxjs';

const first = await firstValueFrom(interval(20).pipe(take(3)));
console.log(first); // 0

try {
  await firstValueFrom(EMPTY);
} catch (e) {
  console.log(e.name); // EmptyError
}

參考資料與延伸閱讀

發佈留言