KAKEHASHI Tech Blog

カケハシのEngineer Teamによるブログです。

Async React の設計思想と Signal の違いを Transition を中心に考える

こんにちは。フロントエンドエンジニアをしているNokogiri(@nkgrnkgr)です。

はじめに

私たちのReactをつかったプロダクトでは Suspense をデータフェッチに利用しています。useTransition や useOptimistic も触ったことはありましたが、プロダクションでどう活かすかという解像度がまだ上がっていませんでした。

そんなとき、uhyo さんの「React 19時代のコンポーネント設計ベストプラクティス」や「Async Reactとは何か」を読んで、Async React の全体像をちゃんと理解したくなりました。実際にコードを書きながら手を動かし、自分なりに解釈した内容を社内勉強会で共有する機会があったので、本記事ではその内容を整理してお伝えします。

Async React の全体像のうち、特に Transition を軸に「React は何をスケジューリングしているのか」を掘り下げます。社内には Angular エンジニアも多く、Angular をはじめ主要フレームワークが細粒度リアクティビティのために Signal を採用する中で「React はなぜ Signal を採用しないのか?」という問いが出てきたので、後半ではその対比にも踏み込みます。

Async React の世界観

React チームが提唱する Async React の世界観を一言で表すとこうなります。

UI = f(state)
↓
await UI = await f(await state)

UIのレンダリングは、状態の取得もレンダリングも全てが非同期プロセスである。

従来の React アプリでは、レンダリングサイクル(Event → Update → Render → Commit)の各段階に「隙間」があり、busy / loading / done といった非同期状態が生まれます。React チームはこれらをパフォーマンスの問題ではなく、調整(Coordination)の問題と位置づけています。

Async React は、この各段階の隙間を useOptimistic / Suspense / useTransition などの API で宣言的に埋める仕組みです。この全体像については「Async Reactとは何か」が詳しいのでそちらを参照ください。本記事ではこの中核にある Transition の概念を掘り下げます。

Transition — UI の更新には2種類ある

UI の更新には、即座に反映されないとストレスになるものと、少し遅れても許容できるものがあります。

例えばユーザーがテキストを入力するとき:

  • 入力フィールドの文字表示 → 即座に反映が必要(Urgent)
  • 検索結果のフィルタリング → 遅れても許容できる(Transition)

従来の React では両方が同じ優先度で処理されます。1万件のリストをフィルタリングする重い処理があると、入力フィールドまでフリーズしてしまう。

// 従来: 全てが同じ優先度
const handleChange = (e: ChangeEvent<HTMLInputElement>) => {
  const value = e.target.value;
  setText(value);                  // 入力の反映
  setFilteredList(filter(value));  // 重いフィルタリング ← これが入力をブロック
};

startTransition で「この更新は急がなくていい」と宣言します。

const [text, setText] = useState("");
const [deferredText, setDeferredText] = useState("");
const [isPending, startTransition] = useTransition();

const handleChange = (e: ChangeEvent<HTMLInputElement>) => {
  const v = e.target.value;
  setText(v);                       // urgent update: 即座に反映
  startTransition(() => {
    setDeferredText(v);             // transition: 低優先度で処理
  });
};

// deferredText が変わるまでフィルタリングは走らない
const filteredUsers = useMemo(() => {
  return filterUsers(allUsers, deferredText); // 1万件のフィルタリング
}, [deferredText]);

return (
  <>
    <Input value={text} onChange={handleChange} />
    <div className={isPending ? "opacity-50" : ""}>
      <MemorizedListComponent users={filteredUsers} />
    </div>
  </>
);

実際に動かすと違いがわかります。startTransition なしでは入力がカクカクになるのに対し、ありでは入力はスムーズなまま、リストだけが少し遅れて更新されます。isPending で「処理中」を opacity で表現できるのもいい。

Transition を利用したスムーズな入力

useTransitionを使ったスムーズな入力のGIF

従来通り Urgent な入力

従来通りUrgentな入力

React は startTransition で囲まれていない通常の state 更新(urgent update)を先に処理し、transition はバックグラウンドで実行する。途中でユーザーが新しい入力をすれば、進行中の transition は中断され最新の入力が優先されます。

ここで注意したいのは、Transition は throttle や debounce とは異なるアプローチだということです。throttle は「一定間隔で処理を間引く」、debounce は「入力が止まるまで処理を遅延させる」もので、どちらも処理の実行タイミングを時間で制御します。一方 Transition は「React が更新の優先度を理解して、スケジューリングする」仕組みです。時間ベースで間引くのではなく、どの更新を先に画面に反映するかを React が判断する。ここを理解したとき、Async React が目指していることが繋がった気がしました。

Suspense + Transition — 同じ Suspense でも挙動が変わる

Transition は、Suspense と組み合わせたときにさらに面白い挙動を見せます。

以下はタブ切り替えの例です。TabButton は内部で startTransition を使い、TabContent は use() で Promise を解いてデータを表示します。

const TabButton = ({ children, isActive, action }: TabButtonProps) => {
  const [isPending, startTransition] = useTransition();

  const handleClick = () => {
    startTransition(() => {
      action();
    });
  };

  return (
    <Button
      variant={isActive ? "primary" : "outline"}
      onClick={handleClick}
      disabled={isPending || isActive}
      isLoading={isPending}
    >
      {children}
    </Button>
  );
};

const TabContent = ({ dataPromise }: { dataPromise: Promise<User[]> }) => {
  const data = use(dataPromise);
  return (
    <List>
      {data.map((item) => (
        <List.Item key={item.id}>{item.name}</List.Item>
      ))}
    </List>
  );
};

const App = () => {
  const [selectedTab, setSelectedTab] = useState<TabId>("posts");
  const [dataPromise, setDataPromise] = useState(() => fetchTabData("posts"));

  const handleTabChange = (tabId: TabId) => {
    setSelectedTab(tabId);
    setDataPromise(fetchTabData(tabId));
  };

  return (
    <>
      <Flex gap="sm">
        {TABS.map((tab) => (
          <TabButton
            key={tab.id}
            isActive={selectedTab === tab.id}
            action={() => handleTabChange(tab.id)}
          >
            {tab.label}
          </TabButton>
        ))}
      </Flex>
      <Suspense fallback={<Spinner />}>
        <TabContent dataPromise={dataPromise} />
      </Suspense>
    </>
  );
};

ここで起きることを整理します。

startTransition なし(通常の setState)の場合:

タブBクリック → setTab('B')  ← urgent update
  → <TabContent /> をレンダリング → データ取得で suspend
  → Suspense が即座に fallback(Spinner)を表示
  → タブAの内容が消えて Spinner に置き換わる
  → データ取得完了 → タブBの内容が表示

結果:タブA → Spinner → タブB(ちらつく)

従来のSuspense(Spinnerが表示される)

startTransition あり(TabButton 経由)の場合:

タブBクリック → startTransition(() => setTab('B'))  ← transition
  → <TabContent /> をメモリ上でレンダリング → suspend
  → transition なので Suspense は fallback を出さない
  → タブAの内容がそのまま表示され続ける
  → データ取得完了 → タブAがタブBにスッと切り替わる

結果:タブA → タブB(Spinner が出ない)

startTransition を使ったスムーズなタブ切り替え

同じ <Suspense fallback={<Spinner />}> でも、中の state 更新が transition かどうかで挙動が変わります。

  • 初回マウント: 表示するものがないので fallback を出す(これは正しい)
  • transition 中の更新: 前の UI を維持し、準備ができたら切り替える

ここに React のスケジューリングの設計思想がよく表れていると感じました。「いつ fallback を出すか」すらも React が判断する。開発者は Suspense boundary を宣言するだけで、状況に応じた挙動を React が選んでくれます。

action prop パターン — Transition をデザインシステムに埋め込む

ここまでで Transition の挙動は理解できました。次に気になるのは「じゃあ全ての setState を startTransition で囲むべきなのか?」という点です。

uhyoさん が提唱している考え方があります。一部の例外を除き、全てのステート更新は Transition であることが望ましい。 それを実現するのが action prop パターンです。

// UIButton: action prop を受け取り、内部で startTransition でラップ
const UIButton = ({ children, action }: UIButtonProps) => {
  const [isPending, startTransition] = useTransition();

  const handleClick: MouseEventHandler = (e) => {
    startTransition(async () => {
      await action(e);
    });
  };

  return (
    <Button disabled={isPending} onClick={handleClick}>
      {children}
    </Button>
  );
};

// 親は「何をするか」だけ渡す。Transition を意識しない
<UIButton action={() => setTab('posts')}>Posts</UIButton>
<UIButton action={() => setTab('comments')}>Comments</UIButton>

親は「何をするか」を渡すだけ。ボタンが自動的に Transition でラップし、isPending も自己管理する。

命名規則として onClick ではなく action を使うことで、「この prop は Transition として実行される」という契約を型レベルで表現します。

このパターンをデザインシステムの基盤コンポーネントに組み込めば、アプリケーション全体で「最適化された UX が自動的に実現される」仕組みになります。個々の画面開発者が startTransition を意識しなくても、ボタンをクリックすれば自然と Transition が効く。前セクションで見た Suspense との連携も、action prop を使っていれば意識せずに手に入ります。

一方で、このパターンには課題もあります。isPending の状態が UIButton の内部に閉じるため、外側のコンポーネントから「今 transition 中かどうか」を知ることができません。ボタンだけが loading 表示になるのか、画面全体をグレーアウトするのか——pending 状態をどこにどう表示するかは、体験設計そのものの問題です。

本当にプロダクトに導入するかは、デザイナーを含めて議論していきたいところです。

Signal との対比 — 同じ問題への異なる解法

社内には Angular エンジニアも多く、「React の Transition って、Signal でいうところの何?」という疑問が自然と出てきました。調べていくと、これは単なる API の違いではなく、問題の捉え方そのものが違うということがわかってきました。

React: 全体を再評価して、スケジューリングで制御する

React は「富豪的プログラミング」を採用しています。state が変わるとコンポーネント全体を再評価し、仮想 DOM の差分比較でどこを更新するか決める。

const App = () => {
  const [count, setCount] = useState(0);
  return (
    <div>
      <p>{count}</p>           {/* count を使う */}
      <HeavyComponent />      {/* count と無関係だが再レンダリングされる */}
    </div>
  );
};

これは開発者にとって「何を表示したいか」だけ書けばいいという楽なモデルですが、パフォーマンス上の無駄があります。React はこの問題に対して2つの回答を用意しています。

  1. React Compiler: ビルド時に useMemo / useCallback 相当のコードを自動生成し、不要な再レンダリングを減らす。人間が手動でメモ化を書く必要がなくなる
  2. Transition: 「処理の優先順位」を制御し、重い処理があっても UI をブロックしない

Signal: 依存グラフで、変更箇所だけを更新する

Signal 側の考え方はシンプルです。「全体を再レンダリングして差分を取る」のではなく、変更箇所をピンポイントで特定すればよい、というアプローチです。

Signal は初回実行時に依存グラフを構築し、変更時にどこを更新するか自動的に特定します。

// Signal の概念(Solid.js 風の擬似コード)
const [count, setCount] = createSignal(0);
const doubled = createMemo(() => count() * 2);

// count が変わると:
// 1. doubled が再計算される(count に依存しているから)
// 2. DOM の count, doubled を表示している箇所だけが更新される
// 3. HeavyComponent は一切触られない

この仕組みでは仮想 DOM の差分比較もメモ化も必要ありません。「何が何に依存しているか」が依存グラフからわかるためです。

対比表: 更新の仕組み

観点 React Signal (Solid, Angular, Vue 等)
更新のメンタルモデル 「UIの全体像を宣言する」 「依存関係を定義する」
更新の単位 コンポーネント単位で再レンダリング 値が使われている箇所だけ更新
不要な再レンダリング Compiler が自動で防ぐ(ビルド時最適化) そもそも発生しない(ランタイム最適化)
仮想 DOM あり(差分比較で更新箇所を特定) なし(依存グラフで更新箇所が自明)

対比表: パフォーマンス戦略

課題 React の解法 Signal の解法
不要な再計算 React Compiler で自動メモ化 依存グラフで影響範囲外は計算しない
重い処理による UI ブロック Transition で優先度を分離 重い処理が影響範囲に含まれなければそもそも起きない
非同期データの待機中 UI Suspense + Transition で「いつ・何を表示するか」制御 各フレームワーク固有の実装に依存
開発者の負担 Compiler が最適化を自動化。開発者は宣言的に書くだけ 依存関係の定義が最適化を兼ねる。明示的だが学習コストあり

設計哲学の違い

ここが一番面白いと感じたところです。

Signal は「不要な処理を起こさない」ことで問題を解決します。依存グラフにより変更の影響範囲が自明にわかるため、そもそも無駄な再レンダリングが発生しません。問題を構造的に排除するアプローチです。

React は「処理は走るが、優先順位を制御する」ことで問題を解決します。全体を再評価するコストは Compiler が最適化し、残った重い処理は Transition でスケジューリングする。問題をスケジューリングで吸収するアプローチです。

React の設計思想を一言で言うと:

開発者は「何を更新するか」だけ書く。「いつ・どう更新するか」は React が判断する。

React はレンダリングのスケジューラーと捉えることができます。setState した結果がいつ画面に反映されるかは React が決める。開発者にとっては全ての処理が async になっていく世界です。

標準化の動き

Signal は TC39 Stage 1(2024年4月〜)として JavaScript の言語仕様への標準化が進んでいます。

フレームワーク Signal 採用状況
SolidJS 初期から fine-grained reactivity
Angular v16〜。Zone.js 脱却の中核技術
Vue 3 ref / reactive が Signal 相当
Preact @preact/signals で提供
React 不採用。Compiler + Transition で独自路線

Angular, Solid, Vue, Preact, Qwik など主要フレームワークの作者が設計に参加している一方、React チームは参加していません。React は Signal ではなく React Compiler の方向に進んでいます。

React 以外の主要フレームワークがほぼ全て Signal を採用する中で、React は独自路線を歩んでいます。どちらが正しいかはまだわかりませんが、フロントエンドエンジニアとして両方の思想を理解しておくことは、技術選択の幅を広げてくれると感じました。

まとめ

Transition を軸に Async React を掘り下げ、Signal との対比を通じて React の設計思想を整理しました。

  • Transition は React のスケジューリング戦略の中核。「急がなくていい更新」を宣言することで、UI の応答性を維持する
  • Suspense + Transition の組み合わせで、初回ロード時はフォールバックを出し、以降の更新では前の UI を維持するという使い分けが自動的に行われる
  • action prop パターン で Transition をコンポーネントに埋め込むことで、「最適化が自動で起こる」デザインシステムが実現できる
  • Signal は依存グラフで不要な処理を構造的に排除するアプローチ。React はスケジューリングで吸収するアプローチ。問題の捉え方そのものが違う

React はレンダリングのスケジューラーである——Transition を通じて、そう捉えられるようになりました。

プロダクトでは Suspense は既に活用していますが、Transition や action prop パターンの導入はまだこれからです。特にデザインシステムへの組み込みは、アプリケーション全体の UX を底上げできる可能性を感じています。実際のプロダクトでどう活かしていくかは、今後チームで広く議論していきたいと考えています。

補足: Copilot をオフにして学んだ話

今回の学習では、意識的に Copilot をオフにしてコードを書きました。

学習の進め方はこうです。まず参考資料のリンクを Gemini に渡し、Async React の学習ガイドを作ってもらいました。そのガイドに沿って出題される問題を自分で解いていく中で、理解の解像度が上がっていきました。

ただ、Copilot をオンにしていると、自分で考える前にコードが補完されてしまい、学習になりません。コードを書くフェーズまで AI に任せると「わかった気」で終わってしまう。自分でエディタに向かってコードを打ち、エラーを出し、直す。このサイクルを回すことで、理解が定着すると感じています。

AI にガイドを作ってもらい、手を動かすのは自分。 この使い分けが、今のところ一番しっくりくる学び方です。

参考資料