
畫面畫完之後,才適合去讀檔、訂閱或對外部系統做一次性的動作,這就是 effect 的工作。這一篇先看 useEffect 什麼時候執行、怎麼用依賴陣列控制重跑、用清除函式收尾,再用它完成載入中、失敗與沒有資料三種畫面的資料讀取模式。接著處理多個元件要共用資料的情況:把狀態提升到父層,兄弟元件透過 props 互相溝通。選讀的部分包含用 API 模組做遠端寫入、避免不必要的 effect、自訂 Hook、Context、React Compiler 與手動記憶化(useMemo、memo、useCallback)、useRef、useReducer,以及表單 Actions(useActionState、useOptimistic)。最後的專案會改用路由的 loader 讀取資料(第 11 篇)。
Effect 與資料
元件在渲染時只負責算出畫面,和畫面以外的世界打交道,例如計時器、讀取資料、改瀏覽器分頁標題,要交給 effect。這一章先學 effect 的執行時機、依賴陣列與清除函式,再用它完成最基本的資料讀取:載入中、失敗與沒有資料三種畫面。選讀的部分是取消請求,以及用 JSONPlaceholder 練習新增、更新與刪除。
useEffect 的執行時機
effect 是畫面更新之後才執行的函式,用來讓元件和外部系統(React 管不到的東西,例如計時器、網路、瀏覽器 API)保持一致。這一節先分清楚 effect、渲染與事件處理各負責什麼,再看 effect 何時執行、怎麼清除,以及寫錯時會出什麼問題。
觀念
React 官方把 effect 定位成「與外部系統同步」的出口,不是「某個值變了就做某件事」的通用工具。一件事該放哪裡,先問它是什麼性質:
- 渲染:從 props 與 state 算出這一輪的畫面。總價、過濾後的清單這類算得出來的值,直接在渲染裡用運算式算,不必放進 state 或 effect。
- 事件處理函式:使用者按一次才要發生的事,例如送出表單、按下才讀一筆資料。
- effect:畫面出現或某些值改變之後,需要和外部系統對齊的事。
graph LR
renderNode["渲染:算出元素"] --> commitNode["提交:畫上畫面"]
commitNode --> effectNode["執行 setup"]
effectNode --> cleanupNode["下次或卸載時清除"]
style renderNode fill:#e3f2fd
style commitNode fill:#e3f2fd
style effectNode fill:#fff3e0
style cleanupNode fill:#e8f5e9
寫法是呼叫 useEffect(setup, deps),傳入兩個參數:
- setup:準備函式,在畫面提交(React 把結果更新到畫面上)之後執行。
- setup 可以回傳一個清除函式(cleanup):下一次 setup 執行之前,以及元件離開畫面時會先執行它,用來停掉計時器、取消訂閱。不需要清除就不回傳。
- deps:依賴陣列,列出 setup 裡讀到的 props 與 state。React 用
Object.is 比較每一項和上一輪是否相同。
一覽
第二個參數有三種寫法,決定 setup 何時再跑:
[a, b]:第一次畫完後執行,之後只要列出的任何一項變了就再執行。
[]:只在第一次畫完後執行。
- 省略第二個參數:每一次渲染之後都執行。
effect 的規則也有 ESLint 在把關。本課專案使用 eslint-plugin-react-hooks 7,下面會用到它的兩條規則:react-hooks/exhaustive-deps 檢查依賴有沒有寫齊,react-hooks/set-state-in-effect 檢查有沒有在 effect 裡同步設定 state。
第一次執行
依賴是空陣列時,setup 只在元件第一次出現後執行,清除函式則在元件離開畫面時執行。這個 demo 讓 setup 與清除函式各印一行,再放一個按鈕讓元件重新渲染,用來確認重新渲染不會讓 effect 再跑。
觀念
空陣列表示這個 effect 不依賴任何會變的值,所以只在第一次畫完後跑,之後無論 state 怎麼變都不重跑。
開發時 <StrictMode> 還會刻意多做一輪檢查:第一次掛上後,立刻執行清除,再執行一次 setup,看清除函式有沒有把 setup 做的事復原。這輪檢查只在開發模式出現,正式建置只跑一次。<StrictMode> 為什麼預設開著,見 React 基礎:JSX、元件、狀態與表單 的「createRoot」。
03-react/src/demos/48-effect.jsximport { useEffect, useState } from 'react';
export default function EffectMount() { const [count, setCount] = useState(0);
useEffect(() => { console.log('效果執行'); return () => { console.log('清除'); }; }, []);
return ( <section> <p>計數 {count}。效果只在第一次畫完後執行,請看 Console。</p> <button type="button" className="mt-3 rounded bg-teal-800 px-3 py-1 text-white" onClick={() => setCount((value) => value + 1)} > 加一 </button> </section> ); }
|
解析
- 畫面第一次出現時,Console 依序印出三行:「效果執行」、「清除」、「效果執行」。中間那行就是 StrictMode 的檢查,把第一次的 setup 收尾,再重新做一次。
- 在正式建置裡,同一個畫面只會印一次「效果執行」。
- 按下「加一」,畫面上的次數增加,Console 沒有新的輸出,因為依賴是空陣列,重新渲染不會讓 effect 重跑。
- 切換到別的 demo,這個元件卸載(離開畫面),Console 會再印一次「清除」。
依賴陣列
effect 裡讀到的 props 與 state 都要列進依賴陣列,列出的值只要有一個變了,React 就先執行上一次的清除,再用新的值執行 setup。
觀念
依賴陣列可以列很多項,例如 [keyword, page]。這個 demo 只列一項,方便看出是哪一個值引起重跑。setup 印出這一次的查詢字,清除函式印出上一次的查詢字。
03-react/src/demos/49-deps.jsximport { useEffect, useState } from 'react';
export default function DepsDemo() { const [keyword, setKeyword] = useState('台北城市漫遊');
useEffect(() => { console.log('查詢', keyword); return () => { console.log('清除', keyword); }; }, [keyword]);
return ( <section> <p>查詢字 {keyword}</p> <button type="button" className="rounded bg-teal-800 px-3 py-1 text-white" onClick={() => setKeyword('花蓮山海三日')} > 改查花蓮山海三日 </button> </section> ); }
|
解析
- 剛打開時,StrictMode 的檢查讓 Console 先出現「查詢 台北城市漫遊」、「清除 台北城市漫遊」、「查詢 台北城市漫遊」,和上一則是同一種檢查。
- 按下按鈕後,查詢字變成「花蓮山海三日」,依賴改變,Console 先印「清除 台北城市漫遊」,再印「查詢 花蓮山海三日」。清除函式看到的是上一輪的值。
- 再按一次,查詢字沒有改變,React 看依賴相同,不會重跑 effect。
- 依賴是用
Object.is 比較,渲染時現做的物件或陣列,每一輪都是新的參考,effect 就可能每次都重跑(React Compiler 有時會幫忙穩定參考,但不要依賴這點),所以盡量只放原始值(字串、數字、布林)。
清除函式
清除函式負責把 setup 開始的事停下來:計時器要清掉、訂閱要取消、進行中的請求要中止。沒有清除,元件離開畫面後,這些工作仍然繼續運作。
觀念
這個 demo 用計時器:setup 啟動一個每秒加一的計時器,並把計時器編號(id)記下來,清除函式用這個編號停掉計時器。計時器的回呼裡才設定 state,setup 本身只負責啟動與停止計時器。
03-react/src/demos/50-timer.jsximport { useEffect, useState } from 'react';
export default function TimerDemo() { const [seconds, setSeconds] = useState(0);
useEffect(() => { const id = setInterval(() => { setSeconds((value) => value + 1); }, 1000); return () => clearInterval(id); }, []);
return <p>秒數 {seconds}</p>; }
|
解析
- 畫面上的秒數從 0 開始,大約每一秒加 1。
- 依賴是空陣列,計時器只啟動一次,秒數更新造成的重新渲染不會再啟動新的計時器。
- 設定秒數時用更新函式(拿到最新值再加一),不讀渲染當下的值,所以空依賴也不會讓秒數卡在同一個數字。
- 切到別的 demo 後,清除函式把計時器停掉。如果沒有清除,計時器會在背景一直跑,持續浪費資源。
- 開發時,StrictMode 會先清掉第一個計時器再重新啟動一個,畫面上不會看到兩倍速;正式建置只啟動一次。
無限迴圈
渲染和 effect 若互相觸發,就會停不下來:effect 設定 state,state 改變造成渲染,渲染後 effect 又執行。這一節先看會造成迴圈的寫法,再看正確的做法。
觀念
迴圈要同時滿足兩件事:effect 每一輪渲染後都會執行(省略依賴,或依賴每次都變),而且 setup 裡同步設定了 state。下面這段就是典型的錯誤。
不要放進專案
沒有第二個參數,所以每一輪渲染後都會執行;setup 裡又同步設定 state,造成下一輪渲染。React 在開發模式會在 Console 警告超過更新次數上限。
useEffect(() => { setCount(count + 1); });
|
react-hooks/set-state-in-effect 會把「在 effect 本體同步呼叫設定函式」標成問題,即使有依賴也一樣,因為這種寫法多半可以改成渲染時直接算出來,少一輪多餘的渲染。能由 props 或 state 算出來的值就不要存進 state;effect 留給改動外部系統,例如下面的瀏覽器分頁標題。
03-react/src/demos/51-loop.jsximport { useEffect, useState } from 'react';
export default function LoopDemo() { const [place, setPlace] = useState('台北城市漫遊');
useEffect(() => { const previous = document.title; document.title = place; return () => { document.title = previous; }; }, [place]);
return ( <section> <p>分頁標題 {place}</p> <button type="button" className="rounded bg-teal-800 px-3 py-1 text-white" onClick={() => setPlace('花蓮山海三日')} > 改成花蓮山海三日 </button> </section> ); }
|
解析
- setup 只改外部的
document.title,沒有呼叫設定函式,所以 effect 不會再引起渲染,不會形成迴圈。
- 依賴是
[place],只有地點改變才重新設定標題。
- 打開後,分頁標題變成「台北城市漫遊」,畫面上的句子也是這個名字。按一次按鈕,標題與句子一起換成「花蓮山海三日」,然後停住;再按一次,值沒變,什麼都不會發生。
- 清除函式把標題還原成這一次 setup 之前的文字,所以切到別的 demo 後,分頁標題回到「React 練習」。
- 以上只是用來說明 effect 改外部系統。React 19 也可以直接在元件裡寫 title 標籤,React 會把它放進文件的 head,實務上改分頁標題用這個比較簡單。
漏寫依賴
effect 裡讀到的 props 與 state 少列在依賴陣列時,effect 會一直拿著第一次渲染的舊值。react-hooks/exhaustive-deps 會警告少了哪個名字;它是警告,不會讓 pnpm lint 失敗,但不能放著不管。
觀念
這個 demo 故意寫成有問題的版本:effect 讀了 count,依賴卻是空陣列。修正的做法有兩種:把缺的值補進依賴,或把那個讀取從 effect 裡拿掉。用註解把警告關掉不算修正,那只是讓 React 以為依賴齊全。
03-react/src/demos/52-lint.jsximport { useEffect, useState } from 'react';
export default function LintDemo() { const [count, setCount] = useState(0);
useEffect(() => { console.log('次數', count); }, []);
return ( <section> <p>次數 {count}</p> <button type="button" className="rounded bg-teal-800 px-3 py-1 text-white" onClick={() => setCount((value) => value + 1)} > 加一 </button> </section> ); }
|
解析
- 打開時,StrictMode 讓 effect 跑兩次,Console 印出兩行「次數 0」。
- 按下「加一」,畫面上的次數變成 1、2、3,Console 卻不再有新輸出,因為 effect 只在第一次渲染後建立,記住的
count 永遠是 0。
- 在
03-react 資料夾執行 pnpm exec eslint src/demos/52-lint.jsx,會看到 react-hooks/exhaustive-deps 指出少了 count。
- 修正是把依賴改成
[count],下面是完整的修正版:按下「加一」後,Console 每次都跟著印出新的次數。
03-react/src/demos/52b-lint-fixed.jsximport { useEffect, useState } from 'react';
export default function LintFixedDemo() { const [count, setCount] = useState(0);
useEffect(() => { console.log('次數', count); }, [count]);
return ( <section> <p>次數 {count}</p> <button type="button" className="rounded bg-teal-800 px-3 py-1 text-white" onClick={() => setCount((value) => value + 1)} > 加一 </button> </section> ); }
|
讀取資料
讀取資料是 effect 最常見的用途:元件第一次出現後,向本機檔案或遠端 API 要資料,再放進 state 畫出來。讀取不是瞬間完成,所以畫面要準備三種情況:還在等、失敗,以及成功但沒有資料。
本課專案的資料讀取是用路由的 loader 完成,見 React Router:路由、連結與參數。在 effect 裡讀取是需要理解的基本概念,但不是專案採用的寫法。若不用路由的 loader,實務上多半會改用 TanStack Query、SWR 這類資料函式庫,它們幫你處理快取與取消請求。
一覽
- 載入中:請求還沒回來,畫一句等待的文字,不要用空清單假裝已經完成。
- 失敗:網路出錯或回應不成功,畫錯誤訊息。
- 沒有資料:請求成功但陣列是空的,這是正常的結果,要和失敗分開,畫「沒有資料」。
- 有資料:畫出清單。
graph LR
loadNode["載入中"] --> okNode["成功"]
loadNode --> errNode["失敗"]
okNode --> emptyNode["沒有資料"]
okNode --> listNode["畫出清單"]
style loadNode fill:#fff3e0
style okNode fill:#e3f2fd
style errNode fill:#ffebee
style emptyNode fill:#e8f5e9
style listNode fill:#e8f5e9
載入與錯誤
用一個 state 記錄目前處於哪一種狀態,另一個 state 放資料。這個 demo 讀本機 public/data/ 底下的 items.json,裡面有三筆資料,並把狀態設成載入中、完成或失敗。
觀念
- 狀態一開始就是
loading,所以第一個畫面直接顯示「載入中」。初始值由 useState 給,不是在 effect 裡設定。
- effect 的函式本身不能加
async(它必須回傳清除函式或什麼都不回傳,不能回傳 Promise),所以在裡面定義一個 async 函式再呼叫它。
fetch 只有在網路出錯時才會失敗,遇到 404、500 仍算收到回應,所以要檢查 response.ok,不成功就丟出錯誤,由 catch 統一處理。
- 設定 state 發生在
await 之後,不是 effect 本體同步執行,所以不會被 react-hooks/set-state-in-effect 標記。
03-react/src/demos/53-load.jsximport { useEffect, useState } from 'react';
export default function LoadDemo() { const [status, setStatus] = useState('loading'); const [items, setItems] = useState([]);
useEffect(() => { const load = async () => { try { const response = await fetch('/data/items.json'); if (!response.ok) throw new Error(String(response.status)); setItems(await response.json()); setStatus('ready'); } catch { setItems([]); setStatus('error'); } }; load(); }, []);
if (status === 'loading') return <p>載入中</p>; if (status === 'error') return <p>讀取失敗</p>; if (items.length === 0) return <p>沒有資料</p>;
return ( <ul className="grid gap-2"> {items.map((item) => ( <li key={item.id}> {item.title} {item.price} </li> ))} </ul> ); }
|
解析
- 第一個畫面是「載入中」,使用者看得到還在等。請求完成後變成三列:台北城市漫遊 12800、花蓮山海三日 15900、京都紅葉散步 42800。
- 回應不成功時進入 catch,畫面變成「讀取失敗」,不會把錯誤頁面的內容當成清單。回應是成功但內容不是 JSON 時,解析 JSON 會丟出例外,同樣進 catch。
- 三種提早 return 的順序是先看載入、再看錯誤、最後才看資料是否為空。
- 開發時 StrictMode 會讓 effect 多跑一輪,所以網路分頁會看到兩次請求,結果相同,畫面不受影響。
- 列表的
key 用資料本身的 id,規則和前面的列表一樣。
空資料
成功拿到一份空陣列,和失敗是兩件事。這個 demo 的程式骨架和上一則完全相同,只把資料來源換成內容為 [] 的 empty.json。
觀念
請求成功,所以狀態是 ready;清單長度為 0,所以不畫清單,改寫「沒有資料」。不要用「讀取失敗」來表示沒有資料,使用者會誤以為網路壞了而一直重新整理。
03-react/src/demos/54-empty.jsximport { useEffect, useState } from 'react';
export default function EmptyLoadDemo() { const [status, setStatus] = useState('loading'); const [items, setItems] = useState([]);
useEffect(() => { const load = async () => { try { const response = await fetch('/data/empty.json'); if (!response.ok) throw new Error(String(response.status)); setItems(await response.json()); setStatus('ready'); } catch { setItems([]); setStatus('error'); } }; load(); }, []);
if (status === 'loading') return <p>載入中</p>; if (status === 'error') return <p>讀取失敗</p>; if (items.length === 0) return <p>沒有資料</p>;
return ( <ul> {items.map((item) => ( <li key={item.id}>{item.title}</li> ))} </ul> ); }
|
解析
- 畫面停在「沒有資料」,瀏覽器網路分頁裡
empty.json 的狀態碼是 200,也就是請求成功,只是內容為空。
- 長度判斷放在 ready 之後。載入中時陣列同樣是空的,但這時不能說沒有資料。
- 錯誤的分支在這個 demo 不會執行,除非檔案被移除。
選讀:AbortController
連續發出多個請求時,回應回來的順序不一定和發出的順序相同。舊的請求若比新的晚回來,又去設定 state,就會把新的結果蓋掉,這個問題叫做競態(race condition)。元件卸載後,進行中的請求也還在跑。AbortController 可以取消進行中的請求,用在 effect 的清除函式最合適。
觀念
AbortController 產生一個 signal,交給 fetch;清除函式呼叫 abort,請求就被取消,fetch 會以名稱為 AbortError 的例外結束。這是主動取消,不是讀取失敗,所以 catch 裡看到它要直接返回,不要改成錯誤畫面。
03-react/src/demos/55-abort.jsximport { useEffect, useState } from 'react';
export default function AbortDemo() { const [status, setStatus] = useState('loading'); const [items, setItems] = useState([]);
useEffect(() => { const controller = new AbortController();
const load = async () => { try { const response = await fetch('/data/items.json', { signal: controller.signal, }); if (!response.ok) throw new Error(String(response.status)); setItems(await response.json()); setStatus('ready'); } catch (error) { if (error.name === 'AbortError') return; setItems([]); setStatus('error'); } };
load(); return () => controller.abort(); }, []);
if (status === 'loading') return <p>載入中</p>; if (status === 'error') return <p>讀取失敗</p>;
return ( <ul className="grid gap-2"> {items.map((item) => ( <li key={item.id}> {item.title} {item.price} </li> ))} </ul> ); }
|
解析
- signal 和這一次 effect 綁在一起,清除時只取消這一次的請求。
- 開發時 StrictMode 會先跑 setup、清除、再跑 setup,第一次請求被取消後返回,不設定任何 state,第二次請求完成後才畫出三列資料。
- 取消後不能設定錯誤狀態,否則第一次被取消的請求會把畫面停在失敗。
- 依賴若之後加上查詢條件,條件一變就先取消舊請求,再發新請求,舊回應不會蓋掉新結果。
- React 官方文件也示範另一種做法:在 effect 裡放一個旗標變數,清除時把它設成 true,回應回來時先檢查旗標,已作廢就不設定 state。這種做法不取消請求,只忽略舊的回應。
選讀:遠端寫入
前面的讀取在元件第一次出現時進行。新增、更新與刪除則是使用者按一次才發生,所以請求要寫在事件處理函式裡,不放進 effect。這一節用 JSONPlaceholder(一個練習用的公開 API)走完四種常用的請求,最後把它們收進同一個模組。JSONPlaceholder 會回傳成功的狀態碼,但不會真的保存資料,重新讀取仍是原本的內容。
一覽
- GET:讀取資料,不改伺服器上的資料。
- POST:新增一筆,成功時狀態碼通常是 201,回應裡有新資料的 id。
- PUT:用送出的整份資料替換指定 id 的那一筆;只改部分欄位的是 PATCH。
- DELETE:刪除指定 id 的那一筆。
GET
GET 讀取單筆文章,路徑最後一段是文章的 id。這個 demo 按下按鈕才發請求,請求屬於使用者的操作,所以放在事件處理函式裡,不需要 effect。
觀念
按下之後先把訊息設成「讀取中」,避免使用者以為沒按到;成功後換成文章標題,失敗則顯示「讀取失敗」。
03-react/src/demos/56-get.jsximport { useState } from 'react';
export default function GetDemo() { const [title, setTitle] = useState('尚未讀取');
const onLoad = async () => { setTitle('讀取中'); try { const response = await fetch( 'https://jsonplaceholder.typicode.com/posts/1', ); if (!response.ok) throw new Error(String(response.status)); const post = await response.json(); setTitle(post.title); } catch { setTitle('讀取失敗'); } };
return ( <section> <button type="button" className="rounded bg-teal-800 px-3 py-1 text-white" onClick={onLoad} > 讀取第一篇 </button> <p className="mt-3">{title}</p> </section> ); }
|
解析
- 沒有按按鈕就不會發出請求,請求在事件裡,不在渲染裡。
- 路徑的
1 是文章 id,換一個數字就是讀另一筆。
- 成功與失敗都寫進同一個 state,畫面只讀那一行。
- 按下之後,畫面上的「尚未讀取」換成第一篇文章的標題。
POST
POST 把新資料放在請求的 body,標頭要註明內容是 JSON。這個 demo 送出一筆新資料,並把回應裡的狀態碼與 id 顯示出來。
觀念
JSONPlaceholder 回應的 id 是練習用的編號,那一筆不會真的留在伺服器上,重新讀取也看不到。
03-react/src/demos/57-post.jsximport { useState } from 'react';
export default function PostDemo() { const [message, setMessage] = useState('尚未送出');
const onCreate = async () => { try { const response = await fetch( 'https://jsonplaceholder.typicode.com/posts', { method: 'POST', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify({ title: '新行程', body: '台北城市漫遊', userId: 1 }), }, ); if (!response.ok) throw new Error(String(response.status)); const created = await response.json(); setMessage(response.status + ' id ' + created.id); } catch (error) { setMessage(error.message); } };
return ( <section> <button type="button" className="rounded bg-teal-800 px-3 py-1 text-white" onClick={onCreate} > 新增 </button> <p className="mt-3">{message}</p> </section> ); }
|
解析
method 設成 POST。沒寫的話 fetch 會用 GET,body 也不會被送出。
JSON.stringify 把物件轉成文字,標頭 Content-Type 告訴對方這是 JSON。
- 按下之後,訊息類似「201 id 101」,狀態碼與 id 都來自回應,不要自己猜 id。
- 再按一次仍然成功,因為練習服務不會保存任何資料。
PUT
PUT 替換指定 id 的那一筆,網址要帶 id,body 是替換後的整份資料。沒有送出的欄位,在替換的語意下就不會留在新的那一份。這門課的練習用 PUT,因為示範的表單就是交出完整的一份。
觀念
這個 demo 把 id 為 1 的文章標題改成「更新後的標題」,成功時把回應裡的標題顯示在畫面上,並在 Console 印出狀態碼。
03-react/src/demos/58-put.jsximport { useState } from 'react';
export default function PutDemo() { const [title, setTitle] = useState('尚未更新');
const onUpdate = async () => { try { const response = await fetch( 'https://jsonplaceholder.typicode.com/posts/1', { method: 'PUT', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify({ id: 1, title: '更新後的標題', body: '內容', userId: 1, }), }, ); if (!response.ok) throw new Error(String(response.status)); const updated = await response.json(); console.log(response.status); setTitle(updated.title); } catch (error) { setTitle(error.message); } };
return ( <section> <button type="button" className="rounded bg-teal-800 px-3 py-1 text-white" onClick={onUpdate} > 更新第一篇 </button> <p className="mt-3">{title}</p> </section> ); }
|
解析
- 路徑帶著要替換的 id;POST 的網址則停在集合,不帶 id。
- body 含 id、標題、內文與 userId,是整份替換。
- 按下之後,畫面變成「更新後的標題」,Console 印出狀態碼 200。
- 練習服務沒有真的保存,重新讀取 id 1 仍是原本的文章。
DELETE
DELETE 的網址指向要刪除的那一筆,通常沒有 body。這個 demo 只確認狀態碼,因為刪除的回應不一定有 JSON 內容。
觀念
按下後對 id 1 送出 DELETE,成功就顯示「已刪除」加狀態碼,失敗則顯示錯誤訊息。畫面上若有清單,要等請求成功後才更新它,失敗時維持原樣,下一節的完整示範就是這樣做。
03-react/src/demos/59-delete.jsximport { useState } from 'react';
export default function DeleteDemo() { const [message, setMessage] = useState('尚未刪除');
const onDelete = async () => { try { const response = await fetch( 'https://jsonplaceholder.typicode.com/posts/1', { method: 'DELETE' }, ); if (!response.ok) throw new Error(String(response.status)); setMessage('已刪除 ' + response.status); } catch (error) { setMessage(error.message); } };
return ( <section> <button type="button" className="rounded bg-teal-800 px-3 py-1 text-white" onClick={onDelete} > 刪除第一篇 </button> <p className="mt-3">{message}</p> </section> ); }
|
解析
- 方法是 DELETE,網址指向那一筆,不是整個集合。
- 沒有 body,所以不必加 JSON 標頭。
- 成功的判斷仍然是
response.ok,HTTP 的 404、500 不會讓 fetch 自己丟出例外。
- 按下之後,畫面顯示「已刪除 200」。再去讀同一筆,練習服務仍然會回傳原本的文章。
API 模組
前面每個 demo 都在元件裡自己組網址、標頭、檢查 response.ok,重複而且冗長。實務上會把請求收進一個模組,元件只負責什麼時候呼叫、畫面上的狀態如何改變。這一節先看模組本身,再看使用它的完整示範。
本節用到 import 與 export,是 JavaScript 的模組寫法,細節見 JavaScript 基礎:值、函式、陣列與模組 的選讀章節「ES Module」。這裡只需要知道:export 的函式可以被其他檔案 import 來用。
模組函式
模組集中處理網址、標頭與成功檢查,每個函式對應一種請求。
一覽
readJson:模組內部使用,回應成功時讀出 JSON,不成功就丟出含狀態碼的錯誤。
getItems:讀本機的清單,可以傳入 AbortController 的 signal 讓呼叫端取消。
getItem:依 id 讀單筆。
createItem:新增一筆。
updateItem:替換指定 id 的整筆。
deleteItem:刪除指定 id,成功時回傳 true。
03-react/src/api/fake-api.jsconst itemsUrl = 'https://jsonplaceholder.typicode.com/posts';
const readJson = async (response) => { if (!response.ok) throw new Error(String(response.status)); return response.json(); };
export const getItems = async (signal) => { const response = await fetch('/data/items.json', { signal }); return readJson(response); };
export const getItem = async (id) => { const response = await fetch(itemsUrl + '/' + id); return readJson(response); };
export const createItem = async (item) => { const response = await fetch(itemsUrl, { method: 'POST', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify(item), }); return readJson(response); };
export const updateItem = async (id, item) => { const response = await fetch(itemsUrl + '/' + id, { method: 'PUT', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify(item), }); return readJson(response); };
export const deleteItem = async (id) => { const response = await fetch(itemsUrl + '/' + id, { method: 'DELETE' }); if (!response.ok) throw new Error(String(response.status)); return true; };
|
解析
- 清單讀本機的
/data/items.json;單筆、新增、更新與刪除的基底網址指向 JSONPlaceholder 的 /posts。
readJson 集中檢查回應是否成功,失敗時丟出的錯誤訊息是狀態碼。
getItems 的 signal 可以不傳;有傳時,呼叫端的清除函式才取消得了這次請求。
deleteItem 成功時不讀 JSON,因為刪除的回應常常是空的,硬讀反而會失敗。
示範完整 CRUD
這個示範把前面學到的東西串在一起:進畫面時在 effect 裡讀清單,新增、更新、刪除則在事件裡呼叫模組函式。
觀念
- 元件讀的是自己的清單 state,不是每次都重新向伺服器要。
- 練習服務不會保存,所以請求成功後,要自己更新清單:新增是接上新的一列,更新是換掉同一個 id,刪除是拿掉那個 id。
- 新增的編號由本機清單自己算,因為練習服務回應的編號不可靠,不適合拿來當 key。
- 重新整理頁面,清單會回到本機檔案裡的三筆。
03-react/src/demos/60-items-demo.jsximport { useEffect, useState } from 'react'; import { createItem, deleteItem, getItems, updateItem, } from '../api/fake-api.js';
const emptyForm = { title: '', place: '', days: '', price: '' };
export default function ItemsDemo() { const [items, setItems] = useState([]); const [message, setMessage] = useState('載入中'); const [ready, setReady] = useState(false); const [form, setForm] = useState(emptyForm); const [editingId, setEditingId] = useState(null);
useEffect(() => { const controller = new AbortController(); const load = async () => { try { setItems(await getItems(controller.signal)); setMessage(''); setReady(true); } catch (error) { if (error.name === 'AbortError') return; setMessage('讀取失敗'); } }; load(); return () => controller.abort(); }, []);
const onChange = (event) => { const { name, value } = event.target; setForm((current) => ({ ...current, [name]: value })); };
const onNew = () => { setEditingId(null); setForm(emptyForm); };
const onEdit = (item) => { setEditingId(item.id); setForm({ title: item.title, place: item.place, days: String(item.days), price: String(item.price), }); };
const onDelete = async (id) => { try { await deleteItem(id); setItems((current) => current.filter((item) => item.id !== id)); if (editingId === id) onNew(); setMessage(''); } catch (error) { setMessage(error.message); } };
const onSubmit = async (event) => { event.preventDefault(); const id = editingId; const fields = { title: form.title, place: form.place, days: Number(form.days), price: Number(form.price), }; try { if (id === null) { const nextId = Math.max(0, ...items.map((item) => item.id)) + 1; await createItem(fields); setItems((current) => [...current, { ...fields, id: nextId }]); } else { await updateItem(id, { ...fields, id }); setItems((current) => current.map((item) => (item.id === id ? { ...fields, id } : item)), ); } onNew(); setMessage(''); } catch (error) { setMessage(error.message); } };
if (!ready) return <p>{message}</p>;
return ( <section className="grid items-start gap-4 md:grid-cols-2"> <div className="grid gap-3"> <button type="button" className="justify-self-start rounded bg-teal-800 px-3 py-1 text-white" onClick={onNew} > 新增 </button> <ul className="grid gap-2"> {items.map((item) => ( <li key={item.id} className="grid gap-2 rounded border border-stone-200 bg-white p-4" > <p>{item.title}</p> <p> {item.place} {item.days} 天 {item.price} </p> <div className="flex gap-2"> <button type="button" className="rounded bg-teal-800 px-3 py-1 text-white" onClick={() => onEdit(item)} > 編輯 </button> <button type="button" className="rounded bg-teal-800 px-3 py-1 text-white" onClick={() => onDelete(item.id)} > 刪除 </button> </div> </li> ))} </ul> </div> <form onSubmit={onSubmit} className="grid max-w-sm gap-3"> <p>{editingId === null ? '新增' : '編輯'}</p> <input name="title" value={form.title} onChange={onChange} placeholder="標題" className="rounded border px-2 py-1" /> <input name="place" value={form.place} onChange={onChange} placeholder="地點" className="rounded border px-2 py-1" /> <input name="days" value={form.days} onChange={onChange} placeholder="天數" className="rounded border px-2 py-1" /> <input name="price" value={form.price} onChange={onChange} placeholder="價格" className="rounded border px-2 py-1" /> <button type="submit" className="justify-self-start rounded bg-teal-800 px-3 py-1 text-white" > 送出 </button> {message ? <p>{message}</p> : null} </form> </section> ); }
|
解析
- 畫面先顯示「載入中」。完成後左邊上方是「新增」按鈕,下面是三張卡片:台北城市漫遊(台北、3 天、12800)、花蓮山海三日(花蓮、3 天、15900)、京都紅葉散步(京都、5 天、42800),每張有「編輯」與「刪除」。右邊是表單,標題「新增」,四個欄位是空的。
- 按「編輯」,右邊標題改成「編輯」並填入那一筆的資料。送出或刪除成功後,左邊的清單跟著更新,表單回到新增模式。
- 載入放在 effect,裡面建立 AbortController 並把 signal 交給
getItems;名稱是 AbortError 就直接返回,不改成讀取失敗。
editingId 是空值時是新增,有值時是正在編輯的那一筆,兩種送出共用同一份表單。
- 新增、更新、刪除都在事件處理函式裡呼叫,不放進 effect。請求失敗時清單維持原樣,只顯示錯誤訊息。
選讀:不需要 effect 的情況
這一節是選讀。effect 是讓元件跟外部系統(網路、計時器、瀏覽器 API)同步的出口,沒有外部系統要同步時,多半不需要它。下面兩種寫法最常見:能在渲染時算出來的值直接算,使用者按下才發生的請求放在事件函式裡。
渲染時計算
總價等於單價乘人數,這種由現有資料就能算出的值,不必另外存進狀態。這一節先看多此一舉的寫法,再看直接計算的寫法。
觀念
狀態只存「無法由別的資料算出」的東西。人數是使用者操作的結果,需要狀態;總價完全由單價和人數決定,每次渲染時相乘即可。若把總價也放進狀態,再用 effect 在人數改變後補寫,畫面會先用舊的總價渲染一次,effect 跑完才再渲染一次,白白多一輪,兩份資料也可能對不上。
下面這支是多此一舉的寫法。eslint-plugin-react-hooks 的規則 react-hooks/set-state-in-effect 會把 effect 裡同步呼叫的 setTotal 標成錯誤。
03-react/src/demos/61-derive.jsximport { useEffect, useState } from 'react';
export default function DeriveDemo() { const [count, setCount] = useState(2); const price = 12800; const [total, setTotal] = useState(price * count);
useEffect(() => { setTotal(price * count); }, [count]);
return ( <section> <p> {count} 人,共 {total} </p> <button type="button" className="rounded bg-teal-800 px-3 py-1 text-white" onClick={() => setCount((value) => value + 1)} > 加一人 </button> </section> ); }
|
打開是「2 人,共 25600」,因為狀態初值就是 price * count。按「加一人」,人數變成 3,但那一輪渲染的總價仍是 25600,effect 跑完才排出下一輪,總價才變成 38400。
解析
total 有自己的狀態和設定函式,卻完全可以由 price 與 count 算出,這就是多餘的狀態。
- effect 在人數改變之後才補寫總價,所以每次人數變動都比必要的多渲染一次。
- 清單的篩選、排序、組字串也是同一類,直接寫在渲染裡。
下面是改好的版本:拿掉總價的狀態與 effect,渲染時直接相乘。人數一變,元件重新執行,總價自然跟著更新。
03-react/src/demos/61b-derive-fixed.jsximport { useState } from 'react';
export default function DeriveFixedDemo() { const [count, setCount] = useState(2); const price = 12800; const total = price * count;
return ( <section> <p> {count} 人,共 {total} </p> <button type="button" className="rounded bg-teal-800 px-3 py-1 text-white" onClick={() => setCount((value) => value + 1)} > 加一人 </button> </section> ); }
|
畫面與上一支完全相同,但少了一個狀態、一支 effect,也不會再被規則標出錯誤。
事件裡的請求
請求若是由按鈕觸發,就寫在按鈕的事件函式裡。這一節先看把請求繞進 effect 的寫法,再看直接寫在事件裡的寫法。
觀念
判斷放哪裡,只要問「這件事為什麼要發生」。因為元件顯示在畫面上而需要的(進頁面就讀清單),放 effect;因為使用者做了某個動作才需要的(按下就送出),放事件函式。
下面這支把按鈕做成只改旗標 armed,再讓 effect 依賴 armed,旗標變成 true 才去讀資料。請求的原因明明是按鈕,卻繞了一圈經過狀態與 effect。
03-react/src/demos/62-click.jsximport { useEffect, useState } from 'react';
export default function ClickFetchDemo() { const [armed, setArmed] = useState(false); const [status, setStatus] = useState('尚未按下'); const [post, setPost] = useState(null);
useEffect(() => { if (!armed) return; const load = async () => { setStatus('讀取中'); setPost(null); try { const response = await fetch( 'https://jsonplaceholder.typicode.com/posts/5', ); if (!response.ok) throw new Error(String(response.status)); setPost(await response.json()); setStatus('完成'); } catch { setPost(null); setStatus('讀取失敗'); } }; load(); }, [armed]);
return ( <section> <p>狀態 {status}</p> <button type="button" className="mt-3 rounded bg-teal-800 px-3 py-1 text-white" onClick={() => setArmed(true)} > 按一下讀第五篇 </button> {post ? ( <p className="mt-3"> #{post.id} {post.title} </p> ) : null} </section> ); }
|
按下之前,狀態是「尚未按下」,沒有請求。按下之後 effect 才送出,狀態依序是「讀取中」、「完成」,並出現 #5 與標題;失敗時是「讀取失敗」。再按一次沒有任何反應:armed 早已是 true,依賴沒變,effect 不會重跑。
解析
- 事件只改旗標,真正的請求在 effect 裡,讀程式的人要追兩個地方才看得懂「按下會發生什麼」。
- 想重新讀取,得先把
armed 設回 false 再設成 true,多出一輪沒有畫面意義的渲染。
- GET 的路徑、狀態碼與 JSON 欄位,見 08 的 fetch 章節。
下面是改好的版本:把請求搬進按鈕的處理函式,拿掉旗標與 effect。事件函式可以是 async;元件函式本身仍然是同步的。
03-react/src/demos/62b-click-event.jsximport { useState } from 'react';
export default function ClickEventDemo() { const [status, setStatus] = useState('尚未按下'); const [post, setPost] = useState(null);
const onLoad = async () => { setStatus('讀取中'); setPost(null); try { const response = await fetch( 'https://jsonplaceholder.typicode.com/posts/5', ); if (!response.ok) throw new Error(String(response.status)); setPost(await response.json()); setStatus('完成'); } catch { setPost(null); setStatus('讀取失敗'); } };
return ( <section> <p>狀態 {status}</p> <button type="button" className="mt-3 rounded bg-teal-800 px-3 py-1 text-white" onClick={onLoad} > 按一下讀第五篇 </button> {post ? ( <p className="mt-3"> #{post.id} {post.title} </p> ) : null} </section> ); }
|
按幾次就讀幾次,每次都先顯示「讀取中」。要在使用者操作之外、進畫面就讀取的資料,才回到 effect(見「載入與錯誤」)。
選讀:自訂 Hook
重複的狀態與讀取流程可以收成一個函式,名稱以 use 開頭,這就是自訂 Hook。它是普通函式,不是元件:不回傳畫面,回傳狀態與動作,畫面仍由元件負責。因為裡面會呼叫別的 Hooks,它也要遵守 Hooks 規則,只在元件或其他 Hook 的最上層呼叫。
抽出讀取
讀取、載入、失敗、取消這一套流程,可以收進一個 Hook,讓元件只負責依狀態畫出畫面。
觀念
useLocalItems 把原本寫在元件裡的狀態與 effect 整包搬走,依賴是空陣列,所以只在使用它的元件第一次畫完後讀取一次。它回傳的物件每一輪都是新的,呼叫端不要把整個物件放進別的 effect 依賴。
03-react/src/hooks/useLocalItems.jsimport { useEffect, useState } from 'react'; import { getItems } from '../api/fake-api.js';
export function useLocalItems() { const [status, setStatus] = useState('loading'); const [items, setItems] = useState([]);
useEffect(() => { const controller = new AbortController(); const load = async () => { try { setItems(await getItems(controller.signal)); setStatus('ready'); } catch (error) { if (error.name === 'AbortError') return; setItems([]); setStatus('error'); } }; load(); return () => controller.abort(); }, []);
return { status, items }; }
|
示範元件只剩三種畫面,裡面沒有 fetch,也沒有 effect。
03-react/src/demos/63-hook.jsximport { useLocalItems } from '../hooks/useLocalItems.js';
export default function HookDemo() { const { status, items } = useLocalItems();
if (status === 'loading') return <p>載入中</p>; if (status === 'error') return <p>讀取失敗</p>;
return ( <ul className="grid gap-2"> {items.map((item) => ( <li key={item.id}> {item.title} {item.price} </li> ))} </ul> ); }
|
畫面先顯示「載入中」,讀完後是三筆資料;讀取失敗則顯示「讀取失敗」。
解析
- 名稱以
use 開頭,Lint 才會把裡面的 Hooks 當成 Hooks 檢查。
- Hook 不是元件,所以那個檔不回傳 JSX。
- 每個呼叫它的元件各有一份自己的狀態,不會自動共用。
傳入引數
自訂 Hook 和一般函式一樣可以接收引數,同一套邏輯就能依引數走出不同的結果。
觀念
useToggle 用引數決定一開始是開還是關,並回傳目前狀態與切換函式。引數只在第一次建立狀態時用到,之後再改引數,不會把狀態改回去。
03-react/src/hooks/useToggle.jsimport { useState } from 'react';
export function useToggle(initialOpen) { const [open, setOpen] = useState(initialOpen);
const toggle = () => { setOpen((value) => !value); };
return { open, toggle }; }
|
兩個 Panel 各呼叫一次,各傳不同的初始值。
03-react/src/demos/64-toggle.jsximport { useToggle } from '../hooks/useToggle.js';
function Panel({ label, initialOpen }) { const { open, toggle } = useToggle(initialOpen);
return ( <section className="rounded border p-3"> <p> {label}:{open ? '開' : '關'} </p> <button type="button" className="rounded bg-teal-800 px-3 py-1 text-white" onClick={toggle} > 切換 </button> </section> ); }
export default function ToggleDemo() { return ( <section className="grid gap-3"> <Panel label="左側" initialOpen={true} /> <Panel label="右側" initialOpen={false} /> </section> ); }
|
一開始左側顯示「開」、右側顯示「關」。各自按「切換」,只改自己那一側。
解析
- 兩個
Panel 各呼叫一次 Hook,所以各有一份 open,互不影響。
- 引數可以是布林、字串、數字,重點是同一套邏輯能依引數有不同的起點。
引數放進依賴
若 Hook 內部的 effect 會讀到引數,而引數之後還會變,就要把它寫進依賴陣列。值一變,React 先執行上一次的清除,再用新的值重跑。
觀念
usePost(id) 依編號讀取一篇文章,[id] 是依賴。使用者換編號時,上一次尚未回來的請求就沒有用了,所以清除函式把 ignore 設成 true,舊的回應回來也不會寫進狀態,避免慢回來的舊資料蓋掉新資料。
03-react/src/hooks/usePost.jsimport { useEffect, useState } from 'react'; import { getItem } from '../api/fake-api.js';
export function usePost(id) { const [status, setStatus] = useState('loading'); const [post, setPost] = useState(null);
useEffect(() => { let ignore = false; const load = async () => { setStatus('loading'); try { const data = await getItem(id); if (ignore) return; setPost(data); setStatus('ready'); } catch { if (ignore) return; setPost(null); setStatus('error'); } }; load(); return () => { ignore = true; }; }, [id]);
return { status, post }; }
|
03-react/src/demos/65-hook-deps.jsximport { useState } from 'react'; import { usePost } from '../hooks/usePost.js';
export default function HookDepsDemo() { const [id, setId] = useState(1); const { status, post } = usePost(id);
return ( <section className="grid gap-3"> <p>目前編號 {id}</p> <div className="flex gap-2"> {[1, 2, 3].map((value) => ( <button key={value} type="button" className="rounded bg-teal-800 px-3 py-1 text-white" onClick={() => setId(value)} > 第 {value} 篇 </button> ))} </div> {status === 'loading' && <p>載入中</p>} {status === 'error' && <p>讀取失敗</p>} {status === 'ready' && ( <p> #{post.id} {post.title} </p> )} </section> ); }
|
一開始編號是 1,先顯示「載入中」,再出現第 1 篇的編號與標題。按「第 2 篇」,編號馬上變成 2,標題在新資料回來前仍短暫是上一篇的,接著變成「載入中」,再換成第 2 篇。
解析
- effect 讀到
id,依賴就要寫 [id]。少寫的話,換編號時資料不會重讀,畫面停在舊的文章。
- 清除函式設定
ignore,讓過期的請求結果被丟棄。開發時嚴格模式會讓 effect 在進畫面時多跑一次,第一次的結果同樣被這個旗標擋掉。
- 這一個 Hook 的邏輯是讀取一篇文章。像「篩選已載入的清單」這種可以直接在渲染時算的事,不該寫成依賴引數的 effect。
各呼叫各一份狀態
同一個 Hook 被呼叫幾次,就有幾份獨立的狀態與幾次請求。它只是共用程式碼,不是共用資料。
觀念
TwiceDemo 裡放兩個 NameList,各自呼叫一次 useLocalItems。
03-react/src/demos/66-twice.jsximport { useLocalItems } from '../hooks/useLocalItems.js';
function NameList() { const { status, items } = useLocalItems(); if (status !== 'ready') return <p>{status}</p>; return <p>{items.map((item) => item.title).join('、')}</p>; }
export default function TwiceDemo() { return ( <section className="grid gap-2"> <NameList /> <NameList /> </section> ); }
|
兩行都會變成「台北城市漫遊、花蓮山海三日、京都紅葉散步」,網路分頁會看到兩次 items.json。
解析
- 兩行文字一樣,是因為讀到的檔案一樣,不是狀態共用。
- 想只讀一次,把 Hook 呼叫在共同父層,再用 props 傳給兩個子元件,這就是下一章「共用狀態」要教的狀態提升。
共用狀態
兩個以上的元件要讀同一份會變的資料時,不能各存一份,否則一邊更新另一邊就對不上。做法是把狀態放到它們最近的共同父層,這叫做狀態提升(lifting state up)。這一章先看父層怎麼持有狀態,再看兩個兄弟元件如何靠父層共享,最後的選讀介紹 Context。結業專案的資料由路由的 loader 讀取,不走 Context。
父層持有
狀態提升的核心是單一資料來源(single source of truth):每一份資料只有一個元件擁有它,其他元件拿到的都是從它傳下來的值,而不是自己的複本。
觀念
資料流動的方向固定,口訣是「資料往下、事件往上」:
- 資料往下:父層把目前的值用 props 傳給子層。
- 事件往上:子層不能直接改父層的狀態,只能呼叫父層傳下來的函式,通知它要改。
graph LR
parent["父層:持有狀態與設定函式"] -->|"props:目前的值"| child["子層:顯示與接收輸入"]
child -->|"呼叫父層給的函式回報"| parent
下面的輸入框在子層,文字狀態在父層。子層沒有自己的狀態,只拿到 value 和 onChange 兩個 props:每打一個字,就呼叫 onChange 把新文字交給父層,父層更新狀態後再把新值傳回來。這種值完全由父層決定的輸入框,叫做受控元件。
03-react/src/demos/67-lift.jsximport { useState } from 'react';
function Editor({ value, onChange }) { return ( <input value={value} onChange={(event) => onChange(event.target.value)} className="rounded border px-2 py-1" /> ); }
export default function LiftDemo() { const [draft, setDraft] = useState('台北城市漫遊');
return ( <section className="grid max-w-sm gap-3"> <Editor value={draft} onChange={setDraft} /> <p>父層看到 {draft}</p> </section> ); }
|
輸入框一開始是「台北城市漫遊」。每打一個字,輸入框與下面那行「父層看到 …」同時更新。
解析
- 狀態與
setDraft 都屬於父層,子層只能透過 onChange 請父層修改,所以文字只有一份,不可能不一致。
onChange={setDraft} 可以這樣直接傳,因為子層呼叫它時給的就是新字串。
- 子層若自己再用狀態抄一份文字,就有兩份資料,會慢慢對不上;所以子層保持沒有狀態。
- 只有這顆輸入框自己用的暫存值,不必提升。放在越下層,影響的渲染範圍越小。
- 初始值不一定是常數。要從
localStorage 這類地方讀出來時,把函式交給 useState,寫成 useState(() => 讀取初始值()),React 只在第一次渲染呼叫它。寫成 useState(讀取初始值()) 的話,每次渲染都會再讀一次,只是結果只有第一次有用。
兄弟元件
兩個兄弟元件(同一個父層的兩個子元件)之間沒有直接傳資料的管道,最直接的共享方式,是把狀態放在它們共同的父層。
觀念
先看沒有提升的結果。下面的選擇區與摘要區各自有一份 picked 狀態,點選擇區的按鈕,只有選擇區自己的那份變了,摘要區讀不到,永遠停在「尚未選」。
03-react/src/demos/68-siblings-split.jsximport { useState } from 'react';
function Picker() { const [picked, setPicked] = useState('尚未選');
return ( <div className="grid gap-2"> <p>選擇區 {picked}</p> <div className="flex gap-2"> <button type="button" className="rounded bg-stone-100 px-3 py-1" onClick={() => setPicked('台北城市漫遊')} > 台北城市漫遊 </button> <button type="button" className="rounded bg-stone-100 px-3 py-1" onClick={() => setPicked('花蓮山海三日')} > 花蓮山海三日 </button> </div> </div> ); }
function Summary() { const [picked] = useState('尚未選'); return <p>摘要區 {picked}</p>; }
export default function SiblingsSplitDemo() { return ( <section className="grid gap-3"> <Picker /> <Summary /> </section> ); }
|
按下任一顆按鈕,「選擇區」那行會變成所選的名稱,「摘要區」那行仍是「尚未選」。
接著把狀態提升到共同父層。Picker 只負責回報,Summary 只負責顯示,兩者都沒有狀態,也不 import 對方。
graph LR
parent["SiblingsDemo:picked 與 setPicked"] -->|"onPick"| picker["Picker:按鈕"]
picker -->|"onPick(名稱)"| parent
parent -->|"picked"| summary["Summary:顯示"]
03-react/src/demos/68b-siblings.jsximport { useState } from 'react';
function Picker({ onPick }) { return ( <div className="flex gap-2"> <button type="button" className="rounded bg-stone-100 px-3 py-1" onClick={() => onPick('台北城市漫遊')} > 台北城市漫遊 </button> <button type="button" className="rounded bg-stone-100 px-3 py-1" onClick={() => onPick('花蓮山海三日')} > 花蓮山海三日 </button> </div> ); }
function Summary({ picked }) { return <p>目前 {picked}</p>; }
export default function SiblingsDemo() { const [picked, setPicked] = useState('尚未選');
return ( <section className="grid gap-3"> <Picker onPick={setPicked} /> <Summary picked={picked} /> </section> ); }
|
一開始摘要是「目前 尚未選」。按下「花蓮山海三日」,父層的 picked 改變、整個 SiblingsDemo 重新渲染,摘要立刻變成「目前 花蓮山海三日」。
解析
Picker 沒有收到 picked,因為它只需要回報,不需要知道現在選了誰。
Summary 沒有收到設定函式,所以它只能顯示,不能自己改選取。
Summary 讀到的,就是 Picker 回報後父層存下的那一份,沒有第二份可以對不上。
- 摘要不對時,只要回到父層的
picked 查,不必在兩個子元件之間找。
選讀:useContext
狀態提升之後,資料還是靠 props 一層一層往下傳。若中間隔了好幾層,而這些中間層自己不用這份資料,每一層都得在參數裡多寫欄位再轉手,這種情況叫做屬性鑽孔(props drilling)。Context 不是另一種狀態,它只是讓真正要讀的元件,直接取得上層提供的值,中間層不必轉手。
一覽
createContext(預設值):建立一條通道,通道本身是一個物件。
<ThemeContext value={…}>:在上層把值放進通道(React 19 起可直接這樣寫,舊版是 <ThemeContext.Provider>)。
useContext(ThemeContext):在下層讀取最近一層上方放進來的值,只能在元件最上層呼叫。
use(ThemeContext):React 19 的另一種讀法,可以寫在條件或提早 return 之後。
層層傳遞的問題
先看沒有 Context 的寫法,感受中間層被迫轉手的麻煩。
觀念
主題狀態在最外層的 DrillDemo,真正顯示並切換的是最內層的 Banner。中間的 Layout 與 Panel 自己不用主題,卻得接收 theme 與 onThemeChange 再傳下去。
03-react/src/demos/69-drill.jsximport { useState } from 'react';
function Banner({ theme, onThemeChange }) { return ( <div className="grid gap-2"> <p>主題 {theme}</p> <button type="button" className="w-fit rounded bg-teal-800 px-3 py-1 text-white" onClick={() => onThemeChange('深色')} > 改成深色 </button> </div> ); }
function Panel({ theme, onThemeChange }) { return ( <div className="rounded border border-dashed border-stone-300 p-3"> <Banner theme={theme} onThemeChange={onThemeChange} /> </div> ); }
function Layout({ theme, onThemeChange }) { return ( <div className="rounded border border-stone-200 p-3"> <Panel theme={theme} onThemeChange={onThemeChange} /> </div> ); }
export default function DrillDemo() { const [theme, setTheme] = useState('淺色');
return ( <section className="grid gap-3"> <Layout theme={theme} onThemeChange={setTheme} /> </section> ); }
|
一開始是「主題 淺色」。按「改成深色」後變成「主題 深色」。
解析
- 狀態仍在最外層,資料來源只有一處,這點和狀態提升相同。
Layout 與 Panel 的 JSX 裡沒有用到主題,只是轉手,參數卻跟著膨脹。
- 之後若再多包一層,新的那層也得再寫一次兩個 props。
- 只有一層父子時直接用 props 就好,問題出在中間有很多層都不關心這份資料。
用 Context 改善
同一棵樹改用 Context:外層放值,內層直接讀,中間層不再有主題相關的 props。
觀念
通道用 createContext 建立一次,括號裡的值是預設值。外層用 <ThemeContext value={theme}> 把目前主題放上去,這一層稱為 provider,它底下的元件都能讀到。內層呼叫 useContext(ThemeContext) 取得最近一層 provider 的值;值改變時,讀它的元件會重新渲染。
03-react/src/demos/70-context.jsximport { createContext, useContext, useState } from 'react';
const ThemeContext = createContext('淺色');
function Banner() { const theme = useContext(ThemeContext); return <p>主題 {theme}</p>; }
function Panel() { return ( <div className="rounded border border-dashed border-stone-300 p-3"> <Banner /> </div> ); }
function Layout() { return ( <div className="rounded border border-stone-200 p-3"> <Panel /> </div> ); }
export default function ContextDemo() { const [theme, setTheme] = useState('淺色');
return ( <ThemeContext value={theme}> <section className="grid gap-3"> <button type="button" className="w-fit rounded bg-teal-800 px-3 py-1 text-white" onClick={() => setTheme('深色')} > 改成深色 </button> <Layout /> </section> </ThemeContext> ); }
|
一開始是「主題 淺色」。按「改成深色」後,最內層文字變成「主題 深色」,而 Layout 與 Panel 的參數裡沒有任何主題。
解析
value 是狀態裡的字串,按鈕改狀態,provider 的 value 跟著變,Banner 就重新渲染。
Banner 在元件最上層呼叫 useContext,不寫在條件裡。
Layout 與 Panel 沒有 import Context,也不轉 props,只畫外框。
- 值放在 provider 裡之後,要改它仍然得經過父層的狀態與設定函式,資料來源依舊只有一處。
拆成多個檔案
元件分檔時,通道只能建立一次,其他檔案都 import 同一個物件;各自建立的兩條通道互不相通。
觀念
下面把同一個示範拆進資料夾 71-contextDemo,每個檔只做一件事:
ThemeContext.js:只呼叫一次 createContext 並匯出。
Banner.jsx:import 那個物件,再讀值。
Panel.jsx、Layout.jsx:只畫外框,不碰 Context。
index.jsx:持有狀態,用 provider 包住 Layout。
import 與 export 的語法見 JavaScript 基礎:值、函式、陣列與模組 的選讀 ES Module 章節。
03-react/src/demos/71-contextDemo/ThemeContext.jsimport { createContext } from 'react';
export const ThemeContext = createContext('淺色');
|
03-react/src/demos/71-contextDemo/Banner.jsximport { useContext } from 'react'; import { ThemeContext } from './ThemeContext.js';
export default function Banner() { const theme = useContext(ThemeContext); return <p>主題 {theme}</p>; }
|
03-react/src/demos/71-contextDemo/Panel.jsximport Banner from './Banner.jsx';
export default function Panel() { return ( <div className="rounded border border-dashed border-stone-300 p-3"> <Banner /> </div> ); }
|
03-react/src/demos/71-contextDemo/Layout.jsximport Panel from './Panel.jsx';
export default function Layout() { return ( <div className="rounded border border-stone-200 p-3"> <Panel /> </div> ); }
|
03-react/src/demos/71-contextDemo/index.jsximport { useState } from 'react'; import { ThemeContext } from './ThemeContext.js'; import Layout from './Layout.jsx';
export default function ContextSplitDemo() { const [theme, setTheme] = useState('淺色');
return ( <ThemeContext value={theme}> <section className="grid gap-3"> <button type="button" className="w-fit rounded bg-teal-800 px-3 py-1 text-white" onClick={() => setTheme('深色')} > 改成深色 </button> <Layout /> </section> </ThemeContext> ); }
|
畫面與上一節相同:先是「主題 淺色」,按下按鈕後變成「主題 深色」。
解析
Banner.jsx 與 index.jsx import 的是同一個物件,能對上的是物件本身,不是變數名稱相同。
- 若
Banner.jsx 自己再呼叫一次 createContext,那是另一條通道,外層的 provider 對它沒有作用。
Panel 與 Layout 完全不認識 Context,所以之後換成別種資料也不必動它們。
預設值
樹上沒有 provider 時,讀取的人拿到建立 Context 時的預設值。
觀念
預設值只是最後的後備,而且是固定的,不會隨狀態改變;要讓值隨時間變,一定要靠 provider 加上狀態。下面直接用資料夾裡的 Banner,故意不包 provider,畫面就是 ThemeContext.js 裡設定的預設字串。
03-react/src/demos/72-default.jsximport Banner from './71-contextDemo/Banner.jsx';
export default function DefaultDemo() { return <Banner />; }
|
畫面是「主題 淺色」,沒有按鈕,也不會變。
解析
- 有 provider 時一律以 provider 的 value 為準,預設值不會被用到。
- 預設值適合「沒包到也能照常顯示」的情況。若沒包 provider 就是程式錯誤,可以像後面 Context 搭配
useReducer 的範例那樣,在自訂 Hook 裡丟出錯誤,比較好找。
用 use 讀取
React 19 提供 use,也能讀 Context。它和 useContext 的差別在位置:use 可以寫在條件或提早 return 之後,useContext 不行。
觀念
下面的 ThemeLabel 在 show 為 false 時提早 return,之後才呼叫 use(ThemeContext)。同樣的位置換成 useContext 就違反 Hooks 規則。讀到的值與 useContext 相同:最近一層 provider 的值,沒有 provider 則是預設值。
03-react/src/demos/72b-use-context.jsximport { createContext, use, useState } from 'react';
const ThemeContext = createContext('淺色');
function ThemeLabel({ show }) { if (!show) return <p>沒有顯示主題</p>; const theme = use(ThemeContext); return <p>主題 {theme}</p>; }
export default function UseContextDemo() { const [show, setShow] = useState(false);
return ( <ThemeContext value="深色"> <section className="grid gap-3"> <button type="button" className="w-fit rounded bg-teal-800 px-3 py-1 text-white" onClick={() => setShow((value) => !value)} > 切換顯示 </button> <ThemeLabel show={show} /> </section> </ThemeContext> ); }
|
一開始畫面是「沒有顯示主題」。按「切換顯示」變成「主題 深色」,再按一次又回到「沒有顯示主題」。
解析
use 可以接在 if 與提早 return 之後,這是它與 useContext 唯一的使用差異。
- provider 寫在父元件
UseContextDemo,讀取的 ThemeLabel 是它的子元件,use 只會往上找,不會讀同一個元件自己放出的 provider。
- 一般情況沿用
useContext 即可,需要在條件之後讀取時才用 use。
選讀:React Compiler 與手動記憶化
元件每次重新渲染都會把函式從頭跑一遍,有些計算、函式與子元件其實和上一次完全相同。把這些結果記住、輸入沒變就重複使用,稱為記憶化(memoization)。React 提供三個手動工具,而本課專案啟用了 React Compiler,會在建置時自動做同一件事。這一節先釐清兩者的分工,後面三節才逐一看手動工具怎麼運作。
編譯器做什麼
React Compiler 是建置時的工具,會分析元件與自訂 hook 的程式碼,替裡面的值、函式與 JSX 加上等同手動記憶化的處理。以前要自己寫的三種工具,編譯器都能代勞:
一覽
useMemo 記住一次計算的結果,見下一節。
memo 包住元件,props 沒變就跳過它的重渲染,見再下一節。
useCallback 記住函式本身,讓它在多次渲染間保持同一個,見第三節。
多數情況下,編譯器自動記住的範圍與精準度不輸手寫,所以新寫的程式不需要主動加這三個工具。它能安全運作的前提是程式遵守 React 的規則,例如渲染過程保持純粹、不直接改動 props 與 state。
仍需要手動記憶化的情況
編譯器只處理元件與 hook 內部,這幾種情形仍要自己決定:
- 計算寫在元件與 hook 之外的一般函式,編譯器不會替它記憶化;而且記住的結果不會在不同元件之間共用。
- 某個值或函式要當作 effect 的依賴,又必須在內容沒變時保持同一份,官方文件指出這時仍可用
useMemo 或 useCallback 精準控制。
- 舊程式或沒有啟用編譯器的專案,原本的手動記憶化要保留;官方建議移除前先充分測試,因為移除可能改變編譯後的結果。
在動手加記憶化之前,官方文件建議先用更根本的做法:讓元件用 children 接收 JSX、把狀態放在需要它的最近一層、保持渲染純粹,並避免不必要的 effect。這些做法常常就讓問題消失,也是本課專案的寫法,因此專案裡沒有用到這三個工具。
eslint-plugin-react-hooks 7 內建一組和編譯器對應的檢查,在編輯器裡就會標出不合規則的寫法:
purity:渲染中呼叫了已知不純的函式。
refs:渲染中讀寫了 ref 的 current。
set-state-in-effect:在 effect 裡同步呼叫 setState。
preserve-manual-memoization:手寫的記憶化與編譯器的分析不相容。
關閉編譯器:use no memo
編譯器開著時,後面三節的「沒有記憶化」範例會被自動優化,看不出重渲染的差別。為了讓範例的現象成立,這些檔案最上方都寫了檔案層級的指令 'use no memo',告訴編譯器略過整個檔案。
這個指令也能寫在單一函式主體的最開頭,只關閉那一個函式。官方文件把它定位為暫時的緊急出口,用在除錯編譯器造成的問題,或搭配與編譯器不相容的第三方函式庫,建議註明為什麼關閉。位置寫在函式中間或使用反引號都會失效。
另外,專案用 StrictMode 執行,開發模式下 React 會把元件函式多呼叫一次以找出不純的寫法,所以 Console 的訊息常會成對出現(React DevTools 可能把第二則顯示成較淡)。後面的範例看的是「操作之後有沒有新增訊息」,不必在意實際印了幾行。
選讀:useMemo
很多次渲染其實跟某個計算無關,例如輸入框只是多打了一個字,算出來的結果卻和上次一模一樣,這種重算就是白做工。useMemo 把計算結果記住,只有計算用到的值改變時才重算,其他時候的渲染直接沿用上次的結果。它省下的是每次渲染裡重複的計算,並不會讓元件少渲染一次;要跳過整個元件的重渲染,用下一節的 memo。
下面先看沒有使用 useMemo 時浪費在哪裡,再改成使用 useMemo 對照效果。
沒有使用 useMemo 時
元件每次重渲染,寫在函式裡的計算都會再做一次。
觀念
text 是留言內容,畫面顯示輸入字數;star 是星等,預設五顆星,點第幾顆就改成幾顆。評語只看星等:四顆以上是「值得推薦」,否則是「普通」。計算前先印出「計算中」,方便在 Console 數次數。
03-react/src/demos/73-memo.jsx 'use no memo';
import { useState } from 'react';
export default function MemoDemo() { const [text, setText] = useState(''); const [star, setStar] = useState(5);
console.log('計算中'); const label = star >= 4 ? '值得推薦' : '普通';
return ( <section className="grid max-w-sm gap-3"> <label className="grid gap-1"> 留言 <input value={text} onChange={(event) => setText(event.target.value)} className="rounded border px-2 py-1" /> </label> <p>輸入字數 {text.length}</p> <div className="flex gap-1"> {[1, 2, 3, 4, 5].map((n) => ( <button key={n} type="button" className="text-2xl text-amber-500" onClick={() => setStar(n)} > {n <= star ? '★' : '☆'} </button> ))} </div> <p>星等 {star}</p> <p>評語 {label}</p> </section> ); }
|
解析
- 五顆星是用
map 畫出的五顆按鈕。編號小於等於目前星等的顯示 ★,其餘顯示 ☆,點哪一顆就把星等設成那個編號。
- 點星星改星等,重算評語是應該的。
- 在留言欄打字會呼叫
setText,元件重渲染,整個函式從頭再跑一次。星等沒變,評語那行卻又執行,Console 每次按鍵都新增「計算中」,結果和上次一樣,這次計算就是浪費。
useState 本身不是負擔,花時間的是函式裡那些算畫面資料的程式。
這裡的評語只是比大小再選字串,就算每次重算,負擔也很小。若計算很複雜,例如對上千筆資料篩選、排序或統計,每打一個字都重跑就會拖慢畫面,這時記住結果才有明顯效果。範例故意用簡單的計算,是為了看清楚什麼時候會重算。
graph TD
textNode["留言改變"] --> renderNode["元件重渲染"]
renderNode --> calcNode["評語又算一次"]
style textNode fill:#e3f2fd
style renderNode fill:#fff3e0
style calcNode fill:#ffcdd2
使用 useMemo
useMemo 接收一個計算函式與依賴陣列。依賴沒變就沿用上次的值,不再執行計算;依賴變了才重算,並記住新的結果。依賴的比較用 Object.is。
同一支範例把評語放進 useMemo,依賴是 [star]。
03-react/src/demos/73b-memo-use.jsx 'use no memo';
import { useMemo, useState } from 'react';
export default function MemoUseDemo() { const [text, setText] = useState(''); const [star, setStar] = useState(5); const label = useMemo(() => { console.log('計算中'); return star >= 4 ? '值得推薦' : '普通'; }, [star]);
return ( <section className="grid max-w-sm gap-3"> <label className="grid gap-1"> 留言 <input value={text} onChange={(event) => setText(event.target.value)} className="rounded border px-2 py-1" /> </label> <p>輸入字數 {text.length}</p> <div className="flex gap-1"> {[1, 2, 3, 4, 5].map((n) => ( <button key={n} type="button" className="text-2xl text-amber-500" onClick={() => setStar(n)} > {n <= star ? '★' : '☆'} </button> ))} </div> <p>星等 {star}</p> <p>評語 {label}</p> </section> ); }
|
解析
- 留言打字仍會重渲染,但星等沒變,
useMemo 沿用上次的值,Console 不再新增「計算中」。
- 點星星改了星等,依賴變了,才重算並再印一次。
- 計算函式要保持純粹,不要在裡面改動 props 或其他既有的物件;開發模式的 StrictMode 會把它多呼叫一次來檢查。
- 官方文件建議先用
console.time 量測,總耗時達到約 1 毫秒以上才可能有幫助;useMemo 也不會加快第一次渲染,只省下更新時的重複計算。
graph TD
textNode["留言改變"] --> renderNode["元件重渲染"]
renderNode --> sameNode["依賴沒變"]
sameNode --> keepNode["沿用上次的評語"]
starNode["星等改變"] --> redoNode["重新計算"]
style textNode fill:#e3f2fd
style renderNode fill:#fff3e0
style sameNode fill:#fff3e0
style keepNode fill:#e8f5e9
style starNode fill:#e3f2fd
style redoNode fill:#ffcdd2
本課專案啟用了 React Compiler,一般元件裡的計算會被自動記住,不必手寫 useMemo。手動版本仍有用的時機見本節之前的「React Compiler 與手動記憶化」。
選讀:memo
父層一重渲染,子元件預設也會跟著重渲染,就算交給它的 props 跟上次一模一樣。memo 把元件包起來之後,父層重渲染時會先比對 props;每一個 props 都和上次相同,就跳過這次渲染,沿用上次的畫面。
下面先看沒有使用 memo 時子元件怎麼被拖著重渲染,再改成使用 memo 對照效果。
沒有使用 memo 時
父層重渲染時,子元件會一起重渲染,即使 props 沒變。
觀念
延續評價留言的範例。父層有留言輸入框與五顆星按鈕;StarView 是子元件,只接收目前的星等,畫出五顆亮暗星星,每次渲染印出「星星列渲染」。
03-react/src/demos/74-memo-component.jsx 'use no memo';
import { useState } from 'react';
function StarView({ star }) { console.log('星星列渲染');
return ( <div className="flex gap-1"> {[1, 2, 3, 4, 5].map((n) => ( <span key={n} className="text-2xl text-amber-500"> {n <= star ? '★' : '☆'} </span> ))} </div> ); }
export default function MemoComponentDemo() { const [text, setText] = useState(''); const [star, setStar] = useState(5);
return ( <section className="grid max-w-sm gap-3"> <label className="grid gap-1"> 留言 <input value={text} onChange={(event) => setText(event.target.value)} className="rounded border px-2 py-1" /> </label> <p>輸入字數 {text.length}</p> <div className="flex gap-1"> {[1, 2, 3, 4, 5].map((n) => ( <button key={n} type="button" className="text-2xl text-amber-500" onClick={() => setStar(n)} > {n <= star ? '★' : '☆'} </button> ))} </div> <StarView star={star} /> <p>星等 {star}</p> </section> ); }
|
解析
StarView 只看 star 決定哪幾顆亮。點父層的星星按鈕改星等,子元件跟著重渲染是應該的。
- 在留言欄打字會呼叫
setText,父層重渲染。星等沒變、子元件收到的 props 也沒變,卻還是一起重渲染,Console 每次按鍵都新增「星星列渲染」。這就是浪費。
graph TD
textNode["留言改變"] --> parentNode["父層重渲染"]
parentNode --> childNode["星星列又渲染一次"]
style textNode fill:#e3f2fd
style parentNode fill:#fff3e0
style childNode fill:#ffcdd2
使用 memo
memo 包起來的元件,在父層重渲染時會先比對 props。每一個 props 都和上次相同,就跳過這次渲染,沿用上次的畫面。
同一支範例把 StarView 用 memo 包起來。
03-react/src/demos/74b-memo-wrap.jsx 'use no memo';
import { memo, useState } from 'react';
const StarView = memo(function StarView({ star }) { console.log('星星列渲染');
return ( <div className="flex gap-1"> {[1, 2, 3, 4, 5].map((n) => ( <span key={n} className="text-2xl text-amber-500"> {n <= star ? '★' : '☆'} </span> ))} </div> ); });
export default function MemoWrapDemo() { const [text, setText] = useState(''); const [star, setStar] = useState(5);
return ( <section className="grid max-w-sm gap-3"> <label className="grid gap-1"> 留言 <input value={text} onChange={(event) => setText(event.target.value)} className="rounded border px-2 py-1" /> </label> <p>輸入字數 {text.length}</p> <div className="flex gap-1"> {[1, 2, 3, 4, 5].map((n) => ( <button key={n} type="button" className="text-2xl text-amber-500" onClick={() => setStar(n)} > {n <= star ? '★' : '☆'} </button> ))} </div> <StarView star={star} /> <p>星等 {star}</p> </section> ); }
|
解析
- 留言打字時父層仍會重渲染,但
star 沒變,memo 判定 props 相同,星星列跳過渲染,Console 不再新增「星星列渲染」。
- 點星星改了星等,
star 變了,星星列才重渲染並再印一次。
- 被
memo 包住的元件,自己的狀態改變、或它讀取的 context 改變時,仍然會重渲染;memo 只擋父層帶來的重渲染。
graph TD
textNode["留言改變"] --> parentNode["父層重渲染"]
parentNode --> sameNode["props 沒變"]
sameNode --> skipNode["星星列跳過渲染"]
starNode["星等改變"] --> redoNode["星星列重渲染"]
style textNode fill:#e3f2fd
style parentNode fill:#fff3e0
style sameNode fill:#fff3e0
style skipNode fill:#e8f5e9
style starNode fill:#e3f2fd
style redoNode fill:#ffcdd2
memo 比對 props 時用的是 Object.is:數字、字串相同就算過,但每次渲染都新建的物件或函式,即使內容一樣也被判定成不同,memo 就擋不住。例如多傳一個每次都新建的 style 物件,每打一個字星星列又會重渲染。下一節的 useCallback 用來處理函式這種情況。有啟用 React Compiler 時,編譯器會自動套用等同 memo 的效果,通常不必手動加。
選讀:useCallback
上一節的 memo 靠比對 props 決定要不要跳過渲染。元件每次重新渲染,寫在裡面的函式也會重新建立一份;內容一樣,卻是新的函式。把它當 props 交給 memo 包住的子元件,子元件每次都收到「不同的」props,memo 就擋不住。useCallback 把函式記住,依賴沒變就交出同一個函式,讓子元件判斷 props 沒變而跳過重渲染。
下面先看沒有使用 useCallback 時的情形,再改成使用 useCallback 對照效果。
沒有使用 useCallback 時
觀念
星星按鈕拆成子元件 StarPicker,並用 memo 包起來;它從父層收到目前的星等,以及點選時要呼叫的函式。父層的事件處理函式寫成一般函式,每次渲染都會重新建立。子元件每次渲染印出「星星列渲染」。
03-react/src/demos/75-callback.jsx 'use no memo';
import { memo, useState } from 'react';
const StarPicker = memo(function StarPicker({ star, onPick }) { console.log('星星列渲染');
return ( <div className="flex gap-1"> {[1, 2, 3, 4, 5].map((n) => ( <button key={n} type="button" className="text-2xl text-amber-500" onClick={() => onPick(n)} > {n <= star ? '★' : '☆'} </button> ))} </div> ); });
export default function UseCallbackDemo() { const [text, setText] = useState(''); const [star, setStar] = useState(5); const handlePick = (n) => { setStar(n); };
return ( <section className="grid max-w-sm gap-3"> <label className="grid gap-1"> 留言 <input value={text} onChange={(event) => setText(event.target.value)} className="rounded border px-2 py-1" /> </label> <p>輸入字數 {text.length}</p> <StarPicker star={star} onPick={handlePick} /> <p>星等 {star}</p> </section> ); }
|
解析
StarPicker 用 star 決定哪幾顆亮,點按鈕時呼叫 onPick(n),由父層把星等設成 n。
- 在留言欄打字會讓父層重渲染,
handlePick 又被建立成新的函式。
memo 比對時,star 沒變,但 onPick 是新函式,所以判定 props 不同。星星列跟著重渲染,Console 每次按鍵都新增「星星列渲染」。
graph TD
textNode["留言改變"] --> parentNode["父層重渲染"]
parentNode --> fnNode["handlePick 變成新的函式"]
fnNode --> childNode["星星列又渲染一次"]
style textNode fill:#e3f2fd
style parentNode fill:#fff3e0
style fnNode fill:#fff3e0
style childNode fill:#ffcdd2
使用 useCallback
useCallback 記住一個函式,並看依賴陣列。依賴沒變就交出上次那一個函式;依賴變了才換成這次的新函式。
const handlePick = useCallback(fn, deps);
|
同一支範例把 handlePick 放進 useCallback,依賴是 []。
03-react/src/demos/75b-callback-use.jsx 'use no memo';
import { memo, useCallback, useState } from 'react';
const StarPicker = memo(function StarPicker({ star, onPick }) { console.log('星星列渲染');
return ( <div className="flex gap-1"> {[1, 2, 3, 4, 5].map((n) => ( <button key={n} type="button" className="text-2xl text-amber-500" onClick={() => onPick(n)} > {n <= star ? '★' : '☆'} </button> ))} </div> ); });
export default function UseCallbackUseDemo() { const [text, setText] = useState(''); const [star, setStar] = useState(5); const handlePick = useCallback((n) => { setStar(n); }, []);
return ( <section className="grid max-w-sm gap-3"> <label className="grid gap-1"> 留言 <input value={text} onChange={(event) => setText(event.target.value)} className="rounded border px-2 py-1" /> </label> <p>輸入字數 {text.length}</p> <StarPicker star={star} onPick={handlePick} /> <p>星等 {star}</p> </section> ); }
|
解析
handlePick 只呼叫 setStar。React 保證設定函式每次渲染都是同一個,不必放進依賴,所以依賴是 []。
- 留言打字時父層仍會重渲染,但
handlePick 還是同一個函式。memo 比對到 star 和 onPick 都沒變,星星列跳過渲染,Console 不再新增「星星列渲染」。
- 點星星改了星等,
star 變了,星星列才重渲染並再印一次。
graph TD
textNode["留言改變"] --> parentNode["父層重渲染"]
parentNode --> sameNode["handlePick 還是同一個"]
sameNode --> skipNode["星星列跳過渲染"]
starNode["星等改變"] --> redoNode["星星列重渲染"]
style textNode fill:#e3f2fd
style parentNode fill:#fff3e0
style sameNode fill:#fff3e0
style skipNode fill:#e8f5e9
style starNode fill:#e3f2fd
style redoNode fill:#ffcdd2
useCallback 要搭配 memo 包住的子元件才有意義;子元件沒有 memo 時,函式是不是同一個都沒差,只有函式被當成 effect 依賴時例外。這裡的星星列只有五顆按鈕,重渲染的負擔很小,實務上不必為它加 memo 與 useCallback。在啟用 React Compiler 的專案裡,編譯器通常已經替你記住函式與元件,更不需要手動加。
選讀:useRef
有時你要的不是畫面上顯示的文字,而是那顆真正的 DOM 節點,例如按下按鈕時呼叫 focus()、量尺寸,或捲到某個位置。這些是瀏覽器對節點提供的方法;只靠狀態描述「現在顯示什麼」,拿不到那顆節點。
useRef 用來在多次渲染之間記住一份值。它回傳一個普通物件,只有一個 current 欄位,每次渲染拿到的都是同一個物件。
要記住 DOM 時,先建立這個物件,再把它交給 JSX 的 ref 屬性(寫法見下方範本)。ref 是 JSX 的特殊屬性,不是 HTML 屬性。你交出去的是整個物件;畫面提交之後,React 才把節點寫進它的 current,節點被移除時再改回 null。
const inputRef = useRef(initialValue);
<input ref={inputRef} />
|
不要寫 ref={inputRef.current}。一開始它是 null,等於只傳空值進去,React 沒有物件可以把節點寫回去。
聚焦輸入框
按「聚焦」時,對記在 ref 裡的那個輸入框呼叫 focus()。
觀念
起始值是 null,因為在 React 把畫面交給瀏覽器之前,DOM 節點還不存在。掛上 ref 之後,current 才變成 DOM 元素,所以要在事件處理函式或 effect 裡才讀它。
不要在渲染過程中讀寫 current:這會讓渲染不再純粹,React 官方文件不建議,eslint-plugin-react-hooks 的 refs 規則也會標出。
聚焦是瀏覽器對畫面的行為(游標進到輸入框),跟 React 重跑元件無關,所以這一支不需要狀態。
跟過去學 JS 操作 DOM 的差別
以前用 JavaScript 直接改節點(找元素、改屬性、呼叫 focus()),覺得很理所當然。現在畫面多半靠 JSX 告訴 React「這次要長成什麼」,再由它去算差、更新 DOM;要碰真正的節點時,才透過 ref 伸手進去。
03-react/src/demos/76-ref.jsximport { useRef } from 'react';
export default function RefDemo() { const inputRef = useRef(null);
const onFocus = () => { inputRef.current?.focus(); };
return ( <section className="grid max-w-sm gap-3"> <input ref={inputRef} className="rounded border px-2 py-1" placeholder="名稱" /> <button type="button" className="w-fit rounded bg-teal-800 px-3 py-1 text-white" onClick={onFocus} > 聚焦 </button> </section> ); }
|
按下聚焦,游標進到輸入框,畫面上的文字不會因為這一下而重畫。
解析
useRef(null) 的起始值是 null,第一次渲染時節點還不在。
?. 避免節點還沒接上時呼叫 focus 而丟出錯誤。
- 這支範例沒有受控的輸入框,輸入的文字留在 DOM 裡,不經過 React 狀態。
ref 當作 props
函式元件預設不會把 ref 交出裡面的節點。在 React 19,元件直接把 ref 當成一般 props 接收,再轉給內部的內建元素,父層就能拿到那顆節點。
03-react/src/demos/76b-ref-prop.jsximport { useRef } from 'react';
function NameInput({ ref }) { return ( <input ref={ref} className="rounded border px-2 py-1" placeholder="名稱" /> ); }
export default function RefPropDemo() { const inputRef = useRef(null);
return ( <section className="grid max-w-sm gap-3"> <NameInput ref={inputRef} /> <button type="button" className="w-fit rounded bg-teal-800 px-3 py-1 text-white" onClick={() => inputRef.current?.focus()} > 聚焦 </button> </section> ); }
|
解析
NameInput 的參數直接解構出 ref,再放到 <input> 上。
- 父層對
NameInput 寫 ref={inputRef},按下聚焦時,inputRef.current 就是子元件裡的那個輸入框。
以前的寫法
React 18 以前,函式元件拿不到 ref 這個 props,要用 forwardRef 包起來。React 19 起新元件不需要它,官方表示未來版本會棄用並移除,舊程式裡看到仍可運作。
ref 函式與清理函式
ref 除了接物件,也可以接一個函式。節點出現時 React 呼叫它並傳入節點;React 19 起,這個函式可以回傳清理函式,節點被移除時 React 就執行它,用法和 effect 的清理類似。
觀念
這適合「節點一出現就要做事、消失時要收尾」的情況,例如訂閱某個節點的大小變化。下面用最簡單的聚焦與記錄示範。函式寫在元件外面,讓每次渲染拿到的是同一個函式;若在元件裡寫成每次都新建的函式,React 會判定 ref 變了,而在每次渲染時先清理、再重新呼叫。
03-react/src/demos/76c-ref-callback.jsximport { useState } from 'react';
function focusOnMount(node) { node.focus(); console.log('輸入框出現,已聚焦');
return () => { console.log('輸入框移除,清理'); }; }
export default function RefCallbackDemo() { const [open, setOpen] = useState(false);
return ( <section className="grid max-w-sm gap-3"> <button type="button" className="w-fit rounded bg-teal-800 px-3 py-1 text-white" onClick={() => setOpen(!open)} > {open ? '隱藏' : '顯示'}輸入框 </button> {open && ( <input ref={focusOnMount} className="rounded border px-2 py-1" placeholder="名稱" /> )} </section> ); }
|
按「顯示輸入框」,輸入框出現並取得焦點,Console 印出「輸入框出現,已聚焦」;按「隱藏輸入框」,印出「輸入框移除,清理」。
解析
- 回傳了清理函式,React 在節點移除時就不再用
null 呼叫 ref 函式。沒有回傳清理函式的舊寫法,移除時仍會收到 null,函式裡需要自己處理。
- StrictMode 在開發模式會替每個 ref 函式多跑一輪設定、清理、再設定,所以按「顯示輸入框」時 Console 會依序看到出現、移除、出現三行;正式版只有一行。清理寫得正確,這額外一輪就不會造成問題。
不觸發渲染的值
除了 DOM,current 也可以放「要跨渲染留下、但畫面不必顯示」的值。這時不要用 useState 硬記:每次 set… 都會整輪重跑,值沒畫上畫面也白跑。也不要用元件內的 let:每次重跑都會重新宣告,接不住上次的值。模組頂層的 let 雖然能留下,卻會讓多個實例搶同一份。
若用 useState 記,而畫面根本不顯示該值:
graph LR
needNode["只要記住<br/>畫面不顯示"] --> setNode["卻用 setState"]
setNode --> rerunNode["整輪重跑+比對"]
rerunNode --> wasteNode["畫面其實沒變"]
style needNode fill:#e8f5e9
style setNode fill:#fff3e0
style rerunNode fill:#e3f2fd
style wasteNode fill:#ffcdd2
若在元件函式裡寫 let count = 0:
graph LR
needNode2["只要記住<br/>畫面不顯示"] --> letNode["元件內 let"]
letNode --> r1Node["渲染 1:count = 0"]
r1Node --> clickNode["事件 += 1"]
clickNode --> r2Node["渲染 2:又從 0<br/>記不住"]
style needNode2 fill:#e8f5e9
style letNode fill:#fff3e0
style r1Node fill:#e3f2fd
style clickNode fill:#e3f2fd
style r2Node fill:#ffcdd2
那把 let 寫在元件函式外面呢?值確實能留下,因為模組只載入一次。但那一份變數屬於整個模組,不屬於某一次元件實例:
graph TD
sharedNode["模組頂層 let count = 0"]
aClick["元件 A 按一次<br/>count += 1"] --> sharedNode
bClick["元件 B 再按一次<br/>count += 1"] --> sharedNode
sharedNode --> resultNode["兩邊讀到的都是 2<br/>不是各自累計"]
style sharedNode fill:#fff3e0
style aClick fill:#e3f2fd
style bClick fill:#e3f2fd
style resultNode fill:#ffcdd2
useRef 就是為這種情況:每個元件實例各有自己的 ref 物件,改 current 不會觸發渲染。反過來說,要顯示在畫面上的數字仍放狀態;只放在 ref 裡,畫面不會自己更新。
觀念
每按一次「只累計」,ref 加一並印到 Console。畫面上的數字是 shown,只有按下「顯示」才把 ref 的值抄進狀態。這用來分辨「要記住」與「要畫出來」:要畫出來的值用狀態。
03-react/src/demos/77-ref-count.jsximport { useRef, useState } from 'react';
export default function RefCountDemo() { const clicks = useRef(0); const [shown, setShown] = useState(0);
const onCount = () => { clicks.current += 1; console.log(clicks.current); };
return ( <section> <p>畫面上的次數 {shown}</p> <button type="button" className="rounded bg-teal-800 px-3 py-1 text-white" onClick={onCount} > 只累計 </button> <button type="button" className="ml-2 rounded bg-stone-200 px-3 py-1" onClick={() => setShown(clicks.current)} > 顯示 </button> </section> ); }
|
連按只累計三次,Console 是 1、2、3,畫面仍是 0。再按顯示,畫面變成 3。
解析
clicks.current += 1 寫在事件處理函式裡,不會觸發渲染。
setShown 才會觸發渲染,它抄的是按下當下的 ref 值。
- 不要在渲染過程中寫
clicks.current += 1:StrictMode 的兩次渲染會把次數加兩次,lint 的 refs 規則也會標出。
- 計時器 id 也適合放在 ref;這一支用次數,是為了讓你在 Console 直接看到。
選讀:useReducer
useState 更新一兩個值很順手。可是同一份狀態有好幾種改法(加一、減一、歸零),或下一個值一定要看上一筆(清單新增、勾選、刪除)時,設定函式會散在各顆按鈕裡,讀起來要在元件上下找邏輯。
useReducer 把「狀態怎麼變」收進一個函式。元件負責送出「發生了什麼」,那個函式再依動作算出下一筆狀態。呼叫形狀是:
const reducer = (state, action) => { return nextState; };
const [state, dispatch] = useReducer(reducer, initialArg);
|
兩個回傳值跟 useState 對得上:左邊是現在的狀態,右邊是更新用的函式。差別在於右邊不是直接塞新值,而是呼叫 dispatch,送進一筆描述這次動作的物件(常見寫法是帶 type)。
真正算下一筆的是第一個參數 reducer。它接收「上一筆狀態」與「這次的 action」,必須回傳「下一筆狀態」。常用 switch 依 action 的 type 分支,認不出的走 default。
計數按鈕
下面用加一、減一、歸零把整條路接起來。按一下就送出一筆 action,React 把目前的 count 與這筆 action 交給 reducer,再用回傳值重跑畫面。
觀念
起始狀態是 0。三種按鈕各送一種 type;數字的加減與歸零都寫在 reducer 裡,元件只負責送出動作。
03-react/src/demos/78-reducer-count.jsximport { useReducer } from 'react';
function reducer(count, action) { switch (action.type) { case 'add': return count + 1; case 'sub': return count - 1; case 'reset': return 0; default: return count; } }
export default function ReducerCountDemo() { const [count, dispatch] = useReducer(reducer, 0);
return ( <section className="grid max-w-sm gap-3"> <p className="text-2xl font-semibold">{count}</p> <div className="flex flex-wrap gap-2"> <button type="button" className="rounded bg-teal-800 px-3 py-1 text-white" onClick={() => dispatch({ type: 'add' })} > 加一 </button> <button type="button" className="rounded bg-teal-800 px-3 py-1 text-white" onClick={() => dispatch({ type: 'sub' })} > 減一 </button> <button type="button" className="rounded bg-stone-200 px-3 py-1" onClick={() => dispatch({ type: 'reset' })} > 歸零 </button> </div> </section> ); }
|
按下加一,數字變大;減一變小;歸零回到 0。三種改法都走同一個 dispatch。
解析
useReducer(reducer, 0) 的第二個參數是起始狀態。
- 每個按鈕只描述「發生什麼」,不自己算下一筆數字。
- 和
useState 一樣,dispatch 之後在同一個事件處理函式裡讀到的 count 仍是舊值,新值要到下一次渲染才有。
default 把不認識的 type 原樣擋下。官方文件的範例改成丟出錯誤,打錯 type 時能立刻發現;本課為了簡短,選擇原狀態還回。
reducer 要當純函式
reducer 只能依傳進來的 state 與 action 算出下一筆並回傳:不要改動原來的陣列或物件,也不要在裡面打 API、讀時間或產生亂數。開發模式的 StrictMode 會把 reducer 多呼叫一次,丟掉其中一個結果;寫得純,多呼叫不會有影響,若直接改原陣列,就會看到待辦被加兩次。
待辦清單
同一份待辦(新增、勾選完成、刪除),下面先用 useState 寫一則,再用 useReducer 寫一則,對照邏輯放在哪裡。
觀念
每一筆待辦至少有 id、標題、是否完成。三種動作可以散在三個設定函式裡,也可以收進同一個 reducer:按鈕只送出 action,switch 依 type 回傳新陣列。
用 useState
三種改法各自一個函式,裡面都要自己展開或對應陣列。
03-react/src/demos/79-reducer-state.jsximport { useState } from 'react';
export default function ReducerStateDemo() { const [todos, setTodos] = useState([ { id: 1, title: '台北城市漫遊', done: false }, ]);
const onAdd = () => { setTodos((items) => [ ...items, { id: Date.now(), title: '新待辦', done: false }, ]); };
const onToggle = (id) => { setTodos((items) => items.map((todo) => todo.id === id ? { ...todo, done: !todo.done } : todo, ), ); };
const onRemove = (id) => { setTodos((items) => items.filter((todo) => todo.id !== id)); };
return ( <section> <button type="button" className="rounded bg-teal-800 px-3 py-1 text-white" onClick={onAdd} > 新增 </button> <ul className="mt-3 grid gap-2"> {todos.map((todo) => ( <li key={todo.id} className="flex gap-2"> <button type="button" className="rounded bg-stone-100 px-2" onClick={() => onToggle(todo.id)} > {todo.done ? '完成' : '未完成'} </button> <span>{todo.title}</span> <button type="button" className="rounded bg-stone-200 px-2" onClick={() => onRemove(todo.id)} > 刪除 </button> </li> ))} </ul> </section> ); }
|
按下新增會多一列「新待辦」;切換完成與刪除也看得到變化。行為正確,但「狀態怎麼變」散在 onAdd、onToggle、onRemove。
解析
- 每個事件處理函式都直接呼叫
setTodos,並在回呼裡算下一筆陣列。
- id 用
Date.now(),避免刪掉之後再新增時跟舊編號撞號。
key 用 id。標題可能重複,不能當 key。
用 useReducer
同一組行為改由 reducer 集中處理。元件只送出 action,陣列怎麼複製留在 switch 裡。
03-react/src/demos/80-reducer.jsximport { useReducer } from 'react';
const reducer = (todos, action) => { switch (action.type) { case 'add': return [...todos, { id: action.id, title: action.title, done: false }]; case 'toggle': return todos.map((todo) => todo.id === action.id ? { ...todo, done: !todo.done } : todo, ); case 'remove': return todos.filter((todo) => todo.id !== action.id); default: return todos; } };
export default function ReducerDemo() { const [todos, dispatch] = useReducer(reducer, [ { id: 1, title: '台北城市漫遊', done: false }, ]);
const onAdd = () => { dispatch({ id: Date.now(), title: '新待辦', type: 'add' }); };
return ( <section> <button type="button" className="rounded bg-teal-800 px-3 py-1 text-white" onClick={onAdd} > 新增 </button> <ul className="mt-3 grid gap-2"> {todos.map((todo) => ( <li key={todo.id} className="flex gap-2"> <button type="button" className="rounded bg-stone-100 px-2" onClick={() => dispatch({ type: 'toggle', id: todo.id })} > {todo.done ? '完成' : '未完成'} </button> <span>{todo.title}</span> <button type="button" className="rounded bg-stone-200 px-2" onClick={() => dispatch({ type: 'remove', id: todo.id })} > 刪除 </button> </li> ))} </ul> </section> ); }
|
畫面上的操作與上一則相同。差在新增、切換、刪除的轉移都寫在 reducer,元件讀起來較短。
解析
- 三個按鈕都只送出一種 action;陣列的複製留在 reducer。
- 新增時的 id 在
onAdd 裡用 Date.now() 產生,再放進 action 交給 reducer。reducer 要保持純粹,不能自己讀時間,否則同樣的輸入會得到不同結果。
- 對照上一則:行為一樣時,選
useState 或 useReducer 差在邏輯要不要集中,不是能不能做出清單。
搭配 Context
清單變大之後,通常會把畫面拆成幾個子元件。拆開之後,狀態和 dispatch 還留在父層,子元件要用就得靠 props 傳下去。這一節先看用 props 怎麼傳,再改成 context,對照少掉了哪些傳遞。
拆成元件用 props
觀念
把上一則的新增按鈕和列表各拆成一個子元件,狀態仍由最外層持有,所以狀態與 dispatch 要從父層當 props 交給子元件。三個檔案放在資料夾 81-propsDemo/:
AddButton.jsx:新增按鈕,只需要 dispatch。
TodoList.jsx:列表,要 todos 來畫,也要 dispatch 來切換與刪除。
index.jsx:放 reducer、持有 useReducer 並組合畫面。reducer 跟持有狀態的元件放同一個檔案,是小專案最常見的寫法。
03-react/src/demos/81-propsDemo/AddButton.jsxexport default function AddButton({ dispatch }) { return ( <button type="button" className="rounded bg-teal-800 px-3 py-1 text-white" onClick={() => dispatch({ type: 'add', id: Date.now(), title: '新待辦' })} > 新增 </button> ); }
|
03-react/src/demos/81-propsDemo/TodoList.jsxexport default function TodoList({ todos, dispatch }) { return ( <ul className="mt-3 grid gap-2"> {todos.map((todo) => ( <li key={todo.id} className="flex gap-2"> <button type="button" className="rounded bg-stone-100 px-2" onClick={() => dispatch({ type: 'toggle', id: todo.id })} > {todo.done ? '完成' : '未完成'} </button> <span>{todo.title}</span> <button type="button" className="rounded bg-stone-200 px-2" onClick={() => dispatch({ type: 'remove', id: todo.id })} > 刪除 </button> </li> ))} </ul> ); }
|
03-react/src/demos/81-propsDemo/index.jsximport { useReducer } from 'react'; import AddButton from './AddButton.jsx'; import TodoList from './TodoList.jsx';
const reducer = (todos, action) => { switch (action.type) { case 'add': return [...todos, { id: action.id, title: action.title, done: false }]; case 'toggle': return todos.map((todo) => todo.id === action.id ? { ...todo, done: !todo.done } : todo, ); case 'remove': return todos.filter((todo) => todo.id !== action.id); default: return todos; } };
export default function TodoPropsDemo() { const [todos, dispatch] = useReducer(reducer, [ { id: 1, title: '台北城市漫遊', done: false }, ]);
return ( <section> <AddButton dispatch={dispatch} /> <TodoList todos={todos} dispatch={dispatch} /> </section> ); }
|
操作跟上一則相同:新增多一列,切換完成、刪除都有效。差在畫面拆成兩個子元件,資料由父層用 props 傳進去。
解析
- reducer 跟上一則一模一樣,拆元件不影響狀態怎麼變。
AddButton 只接 dispatch,TodoList 接 todos 與 dispatch,都是父層用 props 傳進來的。
- 目前只有一層,props 還不算麻煩。若中間再多幾層外框元件,每一層都得幫忙轉傳,就變成前面 context 那一節提過的 props 層層傳遞。
改用 Context
觀念
做法跟前面 context 的主題色範例一樣:狀態搬進提供者元件,子元件自己從 context 取資料。資料夾 82-providerDemo/ 共五個檔案:
todo-context.js:只放 context 物件與 useTodos(包一層 useContext)。外層忘了包提供者時,它會直接丟錯,而不是默默拿到空值。
TodoContext.jsx:放 reducer 與 TodoProvider,用 <TodoContext value={...}> 把 { todos, dispatch } 交出去。React 19 直接把 context 當元件寫,不必再加 .Provider。
AddButton.jsx、TodoList.jsx:不再接 props,改呼叫 useTodos() 取自己要的欄位。
index.jsx:不再持有狀態,只用 TodoProvider 把畫面包起來。
元件檔只匯出元件,Fast Refresh 才不會被 hook 或常數擋住,所以 context 物件與 useTodos 獨立成 .js 檔。
03-react/src/demos/82-providerDemo/todo-context.jsimport { createContext, useContext } from 'react';
export const TodoContext = createContext(null);
export const useTodos = () => { const value = useContext(TodoContext); if (!value) throw new Error('缺少 TodoProvider'); return value; };
|
03-react/src/demos/82-providerDemo/TodoContext.jsximport { useReducer } from 'react'; import { TodoContext } from './todo-context.js';
const reducer = (todos, action) => { switch (action.type) { case 'add': return [...todos, { id: action.id, title: action.title, done: false }]; case 'toggle': return todos.map((todo) => todo.id === action.id ? { ...todo, done: !todo.done } : todo, ); case 'remove': return todos.filter((todo) => todo.id !== action.id); default: return todos; } };
export function TodoProvider({ children }) { const [todos, dispatch] = useReducer(reducer, [ { id: 1, title: '台北城市漫遊', done: false }, ]); return ( <TodoContext value={{ todos, dispatch }}> {children} </TodoContext> ); }
|
03-react/src/demos/82-providerDemo/AddButton.jsximport { useTodos } from './todo-context.js';
export default function AddButton() { const { dispatch } = useTodos(); return ( <button type="button" className="rounded bg-teal-800 px-3 py-1 text-white" onClick={() => dispatch({ type: 'add', id: Date.now(), title: '新待辦' })} > 新增 </button> ); }
|
03-react/src/demos/82-providerDemo/TodoList.jsximport { useTodos } from './todo-context.js';
export default function TodoList() { const { todos, dispatch } = useTodos(); return ( <ul className="mt-3 grid gap-2"> {todos.map((todo) => ( <li key={todo.id} className="flex gap-2"> <button type="button" className="rounded bg-stone-100 px-2" onClick={() => dispatch({ type: 'toggle', id: todo.id })} > {todo.done ? '完成' : '未完成'} </button> <span>{todo.title}</span> <button type="button" className="rounded bg-stone-200 px-2" onClick={() => dispatch({ type: 'remove', id: todo.id })} > 刪除 </button> </li> ))} </ul> ); }
|
03-react/src/demos/82-providerDemo/index.jsximport { TodoProvider } from './TodoContext.jsx'; import AddButton from './AddButton.jsx'; import TodoList from './TodoList.jsx';
export default function ProviderDemo() { return ( <TodoProvider> <section> <AddButton /> <TodoList /> </section> </TodoProvider> ); }
|
畫面和操作跟上一則相同。差在父層的 JSX 不再寫 dispatch={dispatch},子元件自己從 context 取資料。
解析
TodoProvider 包在兩個子元件外面。少了這層,useTodos 會丟出錯誤。
dispatch 的身份是穩定的,放進 context 不會因它而讓使用者重渲染。
AddButton 只拿 dispatch,TodoList 兩個都拿。
value 裡的物件在每次 TodoProvider 渲染時都是新建的;提供者重渲染(例如它的父層更新)時,所有讀這個 context 的元件都會跟著渲染。沒有編譯器時,官方文件的做法是用 useMemo 記住這個物件;本課專案有編譯器,通常不必手動處理。
- 這個 context 只服務待辦。主題若是另一份資料,另開一個 context,不要全部塞進同一個物件。
選讀:表單 Actions
表單送出後常要等伺服器回應,這段期間得顯示「送出中」、處理結果,必要時還要先把預期的畫面顯示出來。React 19 把這類流程統一成 Actions:把函式交給 <form action>,React 會把這次送出當成一筆動作(Action)來追蹤,進行中的狀態也能由 Hook 讀到。
上一篇的 onSubmit 加 preventDefault 仍然可用,這一節是另一種寫法。
一覽
<form action>:送出時 React 呼叫你的函式,傳入 FormData,並取消整頁導向。
useActionState:把動作的回傳結果與是否進行中一起交回來。
useFormStatus:讓表單裡的子元件讀到這張表單是否正在送出。
useOptimistic:動作還沒結束時,先顯示預期的結果。
graph LR
formNode["form action"] --> pendingNode["進行中"]
pendingNode --> doneNode["用結果更新畫面"]
style formNode fill:#e3f2fd
style pendingNode fill:#fff3e0
style doneNode fill:#e8f5e9
表單的 action 是函式時,React 會在 Transition(可被打斷、不阻塞畫面的更新)裡執行它,把這次送出的 FormData 傳進去,並取消整頁導向,所以不必再呼叫 preventDefault。
觀念
欄位的 name 是 title,送出函式用 formData.get('title') 讀值,組成訊息後放進狀態。函式可以是 async;這一則沒有真的打網路,只模擬留下這次詢問。
03-react/src/demos/83-action.jsximport { useState } from 'react';
export default function ActionDemo() { const [message, setMessage] = useState('尚未詢問');
const send = async (formData) => { setMessage('已收到詢問:' + String(formData.get('title') || '未填')); };
return ( <form action={send} className="grid max-w-sm gap-3"> <input name="title" className="rounded border px-2 py-1" placeholder="想去的行程(例如台北城市漫遊)" /> <button type="submit" className="rounded bg-teal-800 px-3 py-1 text-white" > 送出詢問 </button> <p>{message}</p> </form> ); }
|
送出前下面一行是「尚未詢問」。在輸入框打「台北城市漫遊」再按送出,下面一行變成「已收到詢問:台北城市漫遊」,網址不變,輸入框同時被清空。
解析
action 收到的是函式,不是網址字串。
- 讀值靠欄位的 name,輸入框是非受控的,不需要
value 與 onChange。
- 函式順利結束後,React 會自動重設表單裡的非受控欄位,所以輸入框清空;狀態
message 不受影響,畫面上的訊息留著。
- 函式若丟出錯誤,錯誤會交給最近的 Error Boundary,欄位不會被重設。
- 同一張表單不要一半用受控物件、一半用 action 各寫一套,兩邊會互相覆蓋。
useActionState
送出後通常要等伺服器回一個結果,例如「已儲存」或錯誤訊息,再顯示在畫面上。等待期間按鈕最好不能再按,免得同一筆送兩次。全靠 useState 要自己管「結果」和「是否送出中」兩份狀態;useActionState 把它們收在一起,你只寫一個送出函式。
const send = async (previous, formData) => { return result; };
const [state, formAction, isPending] = useActionState(send, initialState);
|
觀念
沿用前面寫好的假 API:send 呼叫 createItem,把行程名稱 POST 出去,拿回應裡的 title 串成報名訊息。進行中時按鈕停用並顯示「報名中」,結束後畫面換成 send 回傳的字串。send 不要自己呼叫,把拿到的 formAction 放進 action 即可。
03-react/src/demos/84-action-state.jsximport { useActionState } from 'react'; import { createItem } from '../api/fake-api.js';
const send = async (previous, formData) => { const item = await createItem({ title: String(formData.get('title') || '未填') }); const title = item.title; return previous === '尚未報名' ? '已報名:' + title : previous + '、' + title; };
export default function ActionStateDemo() { const [message, formAction, isPending] = useActionState(send, '尚未報名');
return ( <form action={formAction} className="grid max-w-sm gap-3"> <input name="title" className="rounded border px-2 py-1" placeholder="想報名的行程" /> <button type="submit" disabled={isPending} className="rounded bg-teal-800 px-3 py-1 text-white disabled:opacity-60" > {isPending ? '報名中' : '報名'} </button> <p>{message}</p> </form> ); }
|
第一次送出「台北城市漫遊」,等假 API 回應後訊息變成「已報名:台北城市漫遊」。再送出「花蓮山海三日」,訊息變成「已報名:台北城市漫遊、花蓮山海三日」。等待時按鈕停用、文字是「報名中」,每次送出後輸入框都會清空。
解析
- 第二個引數「尚未報名」是起始狀態,第一次動作的
previous 就是它。
- 回傳值成為下一次的
message,不需要 setState。
previous 是上一筆結果,不是輸入框裡的草稿,草稿在 FormData。
- 連續送出的動作會排隊,一次執行一個,後一個拿到前一個的結果。
- 預期內的錯誤(例如欄位驗證)要當成回傳值放進狀態;如果
send 丟出錯誤,會交給 Error Boundary,後面排隊的動作也會被取消。這一則的假 API 失敗時就會丟錯,教學用,沒有另外處理。
- 在
send 裡 await 之後才呼叫 setState,需要再包一層 startTransition(useActionState 文件列為目前的限制)。
按鈕、送出提示常被拆成獨立元件。這時元件不必從父層傳 isPending 進來,直接用 useFormStatus 讀它所在那張表單的狀態。
import { useFormStatus } from 'react-dom';
const { pending, data, method, action } = useFormStatus();
|
觀念
useFormStatus 只讀「外層」的 <form>:呼叫它的元件必須是 form 的子元件,寫在放 <form> 的同一個元件裡永遠讀到 false。因此送出按鈕獨立成 SubmitButton,放在 form 裡面。
03-react/src/demos/84b-form-status.jsximport { useFormStatus } from 'react-dom';
function SubmitButton() { const { pending } = useFormStatus(); return ( <button type="submit" disabled={pending} className="rounded bg-teal-800 px-3 py-1 text-white disabled:opacity-60" > {pending ? '送出中' : '送出'} </button> ); }
export default function FormStatusDemo() { const send = async () => { await new Promise((resolve) => setTimeout(resolve, 2000)); };
return ( <form action={send} className="grid max-w-sm gap-3"> <input name="title" className="rounded border px-2 py-1" placeholder="輸入任何文字" /> <SubmitButton /> </form> ); }
|
按下送出後,按鈕停用並顯示「送出中」,2 秒後恢復成「送出」,輸入框同時清空。
解析
SubmitButton 沒有任何 props,狀態來自外層的 form。
send 是 async 函式,React 以它是否結束判斷 pending。
- 想在同一個元件內自己用
isPending,改用 useActionState 第三個回傳值即可。
useOptimistic
動作還沒回來時,先把預期的結果畫出來,讓畫面不必等伺服器。真正的狀態仍在動作結束後才更新;動作結束或失敗時,樂觀的那一層就消失,回到實際的狀態。
const reducer = (current, optimistic) => { return next; };
const [optimisticState, setOptimistic] = useOptimistic(value, reducer);
|
觀念
setOptimistic 只能在 Action 裡呼叫,<form action> 的函式就是一個 Action,所以可以直接用。這一則直接用新的名稱取代舊的,所以省略 reducer。
送出時先 setOptimisticName,再等待,最後更新實際狀態。等待的 3 秒內畫面已經是新名稱。這裡故意不用假 API,因為它回得太快,看不出差別。await 之後的 setName 要包 startTransition,才會被視為同一筆 Transition,樂觀值與實際值在同一次畫面更新裡一起換成新值。
03-react/src/demos/85-optimistic.jsximport { startTransition, useOptimistic, useState } from 'react';
export default function OptimisticDemo() { const [name, setName] = useState('台北城市漫遊'); const [optimisticName, setOptimisticName] = useOptimistic(name);
const send = async (formData) => { const next = String(formData.get('name') || name); setOptimisticName(next); await new Promise((resolve) => setTimeout(resolve, 3000)); startTransition(() => setName(next)); };
return ( <form action={send} className="grid max-w-sm gap-3"> <p>旅程名稱 {optimisticName}</p> <input name="name" className="rounded border px-2 py-1" placeholder="新的旅程名稱" /> <button type="submit" className="rounded bg-teal-800 px-3 py-1 text-white" > 更新名稱 </button> </form> ); }
|
輸入「花蓮山海三日」並送出,畫面上的「旅程名稱」立刻變成花蓮山海三日,不必等 3 秒;3 秒後實際狀態跟上,畫面維持同一個名稱,輸入框同時清空。
解析
- 畫面讀
optimisticName,不直接讀 name,進行中時兩者可能不同。
- 動作結束後
name 變成新值,樂觀值與實際值就一致了。
- 樂觀值只在動作進行中存在。若永遠沒有更新實際狀態,動作一結束畫面就跳回舊名稱。
- 動作失敗時不要更新實際狀態,樂觀值就消失,畫面回到舊名稱;可以另用一個狀態顯示錯誤訊息。
- 實際專案要放回清單時,會用第二個引數 reducer 把預期項目併進清單。
useFormStatus 與 useActionState 的 isPending 都是「動作進行中」;useOptimistic 解決的是「進行中先顯示什麼」,三者可以同時用在同一張表單。
回家作業
這份作業只用必教內容,資料取自專案的行程清單。請在練習專案裡開啟,行程資料放在 public/data/tours.json,用 fetch('/data/tours.json') 讀取。課堂上不會批改,也不講解;每一題都附上完成後該看到的結果,可以自己對照。做完或卡住時,再看練習 repo 根目錄 homework/10-react-advanced/ 裡的標準答案。
起始檔
起始檔在練習專案的 03-react/src/homework/10-homework.jsx,在練習專案的選單裡切到「10 回家作業」就能看到。
03-react/src/homework/10-homework.jsx
export default function Homework10() { return <p>在這裡開始寫</p>; }
|
題目
題目一:讀取資料
元件載入時用 effect 讀取行程資料並顯示列表。讀取期間顯示「載入中」,失敗顯示「讀取失敗」,資料是空陣列時顯示「目前沒有行程」。
完成後第一次看到「載入中」,接著出現八筆行程;把路徑暫時改成不存在的檔案,畫面顯示「讀取失敗」。
題目二:共用的收藏
每筆行程旁有「收藏」按鈕。另外在同一個畫面放一個「收藏清單」元件,列出已收藏的行程,並且可以從清單移除。收藏的編號只放在共同的父層,兩個元件都透過 props 取得。
完成後在列表按收藏,清單立刻多一筆;在清單按移除,列表那筆的按鈕變回未收藏。
題目三:同步分頁標題
用 effect 讓瀏覽器分頁標題跟著收藏數量變化,例如「收藏 2 筆|洛奇旅行」。收藏數量沒有改變時,這個 effect 不應重新執行。
完成後每次收藏或移除,分頁標題的數字隨之改變。
題目四:重新整理後還在
收藏的編號要存進 localStorage,重新整理頁面後仍然保留。初始值從 localStorage 讀取,讀不到時用空陣列;儲存用的 key 是 homework10-favorites。
完成後收藏兩筆、重新整理,收藏清單仍有那兩筆。
題目五:避免不必要的 effect
檢查你寫的程式:「已收藏筆數」是不是用 effect 更新的另一個狀態?如果是,改成在渲染時直接由收藏陣列算出來。
完成後畫面行為不變,但程式裡沒有只為了算筆數而存在的 effect 與狀態。
本篇重點回顧
選讀的章節有:選讀:AbortController、選讀:遠端寫入、選讀:不需要 effect 的情況、選讀:自訂 Hook、選讀:useContext、選讀:React Compiler 與手動記憶化、選讀:useMemo、選讀:memo、選讀:useCallback、選讀:useRef、選讀:useReducer、選讀:表單 Actions。
- effect 的 setup 在畫面提交之後執行,用來跟計時器、讀取或訂閱這類外部系統對齊,語法是
useEffect(setup, deps)。
- 依賴陣列決定重跑時機:列出的值任何一個改變就重跑,空陣列只在第一次畫完後跑,省略則每次渲染之後都跑。
- 清除函式在下一次 setup 之前與元件離開畫面時執行,負責停掉計時器、取消訂閱與中止請求。
- 在 effect 裡設定狀態又讓它每次重跑會造成無限迴圈,漏寫依賴則會讓效果沿用舊值。
- 讀取資料要把載入中、失敗與沒有資料當成三種不同的畫面來處理,並用清除函式避免過期的回應蓋掉新結果。
- 畫面推得出來的值直接在渲染時算,按一次才要做的事放在事件裡,不必都交給 effect。
- 兩個以上的元件要讀同一份會變的資料時,把狀態提升到最近的共同父層,再用 props 往下傳。
- 兄弟元件之間不能直接溝通,由父層持有狀態,一邊透過傳下去的函式更新,另一邊就會拿到新值。
專有名詞中英對照
Effect 與資料
- 效果(effect)
- 依賴陣列(dependency array)
- 清除函式(cleanup)
- 準備函式(setup)
- 無限迴圈(infinite loop)
- 競態(race condition)
- 嚴格模式(Strict Mode)
- API 模組(API module)
- 自訂 Hook(custom Hook)
共用狀態
- 狀態提升(lifting state up)
- 單一資料來源(single source of truth)
- 屬性鑽孔(props drilling)
選讀:React Compiler 與手動記憶化
- 記憶化(memoization)
- 編譯器(React Compiler)
選讀:表單 Actions
- 動作(Action)
- 非受控(uncontrolled)
- 樂觀狀態(optimistic state)