ホーム>React>React Hooks(フック)とは?一覧と使い方を、動かした結果で確かめる(useState・useEffectほか)
React

React Hooks(フック)とは?一覧と使い方を、動かした結果で確かめる(useState・useEffectほか)

いつもご利用ありがとうございます。
この記事にはアフィリエイト広告を含む広告が掲載されており、その広告費によって運営しています。
Amazonのアソシエイトとして、ララテックは適格販売により収入を得ています。

React Hooks(フック)とは何かと、組み込みのフック18個の一覧、よく使うuseState・useReducer・useContext・useRef・useEffect・useMemo・useCallback・useIdと自作フックの使い方をまとめました。setCountを3回呼んだ結果、useEffectが動く順番とクリーンアップ、useMemo・useCallbackで減った回数、フックのルールを破ったときのエラーを、React 19.3で実際に動かした結果つきで書いています。

React Hooks(フック)は、関数コンポーネントの中から、state や副作用などの React の機能を使うための関数です。

useState・useEffect のように、名前が use で始まります。

この記事では、組み込みのフックの一覧と、よく使うフックの最小の例をまとめています。

説明だけだと「結局どう動くの?」となりがちなので、それぞれテストで動かして、回数や順番を数えた結果を載せました。

⇨ React 記事の目次はこちら

確かめた環境

2026年11月に、Docker の node:22 のコンテナで、npm create vite@latest の React のテンプレートから作ったプロジェクトで確かめました。

Node.js 22.23.5
react 19.3.1 / react-dom 19.3.1
vite 8.3.8
vitest 5.1.1
@testing-library/react 16.3.3
@testing-library/user-event 14.6.12
jsdom 31.0.1
oxlint 1.94.0(テンプレートに入っていたもの)

画面の確認は Chromium 156 です。

テストは12件で、すべて通りました。

 Test Files  1 passed (1)
      Tests  12 passed (12)

Vite の React のプロジェクトの作り方は、Vite+Reactの環境構築に書いています。

組み込みのフック18個の一覧

React の公式ドキュメントのフックのページには、次の18個が載っています(2026年11月に確認)。

Built-in React Hooks(react.dev)

分類フック何をするか
StateuseState直接更新できる state を持つ
StateuseReducer更新の処理を reducer 関数にまとめた state を持つ
StateuseOptimistic非同期の処理の途中に、仮の state を表示する
ContextuseContextContext の値を読む
RefuseRef再描画に関係しない値や DOM の要素を持つ
RefuseImperativeHandle親に渡す ref の中身を決める(まれに使う)
EffectuseEffect外部のシステムと同期する(副作用)
EffectuseLayoutEffect画面に描かれる前に動く(まれに使う)
EffectuseInsertionEffectDOM の変更の前に CSS を差し込む(ライブラリ向け)
EffectuseEffectEventEffect から呼ぶ、依存配列に入れなくてよい関数を作る
PerformanceuseMemo重い計算の結果をキャッシュする
PerformanceuseCallback関数をキャッシュする
PerformanceuseTransitionstate の更新を急がないものとして扱う
PerformanceuseDeferredValue急がない部分の表示を後回しにする
OtheruseDebugValueReact DevTools に出るラベルを決める
OtheruseId一意な ID を作る
OtheruseSyncExternalStoreReact の外のストアを購読する
OtheruseActionStateアクション(フォームの送信など)の state を扱う

この記事では、このうち useState・useReducer・useContext・useRef・useEffect・useMemo・useCallback・useId の8個と、自作のフックを動かしました。

useState:値で3回と関数で3回の違い

useState は、コンポーネントに state(変わる値)を持たせるフックです。

[今の値, 更新する関数] の2つを返し、更新する関数を呼ぶと再描画されます。

import { useState } from 'react'

export function Counter() {
  const [count, setCount] = useState(0)

  return (
    <div>
      <p>カウント: {count}</p>
      <button onClick={() => setCount(count + 1)}>+1</button>
      <button
        onClick={() => {
          setCount(count + 1)
          setCount(count + 1)
          setCount(count + 1)
        }}
      >
        値で3回
      </button>
      <button
        onClick={() => {
          setCount((c) => c + 1)
          setCount((c) => c + 1)
          setCount((c) => c + 1)
        }}
      >
        関数で3回
      </button>
    </div>
  )
}

0 の状態で「値で3回」を押すと、3 ではなく 1 になりました。

「値で3回」を押した後の画面。カウント: 1 と表示されている

続けて「関数で3回」を押すと、1 から 4 になりました。

続けて「関数で3回」を押した後の画面。カウント: 4 と表示されている

テストでも同じ結果でした。

await userEvent.click(screen.getByText('値で3回'))
expect(screen.getByText(/カウント/).textContent).toBe('カウント: 1')
await userEvent.click(screen.getByText('関数で3回'))
expect(screen.getByText(/カウント/).textContent).toBe('カウント: 4')

setCount(count + 1) の count は、押した時点の値(0)のままなので、3回とも「1 にする」になります。

前の値をもとに更新したいときは、setCount((c) => c + 1) のように関数で渡すと、1回ずつ積み上がります。

useReducer:更新の処理を1か所にまとめる

useReducer は、state の変え方を reducer 関数にまとめるフックです。

「追加」「空にする」のように更新の種類が増えてきたら、useState より読みやすくなります。

import { useReducer } from 'react'

function cartReducer(state, action) {
  switch (action.type) {
    case 'add':
      return { ...state, items: state.items + 1 }
    case 'clear':
      return { ...state, items: 0 }
    default:
      throw new Error('知らない action: ' + action.type)
  }
}

export function Cart() {
  const [state, dispatch] = useReducer(cartReducer, { items: 0 })

  return (
    <div>
      <p>カートの中: {state.items}個</p>
      <button onClick={() => dispatch({ type: 'add' })}>追加</button>
      <button onClick={() => dispatch({ type: 'clear' })}>空にする</button>
    </div>
  )
}

「追加」を2回押すと カートの中: 2個、「空にする」で カートの中: 0個 になりました。

useContext:propsを渡さずに値を読む

useContext は、createContext で作った Context の値を読むフックです。

親から子へ props を何段も渡さなくても、離れたコンポーネントで同じ値を読めます。

import { createContext, useContext } from 'react'

export const ThemeContext = createContext('light')

export function ThemeLabel() {
  const theme = useContext(ThemeContext)
  return <p>テーマ: {theme}</p>
}
<>
  <ThemeContext value="dark">
    <ThemeLabel />
  </ThemeContext>
  <ThemeLabel />
</>

React 19.3.1 で表示すると、囲んだほうは テーマ: dark、囲んでいないほうは createContext に渡した既定値の テーマ: light になりました。

React 19 では <ThemeContext value="dark"> のように Context をそのまま書けて、19.3.1 でもこの書き方で動きました。

古い記事でよく見る <ThemeContext.Provider value="dark"> は、React 18 までの書き方です。

useRef:変えても再描画されない値

useRef は、{ current: 値 } という箱を返すフックです。

DOM の要素をつかむときと、再描画に関係しない値を持っておくときに使います。

import { useRef, useState } from 'react'

export function FocusInput() {
  const inputRef = useRef(null)
  const clicks = useRef(0)
  const renders = useRef(0)
  const [, force] = useState(0)
  renders.current += 1

  return (
    <div>
      <input ref={inputRef} aria-label="名前" />
      <button onClick={() => inputRef.current.focus()}>入力欄へ</button>
      <button onClick={() => (clicks.current += 1)}>ref を増やす</button>
      <p>描画 {renders.current} 回 / ref の値 {clicks.current}</p>
      <button onClick={() => force((n) => n + 1)}>再描画</button>
    </div>
  )
}

「入力欄へ」を押すと、入力欄にフォーカスが移りました。

「ref を増やす」を3回押しても、表示は変わりませんでした。

ref を3回増やした後: 描画 1 回 / ref の値 0
state で再描画した後: 描画 2 回 / ref の値 3

ref の値は3まで増えていましたが、ref を変えても再描画は起きないので、画面は古いままです。

state の更新で再描画したところで、やっと 3 が表示されました。

画面に出す値は state、画面に関係しない値(タイマーの ID など)は ref、と分けると混乱しにくいです。

useEffect:依存配列ごとに動くタイミングを数えた

useEffect は、描画の後に処理を動かすフックです。

データの取得、タイマー、イベントの登録など、React の外とやりとりする処理を書きます。

2つ目の引数(依存配列)の書き方で、動くタイミングが変わります。

import { useEffect, useState } from 'react'

export function EffectLog({ userId, log }) {
  const [, setTick] = useState(0)

  useEffect(() => {
    log('依存配列なし')
  })

  useEffect(() => {
    log('[]')
    return () => log('[] のクリーンアップ')
  }, [])

  useEffect(() => {
    log('[userId] ' + userId)
    return () => log('[userId] のクリーンアップ ' + userId)
  }, [userId])

  return <button onClick={() => setTick((t) => t + 1)}>再描画</button>
}

描画のたびに、どの Effect が動いたかを記録した結果です。

1回目の描画: [ '依存配列なし', '[]', '[userId] 1' ]
state で再描画: [ '依存配列なし' ]
userId を 2 に: [ '[userId] のクリーンアップ 1', '依存配列なし', '[userId] 2' ]
アンマウント: [ '[] のクリーンアップ', '[userId] のクリーンアップ 2' ]
依存配列動いたとき
なし毎回の描画の後
[]最初の1回だけ(クリーンアップは消えるとき)
[userId]最初と、userId が変わったとき

userId が変わったときは、先に前の値(1)のクリーンアップが動いてから、新しい値(2)で動きました。

前のユーザーの購読を止めてから次のユーザーを購読する、のような処理をこの形で書けます。

StrictModeでは開発中に2回動く

Vite のテンプレートの main.jsx は、<StrictMode> で全体を囲んでいます。

同じコンポーネントを StrictMode で囲んで表示すると、最初の描画で Effect が一度動き、クリーンアップされて、もう一度動きました。

StrictMode の1回目の描画: [
  '依存配列なし',
  '[]',
  '[userId] 1',
  '[] のクリーンアップ',
  '[userId] のクリーンアップ 1',
  '依存配列なし',
  '[]',
  '[userId] 1'
]

開発中に「useEffect が2回動く!」となるのはこれです(;´Д`)

クリーンアップを正しく書いていれば、2回動いても結果は同じになる、というのが React の考え方です。

公式ドキュメントによると、この2回目の実行は開発中だけで、本番のビルドでは起きないとのことです。

useEffect(react.dev)

useMemo:関係ない再描画で計算し直さない

useMemo は、計算の結果をキャッシュするフックです。

依存配列の値が変わらない間は、前の結果をそのまま使います。

import { useMemo, useState } from 'react'

export function FilteredList({ items, onFilter }) {
  const [keyword, setKeyword] = useState('')
  const [dark, setDark] = useState(false)

  const filtered = useMemo(() => {
    onFilter() // 計算した回数を数える
    return items.filter((item) => item.includes(keyword))
  }, [items, keyword])

  return (
    <div className={dark ? 'dark' : ''}>
      <input aria-label="絞り込み" value={keyword} onChange={(e) => setKeyword(e.target.value)} />
      <button onClick={() => setDark(!dark)}>色を切り替え</button>
      <p>{filtered.length}件</p>
    </div>
  )
}

['react', 'redux', 'vue'] を渡して、絞り込みの計算が何回動いたかを数えました。

最初: 1
色を2回切り替えた後: 1
re と入力した後: 3 2件

「色を切り替え」で2回再描画されても、keyword が変わっていないので計算は1回のままでした。

re と入力すると、r と e の1文字ずつで2回計算し直して3回になり、react と redux の2件に絞り込まれました。

useCallback:memoの子の再描画を減らす

useCallback は、関数そのものをキャッシュするフックです。

単体ではあまり意味がなく、memo で囲んだ子コンポーネントに関数を渡すときに効きます。

import { memo, useCallback, useState } from 'react'

const Child = memo(function Child({ onClick, onRender }) {
  onRender() // 描画された回数を数える
  return <button onClick={onClick}>子のボタン</button>
})

export function Parent({ useCb, onChildRender }) {
  const [count, setCount] = useState(0)
  const plain = () => {}
  const cached = useCallback(() => {}, [])

  return (
    <div>
      <button onClick={() => setCount(count + 1)}>親を再描画 {count}</button>
      <Child onClick={useCb ? cached : plain} onRender={onChildRender} />
    </div>
  )
}

親を3回再描画したときの、子の描画の回数です。

useCallback なし: 子の描画 4 回
useCallback あり: 子の描画 1 回

useCallback がないと、親が描画されるたびに () => {} が新しい関数として作られるので、memo していても子は毎回描画されました(最初の1回+3回)。

useCallback で同じ関数を渡すと、子は最初の1回だけになりました。

useId:ラベルと入力欄をつなぐID

useId は、コンポーネントごとに一意な ID を作るフックです。

<label htmlFor> と <input id> をつなぐときに使います。

import { useId } from 'react'

export function EmailField() {
  const id = useId()
  return (
    <div>
      <label htmlFor={id}>メール</label>
      <input id={id} type="email" />
    </div>
  )
}

同じコンポーネントを2つ並べて renderToString で HTML にすると、別々の ID になりました。

<div><label for="_R_1_">メール</label><input id="_R_1_" type="email"/></div><div><label for="_R_2_">メール</label><input id="_R_2_" type="email"/></div>

id="email" と決め打ちすると、同じ部品を2つ置いたときに ID がかぶりますが、useId ならその心配がありません。

自作のフック(カスタムフック)

フックを組み合わせて、自分のフックを作ることもできます。

名前を use で始めた関数の中で、ほかのフックを呼ぶだけです。

import { useCallback, useState } from 'react'

export function useToggle(initial = false) {
  const [on, setOn] = useState(initial)
  const toggle = useCallback(() => setOn((v) => !v), [])
  return [on, toggle]
}

export function MenuButton() {
  const [open, toggle] = useToggle()
  return (
    <div>
      <button onClick={toggle}>メニュー</button>
      {open && <ul><li>設定</li></ul>}
    </div>
  )
}

最初は「設定」が出ておらず、「メニュー」を1回押すと出ました。

ライブラリのフックも同じ仕組みで、たとえば React Hook Form の useForm もフックの1つです(React Hook Formの使い方)。

フックのルールを破ったときのエラー

フックには「コンポーネント(か自作のフック)の一番上で、毎回同じ順番で呼ぶ」というルールがあります。

if の中でフックを呼ぶと、どうなるのか試しました。

import { useEffect, useState } from 'react'

// フックのルールを破った例: if の中でフックを呼ぶ
export function BadProfile({ loggedIn }) {
  const [name, setName] = useState('ゲスト')

  if (loggedIn) {
    const [point] = useState(100)
    useEffect(() => {
      document.title = point + 'pt'
    })
  }

  const [theme] = useState('light')

  return (
    <p onClick={() => setName('たろう')}>
      {name} / {theme}
    </p>
  )
}

oxlintで書いた時点で分かる

今の Vite の React のテンプレートには、ESLint ではなく oxlint が入っていて、設定(.oxlintrc.json)で react/rules-of-hooks が error になっていました。

このファイルに oxlint をかけると、2つのエラーが出ました(1つ目を載せます)。

  x react-hooks(rules-of-hooks): React Hook "useState" is called conditionally. React Hooks must be called in the exact same order in every component render.
   ,-[src/hooks/Bad.jsx:8:21]
 6 |
 7 |   if (loggedIn) {
   :       ^^^^|^^^
   :           `-- When this condition is false, this Hook is skipped.
 8 |     const [point] = useState(100)
   :                     ^^^^^^|^^^^^^
   :                           `-- This Hook call is not reachable on every render path.
 9 |     useEffect(() => {
   `----
  help: Move the Hook call before the condition, or call it unconditionally and branch inside the Hook/effect instead.

Found 0 warnings and 2 errors.

npm run lint で確かめられるので、フックを書き始めたら一度かけておくと安心です。

実行すると条件が変わったときに落ちる

lint を無視して動かすと、loggedIn={false} で最初に表示したときはエラーになりませんでした。

その後 loggedIn={true} に変えて描画し直したところで、次のエラーになりました。

Rendered more hooks than during the previous render.

コンソールには、フックの順番が変わったという次のエラーも出ました(テストで受け取ったままの形で載せています。%s は書式の指定です)。

React has detected a change in the order of Hooks called by %s. This will lead to bugs and errors if not fixed. For more information, read the Rules of Hooks: https://react.dev/link/rules-of-hooks

React は、フックを「何番目に呼ばれたか」で見分けているので、途中で数が変わると前の描画と対応が取れなくなります。

最初の表示では動いてしまうので、条件が変わるまで気づけないのがやっかいです。

参考:この記事で動かしていないフック

useTransition は、重い画面の切り替えなどの state の更新を「急がないもの」として扱い、入力などのほかの更新を先に処理させるためのフックとのことです。

useTransition(react.dev)

useDeferredValue は、値の更新を遅らせて、入力欄は先に反映し、重い一覧は後から追いつかせる、といった使い方ができるようです。

useDeferredValue(react.dev)

useActionState と useOptimistic は、フォームの送信などのアクションと組み合わせて使うフックで、送信中の状態や、サーバーの返事を待たずに仮の結果を表示するのに使うとのことです。

useActionState(react.dev)

useEffectEvent は、Effect の中から呼ぶけれど、依存配列に入れたくない処理を切り出すためのフックとのことです。

useEffectEvent(react.dev)

useLayoutEffect は、画面に描かれる前に要素の大きさを測るときなどに使うもので、公式ドキュメントでは、性能に影響するため多くの場合は useEffect を使うよう書かれています。

useLayoutEffect(react.dev)

React 19 からある use は、Promise や Context を読むための API で、公式ドキュメントではフックの一覧ではなく API として載っています。

if の中でも呼べる点が、ほかのフックと違うとのことです。

use(react.dev)

まとめ

React Hooks は、関数コンポーネントで state や副作用を使うための、use で始まる関数です。

  • 画面に出す値は useState、更新の種類が多ければ useReducer
  • 離れたコンポーネントで値を共有するなら useContext
  • 画面に関係ない値と DOM は useRef
  • React の外とのやりとりは useEffect(クリーンアップも書く)
  • 再計算や再描画が気になったら useMemo・useCallback
  • フックは一番上で、毎回同じ順番で呼ぶ

「値で3回呼んでも1しか増えない」「開発中は useEffect が2回動く」あたりは、知らないとハマりやすいところでした。

React そのものの仕組みは Reactとは?、手を動かして覚えたいときは React入門チュートリアル もどうぞ!

フィードバックのお願い
この記事のフィードバックがありましたらYoutubeの適当な動画にコメントしていただいたり、お問い合わせからご連絡ください。