useRefの2つの用途 — 中身がnullで落ちる

useRefの2つの用途。カーソルのある入力欄とrefの箱、ノートパソコン。

React を触り始めて、最初に「調べても分からない」と思ったのが useRef でした。

前回: useMemoとuseCallback — 付けるほど遅くなる

これは深掘りです。本線の順路ではありません。 本線のコンポーネントとpropsの回で state まで進んだ人が、「入力欄に自動でカーソルを当てたい」「スクロール位置を動かしたい」と思った瞬間に、React でのやり方が分からなくなったときに読む記事です。飛ばしても本線は進みます。

この記事のコマンドは、すべて VM(Ubuntu Server)の中で打ちます。 Windows の PowerShell ではありません。 画面の確認は、ホストの Windows のブラウザで行います。 本線で作った ~/react-demo/ には触りません。 この記事では、まっさらな ~/reactlab/ を新しく作り、ポート 5178番で動かします。

理由は、あとになって分かりました。検索して出てくる記事が、2種類あったからです。

読んだ記事A読んだ記事B
「useRef は DOM要素を掴むためのフックです」「useRef は 再描画されない変数を持つためのフックです」
<input ref={inputRef} /> と書くref.current に数値を入れる
話の中心は HTML の要素話の中心は 値の保存

どちらも正しいのに、書いてあることが重ならない。 「DOMを掴む道具」だと思って読み進めると、急に「タイマーIDを入れます」という話が始まって、置いていかれる。

useRef は、名前が1つなのに、まったく違う2つの用途に使われています。 この2つを分けずに覚えようとすると、どちらも分からなくなります。 私はそうなりました。

さらに悪いことに、この2つは「よく分からないけど動く」で通り抜けられてしまいます。 そして、あとで必ず2種類の事故を起こします。

  1. inputRef.current.focus() と書いたら Cannot read properties of null で画面が真っ白になった
  2. カウントを useRef に入れたら、値は増えているのに画面の数字だけ 0 のままになった

この記事では、その2つを、わざと自分の手で起こします。 エラーを避けて通ると、次に出たときも読めないからです。

対象レベル: 中級〜上級 / 区分: 発展

目次

この記事でわかること

  • useRef には、まったく違う2つの用途があること。「DOMへの参照」と「再描画を起こさない箱」で、共通しているのは「React の管理の外に置く」という一点だけであること
  • ref.current は、レンダー中には必ず null であること。要素が入るのは画面に置いたあとなので、関数の本体で触ると必ず落ちる
  • useRef に入れた値を変えても、画面は絶対に更新されないこと。バグではなく、それが useRef の存在理由であること
  • DOM を直接触ってよいのは「React が管理していない操作」だけであること。フォーカス・スクロール・再生・サイズ測定はよくて、表示内容の書き換えは駄目な理由
  • ref は React 18 以前は props ではなかった(19 からは props として渡る)こと。子コンポーネントに ref を渡す方法が React 19 の前後で変わっているので、自分が使っている版を確かめないと、動かない記事を読むことになる
  • 要素がついた瞬間に何かしたいときは、useEffect より「コールバック ref」のほうが確実であること
  • useRef / useState / useMemo は、迷ったら「その値は画面に出るか」の一問で選べること

この記事でやること

  1. ~/reactlab/ を新しく作り、ポート 5178番で起動する
  2. 入力欄にフォーカスを当てるコードを、わざとレンダー中に書いて null を踏んでから、useEffect に移して直す
  3. スクロール位置の移動・要素サイズの測定を実装して、DOM を触ってよい範囲の線を引く
  4. 同じカウンターを useState 版と useRef 版で並べて作り、片方だけ画面が更新されないところを見る
  5. ref を子コンポーネントに渡し、自分の React のバージョンを確認したうえで正しい書き方を選ぶ
  6. コールバック ref で、要素がついた瞬間に高さを測る
  7. 練習場を片づける

先に知る言葉

この記事で初めて出てくる言葉です。 基本的な言葉は用語集にもまとめてあります。

言葉意味
ref(レフ)reference(参照)の略。「あとで直接触りたいもの」への取っ手。React が中身を見張らない箱
currentref の中身が入っている場所。useRef が返すのは箱そのもので、中身は必ず .current の中にある
DOM要素ブラウザが実際に画面に置いている <input> などの実体(DOMの回)
マウント(mount)コンポーネントが初めて実際の DOM に置かれること。ref に要素が入るのはこの瞬間
アンマウント(unmount)逆に、DOM から取り除かれること。ref の中身は null に戻される
フォーカスキーボード入力を今どの要素が受け取っているか。カーソルが点滅している入力欄のこと
forwardRef親から受け取った ref を、子コンポーネントの中の要素へ転送するための古い書き方
コールバック refref にオブジェクトではなく関数を渡す書き方。要素がついた瞬間・外れた瞬間に呼ばれる

① 準備 — reactlab を作る

本線で作った ~/react-demo/ は、そのまま残します。 この記事はわざとエラーを出す手順を含むので、別のプロジェクトでやります。

VM の中で打ちます。

bash
$ cd ~
$ npm create vite@latest reactlab -- --template react

「このまま依存を入れて起動しますか」と聞かれたら No(n)を選んでください。ポートを自分で決めたいからです。

bash
$ cd ~/reactlab
$ npm install
$ ls
eslint.config.js  index.html  package.json  public  README.md  src  vite.config.js

この一覧が出れば成功です。 npm install は初回だけ数分かかります(npmの回)。

自分の React のバージョンを、いま確認しておく

この記事の⑤で、バージョンによって書き方が変わる場面が出てきます。 先に見ておきます。

bash
$ npm ls react
reactlab@0.0.0 /home/user/reactlab
└─┬ react@19.2.0
  └── react@19.2.0 deduped

先頭の数字(この例では 19)をメモしておいてください。 18 と 19 で、⑤の正解が変わります。

ポートを開ける

本線で 5173番、他の深掘りで 5174〜5177番を使っています。 ぶつからないように、この記事は 5178番でやります。

bash
$ sudo ufw allow 5178/tcp
$ sudo ufw status
Status: active

To                         Action      From
--                         ------      ----
22/tcp                     ALLOW       Anywhere
5173/tcp                   ALLOW       Anywhere
5178/tcp                   ALLOW       Anywhere

5178/tcp の行が出れば準備完了です。開けずに起動すると、ターミナルには「起動しました」と出るのに、ブラウザは読み込み中のままになります(ネットワークの回)。

起動する

bash
$ npm run dev -- --host 0.0.0.0 --port 5178

ホストの Windows のブラウザで http://192.168.226.50:5178/ を開きます(IPは自分の値に。分からなければ VM の中で ip a)。Vite のロゴとカウンターが出れば成功です。

[スクリーンショット: 01_reactlab起動5178.png] ホストのブラウザで :5178 を開き、Vite + React の初期画面が出ているところを撮ってください。アドレスバーのポート番号が 5178 になっているのが見える形で。

止め方: ターミナルで Ctrl+C。この記事の間は起動したままで構いません。 保存するたびにブラウザが自動で更新されます。

編集は VS Code から VM を開いて行います(VS Code Remote の回)。

コンソールを開けたままにする

この記事は、わざとエラーを出します。 ホストのブラウザで F12 を押して、Console タブを出したままにしてください(開発者ツールの回)。


② 先に、2つの用途を切り離す

手を動かす前に、これだけは表で頭に入れてください。 ここが混ざると、以降の全部が分からなくなります。

① DOMへの参照② 再描画を起こさない箱
書き方<input ref={inputRef} /> とJSXに渡すref.current = 値 と自分で入れる
中身を入れるのは誰かReact(画面に置いたときに自動で入れる)自分(React は一切触らない)
中身の型DOM要素(<input> の実体)か null何でもいい(数値・ID・オブジェクト)
最初の値必ず null(まだ画面に無いから)useRef(0) などで自分が決めた値
何のために使うかフォーカス・スクロール・再生・サイズ測定タイマーID・直前の値・初回かどうかの目印
画面は更新されるかされないされない

共通しているのは、いちばん下の行だけです。

useRef の本質は「React に見張らせない場所を1つ作ること」です。 React は .current の変化に興味がありません。 中身が変わっても、再描画は起きません。 ①と②は、その性質を、まったく別の目的で使っているだけです。

useState と比べると、違いは一行で言えます。

中身を変えたら描画をまたいで残るか
useState再描画される残る
useRef何も起きない残る
ただの変数(let x = 0)何も起きない残らない(描画のたびに 0 に戻る)

「残るけれど、画面は動かさない」という、useState とただの変数の中間が useRef です。


③ DOMを直接触る

まず①の用途です。 一番よく使うのは、入力欄にカーソルを当てる(フォーカス) です。

src/App.jsx を、まるごとこれに置き換えます。

import { useRef } from 'react'

export default function App() {
  const inputRef = useRef(null)

  function handleClick() {
    console.log('current の中身:', inputRef.current)
    inputRef.current.focus()
  }

  return (
    <div style={{ padding: 24 }}>
      <h1>useRef の練習</h1>
      <input ref={inputRef} placeholder="ここにカーソルが来る" />
      <button onClick={handleClick}>入力欄にカーソルを当てる</button>
    </div>
  )
}

ブラウザでボタンを押してください。 入力欄のカーソルが点滅すれば成功です。

コンソールにはこう出ます。

current の中身: <input placeholder="ここにカーソルが来る">

ここで一度、目で確かめてほしいことがあります。 inputRef.current の中身は、React の何かではありません。 ブラウザが持っている <input> そのものです。だから focus() というDOMのメソッドがそのまま呼べます(DOMの回でやった document.querySelector の戻り値と、まったく同じものです)。

[スクリーンショット: 02_focus成功とconsole.png] ボタンを押して入力欄にカーソルが当たった状態と、コンソールに <input ...> が出ているところを、1枚に入れて撮ってください。

描画の前は null — 実際に踏む

次が、この記事でいちばん大事なところです。

「ページを開いた瞬間から、入力欄にカーソルが当たっていてほしい」 と考えたとします。ボタンを待たずに、最初に呼べばいい。 そう思って、関数の本体に直接書きます。

App の中に、この1行を足してください。 これは、わざと壊すコードです。

export default function App() {
  const inputRef = useRef(null)

  inputRef.current.focus()   // ⚠️ わざと壊す

  // 以下はそのまま

保存すると、画面が真っ白になり、コンソールに赤い文字が出ます。

TypeError: Cannot read properties of null (reading 'focus')

[スクリーンショット: 03_nullエラー.png] 画面が真っ白になり、コンソールに Cannot read properties of null が出ているところを撮ってください。

このエラーは、DOMの回で見たものと文面がまったく同じです。 原因も同じです。

まだ画面に置かれていないものを、掴もうとした。

順番を、時系列で並べます。ここを一度読めば、二度と踏みません。

順番起きることinputRef.current の中身
1useRef(null) が箱を作るnull(自分で入れた初期値)
2App の関数本体が動く(レンダー)null のまま
3返された JSX から、React が実際の DOM を作るnull
4DOM を画面に置く(マウント)。React が ref に要素を入れる<input>
5useEffect が動く<input>
6ボタンが押される<input>

2 の時点で触ったから落ちました。 要素が入るのは 4 です。 レンダー中は、まだ画面に何も無いのだから、null なのが当たり前です。

直します。さっき足した1行を消して、代わりにこう書きます。

import { useEffect, useRef } from 'react'

export default function App() {
  const inputRef = useRef(null)

  useEffect(() => {
    inputRef.current.focus()
  }, [])

  function handleClick() {
    inputRef.current.focus()
  }

  return (
    <div style={{ padding: 24 }}>
      <h1>useRef の練習</h1>
      <input ref={inputRef} placeholder="ここにカーソルが来る" />
      <button onClick={handleClick}>入力欄にカーソルを当てる</button>
    </div>
  )
}

保存すると、リロードした瞬間からカーソルが点滅しています。

useEffect は「画面に置いたあと」に動きます(useEffectの回)。だから ref の中身がある。 useEffect は多用するものではありませんが、ref を触るというのは、数少ない「本当に React の外を触る」用事です。

覚え方はこれで足ります。 ref.current を触っていいのは、useEffect の中か、イベントハンドラの中だけ。 レンダー中(関数の本体)で触ってはいけません。

他に何ができるのか

フォーカス以外も、同じ形で書けます。 App.jsx を置き換えて、3つ並べます。

import { useRef } from 'react'

export default function App() {
  const bottomRef = useRef(null)
  const videoRef = useRef(null)
  const boxRef = useRef(null)

  function scrollToBottom() {
    bottomRef.current.scrollIntoView({ behavior: 'smooth' })
  }

  function togglePlay() {
    const v = videoRef.current
    if (v.paused) v.play()
    else v.pause()
  }

  function measure() {
    const rect = boxRef.current.getBoundingClientRect()
    console.log('幅:', Math.round(rect.width), '高さ:', Math.round(rect.height))
  }

  return (
    <div style={{ padding: 24 }}>
      <button onClick={scrollToBottom}>一番下へスクロール</button>
      <button onClick={togglePlay}>動画を再生/停止</button>
      <button onClick={measure}>この箱のサイズを測る</button>

      <div ref={boxRef} style={{ background: '#eee', padding: 16, marginTop: 12 }}>
        サイズを測る対象の箱。ブラウザの幅を変えて、もう一度測ってみてください。
      </div>

      <video ref={videoRef} width="320" src="/sample.mp4" />

      <div style={{ height: '150vh' }} />
      <p ref={bottomRef}>ここが一番下です。</p>
    </div>
  )
}

3つのボタンを順に押してください。

  • スクロール: ページがなめらかに一番下まで動きます
  • サイズ: コンソールに数字が出ます。ブラウザの幅を変えてからもう一度押すと、数字が変わります
  • 動画: public/sample.mp4 を置いていなければ、ここは動きません。 手元に mp4 が無ければ飛ばして構いません。「play() という DOM のメソッドを ref 経由で呼んでいる」という形だけ見ておけば十分です
幅: 792 高さ: 54

[スクリーンショット: 04_サイズ測定.png] 「この箱のサイズを測る」を押して、コンソールに幅と高さが出ているところを撮ってください。

この3つに共通するのは、「React では表現できない操作」だということです。

やりたいことJSX で書けるか
カーソルを当てる書けない(「今フォーカスしている」は JSX に無い)
スクロール位置を動かす書けない
動画を再生する書けない(<video> に「再生中」という属性は無い)
実際に何ピクセルか測る書けない(実際に置いてみないと分からない)
文字を表示する書ける(だから ref でやってはいけない)

React が管理しているものを、手で書き換えない

ref で DOM を掴めると分かると、必ずこれをやりたくなります。

// ⚠️ 絶対にやらない
function bad() {
  titleRef.current.textContent = 'こんにちは'
  boxRef.current.style.display = 'none'
  listRef.current.removeChild(listRef.current.firstChild)
}

動きます。その場では、ちゃんと画面が変わります。 そして、次に再描画された瞬間に、全部消えます。

React は、自分が作った DOM の「あるべき姿」を覚えています(再描画の回)。次のレンダーで、覚えている姿と実際の画面を突き合わせて、違うところを直します。 手で書いた変更は「違うところ」なので、React に戻されます。

もっと悪いのは、要素を消したり足したりした場合です。 React が「ここに置いたはずの要素」を探しに行って見つからず、別のエラーで落ちます。しかも、落ちる場所は書き換えた場所ではありません。

線引きは1つです。 「画面に何が出るか」は、必ず state で決める。 ref で触っていいのは、「出ているものに対して、React が知らない操作をする」ときだけ。

「表示を消したい」なら、こうです。

const [show, setShow] = useState(true)
// ...
{show && <div ref={boxRef}>本文</div>}

そもそも、React を使う理由が「手で DOM を書き換えるのをやめる」ことでした(フレームワーク選びの回)。ref で戻ってしまっては、意味がありません。


④ 再描画を起こさない箱として使う

ここから②の用途です。 ①とは、まったく別の話だと思って読んでください。

まず、違いを実演する

App.jsx を、まるごとこれに置き換えます。同じ「カウンター」を2つ並べます。

import { useRef, useState } from 'react'

export default function App() {
  const [stateCount, setStateCount] = useState(0)
  const refCount = useRef(0)

  function addState() {
    setStateCount(stateCount + 1)
    console.log('state:', stateCount + 1)
  }

  function addRef() {
    refCount.current = refCount.current + 1
    console.log('ref:', refCount.current)
  }

  return (
    <div style={{ padding: 24 }}>
      <p>useState 版: {stateCount}</p>
      <button onClick={addState}>state を +1</button>

      <p>useRef 版: {refCount.current}</p>
      <button onClick={addRef}>ref を +1</button>
    </div>
  )
}

まず「ref を +1」を、5回押してください。

ref: 1
ref: 2
ref: 3
ref: 4
ref: 5

コンソールの数字は増えているのに、画面の「useRef 版」は 0 のままです。

[スクリーンショット: 05_refは画面が更新されない.png] コンソールに ref: 5 まで出ているのに、画面の「useRef 版」が 0 のままになっているところを、1枚に入れて撮ってください。

次に、「state を +1」を1回だけ押してください。

その瞬間、「useRef 版」の表示が一気に 5 になります。

驚くところですが、理屈は単純です。

  1. ref.current は、押すたびにちゃんと増えていた
  2. ただし、React は .current の変化を知らないので、再描画しなかった
  3. setStateCount で再描画が起きたとき、ついでに refCount.current も読み直された

これはバグではありません。これが useRef の存在理由そのものです。 「値は覚えていてほしいが、変わっても画面は動かさないでほしい」という場面のための道具です。

では、何に使うのか

「画面に出さない値」で、かつ「描画をまたいで覚えていてほしい値」です。

用途なぜ useRef か
タイマーID(setInterval の戻り値)止めるときに要るが、画面には出ない。 ただの変数だと次の描画で消える
直前の値「前は何だったか」を覚えるだけ。覚えたこと自体で画面は変わらない
「初回かどうか」の目印2回目以降だけ動かしたい、を判定するため
再描画に関係しない集計「このセッションで何回押されたか」を送信時にだけ使う、など
DOM要素そのもの③でやった①の用途。同じ性質を使っている

タイマーの例です。 これは useState では書けません(ID を state に入れると、set するたびに再描画されてしまいます)。

import { useRef, useState } from 'react'

export default function App() {
  const [seconds, setSeconds] = useState(0)
  const timerRef = useRef(null)

  function start() {
    if (timerRef.current !== null) return   // 二重起動を防ぐ
    timerRef.current = setInterval(() => {
      setSeconds((s) => s + 1)
    }, 1000)
  }

  function stop() {
    clearInterval(timerRef.current)
    timerRef.current = null
  }

  return (
    <div style={{ padding: 24 }}>
      <p>経過: {seconds} 秒</p>
      <button onClick={start}>開始</button>
      <button onClick={stop}>停止</button>
    </div>
  )
}

「開始」を押すと数字が増え、「停止」で止まれば成功です。 「開始」を続けて3回押しても、速さが3倍にならないことも確かめてください(timerRef.current !== null で弾いています)。

let timerId = null と書いてはいけません。 setSeconds のたびに App の関数がもう一度呼ばれ、timerId は毎回 null に戻ります(再描画の回)。「停止」を押しても、消すべき ID が手元に無いという状態になります。

「直前の値」も定番です。

import { useEffect, useRef, useState } from 'react'

export default function App() {
  const [count, setCount] = useState(0)
  const prevRef = useRef(null)

  useEffect(() => {
    prevRef.current = count
  })

  return (
    <div style={{ padding: 24 }}>
      <p>いま: {count} / さっき: {String(prevRef.current)}</p>
      <button onClick={() => setCount(count + 1)}>+1</button>
    </div>
  )
}

押していくと いま: 3 / さっき: 2 のように、1つずれて表示されます。

なぜ1つずれるのかは、③の順番の表と同じです。 画面を描くときには prevRef.current はまだ前回の値のままで、描き終わってから useEffect が今回の値を入れるからです。

描画に使う値を useRef に入れない

ここが②の唯一の落とし穴です。 上の例では、prevRef.current を画面に出しています。

これは「たまたま count が変わるたびに再描画されるので、ついでに表示が更新されているだけ」です。 useRef の値だけを変えても、画面は永久に古いままです。

その値は…使うもの
画面に出る。変わったら表示も変わってほしいuseState
画面に出ない。または、他の再描画のついででいいuseRef

判断に迷ったら useState を選んでください。 useState を選んで困るのは「少し余計に描画される」だけですが、useRef を選んで間違えると「画面が古いまま」という、原因の分からないバグになります。


⑤ ref は props か — React 19 の前後で違う

次に、自分で作ったコンポーネントに ref を渡そうとして、必ず1回つまずきます。

function MyInput(props) {
  console.log('props の中身:', props)
  return <input {...props} />
}

// 親
<MyInput ref={inputRef} placeholder="名前" />

コンソールを見てください。

React 19 以降:  props の中身: {ref: {…}, placeholder: "名前"}
React 18 以前:  props の中身: {placeholder: "名前"}

React 18 以前では、ref が入っていません。 ①で確かめた React 19.2 では ref も props に入り、<input {...props} /> でそのまま渡るので、フォーカスも効きます。

JSXの回で、JSX がただの関数呼び出しに変わることを見ました。 そこで、key だけは props に入らない特別な名前だと書きました。React 18 以前は、ref も同じ扱いでした。

名前props に入るか
placeholder onClick など入る
key入らない(React が並びの管理に使う)
refReact 18 以前は入らない(React が参照の受け渡しに使う)。19 以降は関数コンポーネントなら入る

つまり React 18 以前の ref は、「親から子へ渡すデータ」ではなく、「React に対する指示」でした。

子に渡す方法は、バージョンで違う

ここが、記事を読むときに一番事故るところです。 ①で確認した npm ls react の数字を思い出してください。

React 19 以降なら、これで動きます。 ref を、ふつうの props として受け取れるようになりました。

import { useRef } from 'react'

function MyInput({ ref, ...rest }) {
  return <input ref={ref} {...rest} />
}

export default function App() {
  const inputRef = useRef(null)
  return (
    <div style={{ padding: 24 }}>
      <MyInput ref={inputRef} placeholder="名前" />
      <button onClick={() => inputRef.current.focus()}>フォーカス</button>
    </div>
  )
}

React 18 以前は、これでは動きません。 forwardRef で包む必要があります。

import { forwardRef } from 'react'

const MyInput = forwardRef(function MyInput(props, ref) {
  return <input ref={ref} {...props} />
})

検索して出てきたコードが動かないとき、たいていは「その記事が書かれた時点のバージョンと違う」だけです。 npm ls react を打って、自分の版を確かめてから読んでください。 19 で forwardRef を使っても動きます(19 では不要になっただけで、将来の版で非推奨にする予定と公式に書かれています)。逆は動きません。

確認: ボタンを押して、MyInput の中の入力欄にカーソルが当たれば成功です。Cannot read properties of null が出たら、渡し方がその版に合っていません。

[スクリーンショット: 06_子コンポーネントにref.png] MyInput を経由してフォーカスが当たっているところと、npm ls react の出力を並べて撮ってください。


⑥ useImperativeHandle — 親から子の操作を呼ぶ

ref を渡せば、親は子の中の DOM を丸ごと触れてしまいます。 「フォーカスだけ許したい。中身の書き換えまではさせたくない」 というときに使うのが useImperativeHandle です。子が「ref に何を入れるか」を自分で決められるようになります。

import { useImperativeHandle, useRef } from 'react'

function MyInput({ ref, ...rest }) {
  const realRef = useRef(null)
  useImperativeHandle(ref, () => ({
    focus: () => realRef.current.focus(),
    clear: () => { realRef.current.value = '' },
  }))
  return <input ref={realRef} {...rest} />
}

こうすると、親から呼べるのは inputRef.current.focus() と .clear() の2つだけになります。 多用しないでください。 「親が子に命令する」という形は、React の「データは上から下へ流れる」という前提を崩します。 state を親に上げれば済む場面がほとんどです(propsとstateの回)。私は、他人に配る部品を作るとき以外は使っていません。


⑦ コールバック ref — 要素がついた瞬間に動かす

ref には、オブジェクトの代わりに関数を渡せます。 要素がついた瞬間に呼ばれ、外れる瞬間にもう一度呼ばれます。

「箱の高さを測って表示したい」 で比べます。useEffect でやると、こうなります。

const boxRef = useRef(null)
const [h, setH] = useState(0)

useEffect(() => {
  if (boxRef.current) setH(boxRef.current.offsetHeight)
}, [])

これは、条件で出したり消したりする要素だと壊れます。 [] なので最初の1回しか動かず、あとから現れた要素は測られません。 if (boxRef.current) を書き足したのは、まさにそれで null を踏んだからです。

コールバック ref なら、こう書けます。

import { useCallback, useState } from 'react'

export default function App() {
  const [h, setH] = useState(0)
  const [show, setShow] = useState(true)

  const measureRef = useCallback((node) => {
    if (node === null) return          // 外れたときは null で呼ばれる
    setH(node.getBoundingClientRect().height)
  }, [])

  return (
    <div style={{ padding: 24 }}>
      <button onClick={() => setShow(!show)}>出す/消す</button>
      <p>高さ: {Math.round(h)} px</p>
      {show && (
        <div ref={measureRef} style={{ background: '#eee', padding: 16 }}>
          この箱の高さを、ついた瞬間に測っています。
        </div>
      )}
    </div>
  )
}

「出す/消す」を何度か押してください。 出すたびに、高さがきちんと入り直します。

[スクリーンショット: 07_コールバックref.png] 箱を消して出し直したあとも「高さ: 54 px」のように値が入っているところを撮ってください。

呼ばれ方は、これだけです。

タイミング引数
要素が画面についたその DOM 要素
要素が画面から外れたnull

useCallback で包まないと、毎回の描画で「別の関数」になり、React は「ref が変わった」と判断して、外して付け直します(useMemoの回)。再描画のたびに測り直しが1回余分に走るので、忘れないでください(高さが変わらなければ setH は同じ値なので React が再描画を省き、無限には続きません)。

なお、「幅が変わったら測り直す」まで必要なら ResizeObserver を使います。 この記事では扱いませんが、getBoundingClientRect は「その瞬間の値」しか返さないことだけ覚えておいてください(レスポンシブの回)。


⑧ 使い分け表

最後に、3つを1枚にします。 迷ったら「その値は画面に出るか」から見てください。

useStateuseRefuseMemo
何のためのもの画面に出る値を持つ画面に出ない値を持つ/DOMを掴む計算結果を使い回す
変えたら再描画されるされない(自分では値を持たない)
描画をまたいで残る残る残る残るとは限らない(React が捨てることがある)
レンダー中に読んでよいかよい駄目(useEffect かハンドラの中で)よい(そのために在る)
無くても動くか動かない動かない(用途が違う)動く(速度のためだけ)
代表例入力中の文字・開閉タイマーID・input要素重い絞り込みの結果

言い換えると、こうです。

  • 画面に出る → useState
  • 画面に出ないが、覚えていてほしい → useRef
  • 他の値から計算できる → どれにも入れず、その場で計算する。遅かったときだけ useMemo

useMemo は最後です。 「持たなくていい値を持たない」が先で、それでも遅いときに初めて出てきます(useMemoの回)。


つまずいたところ

useRef を「useState の軽い版」だと思っていた

最初、「再描画されない useState」という説明を読んで、「なるほど、軽いほうか」と理解しました。 完全に間違いです。

軽い重いの話ではありません。 useState は「画面に出す値」、useRef は「画面に出さない値」で、用途がそもそも違います。 軽いと思っていたので、迷ったら useRef を選んでいました。 そして④の「画面が 0 のまま」を、入力欄で踏みました。

打った文字を useRef に入れて、「送信のときに読めばいいから軽い」と思ったのです。 文字は表示されました(<input> が自分で持っているからです)。ところが「あと何文字」というカウンターだけが、永久に 0 のままでした。 原因を探して2時間使いました。

null チェックを、意味も分からず全部に書いていた

Cannot read properties of null が怖くて、ref.current を触るところ全部に if (ref.current) を書いていました。

これは、エラーを消しただけで、直していません。 useEffect の中なら要素は必ず入っているので、チェックは要りません。逆に、⑦のように「消えたり出たりする要素」を [] の useEffect で測っている場合は、チェックが通らずに「何も起きない」という、エラーより厄介な状態になります。

if を書きたくなったら、「これはいつ呼ばれるのか」を先に考えるほうが早いと、あとで分かりました。

forwardRef の記事どおりに書いて、警告が出た

React 19 のプロジェクトで、forwardRef の解説記事どおりに書きました。 動きましたが、コンソールに見慣れない警告が出ました。

記事が間違っていたのではなく、「自分の版を確認していなかった」のが原因です。 React は 19 で ref の扱いを変えています。 それ以降、React の記事を読むときは、最初に npm ls react を打つようにしました。

ref で DOM を書き換えて、再描画で消えた

「ここだけ手で書けば速い」と思って、textContent を直接書き換えました。 動きました。 別のボタンを押した瞬間に、書いた文字が消えました。

そのときは「React が消した」と分からず、「文字が消えるバグ」として1日探しました。 消したのは React で、しかも React から見れば正しい動作です。 「あるべき姿」に戻しただけでした。

コールバック ref を useCallback で包まずに、再描画のたびに測り直しが走った

⑦を最初に書いたとき、useCallback を付けませんでした。 再描画のたびに測り直しが走っていました。

測る → setH で再描画 → 関数が新しくなる → ref が付け直される → また測る、の輪ができていました(この例では高さが同じなので setH が同じ値になり、React が再描画を省いて輪はそこで止まります。それでも毎回の付け外しと測り直しは無駄です)。「関数は毎回別物」というのは再描画の回で学んだはずだったのに、ref に渡すときには結び付きませんでした。


後片づけ

この記事で使った ~/reactlab/ は、実験用です。

まず、ブラウザのタブを閉じるか再読み込みしてください。 ④で作ったタイマーが動いたままの可能性があります。 開発サーバーを止めても、ブラウザの中で動いているものは止まりません。

開発サーバーを止めます。 起動しているターミナルで Ctrl+C を押します。

bash
$ ss -tlnp | grep 5178

確認: 何も返らなければ、止まっています。

ポートを閉じます。

bash
$ sudo ufw delete allow 5178/tcp
$ sudo ufw status

確認: 一覧に 5178/tcp が残っていなければ成功です。

プロジェクトを消します。

bash
$ du -sh ~/reactlab
$ rm -rf ~/reactlab
$ ls ~

確認: reactlab が消えていれば片づけ完了です。

本線のものが無事なことを、必ず確認してください。

bash
$ ls ~/react-demo/src

確認: App.jsx などが並んでいれば、本線は無傷です。


まとめ

理解できたことを、並べます。

  • useRef は2つの用途に使われている。 ①DOMへの参照と②再描画を起こさない箱。共通しているのは「React に見張らせない」という一点だけ
  • ref.current は、最初のレンダー中は null。2回目以降も前回の値が残っているだけで当てにならない。 要素が入るのは画面に置かれたあとなので、触ってよいのは useEffect の中か、イベントハンドラの中だけ
  • DOM を直接触ってよいのは、JSX で書けない操作だけ。 フォーカス・スクロール・再生・サイズ測定は ref、表示内容は state
  • ref.current を変えても画面は更新されない。 バグではなく、それが存在理由。 だから「画面に出る値」を入れてはいけない
  • useRef が要るのは、「覚えていてほしいが、変わっても画面は動かさなくていい」値。 ただの変数では、描画のたびに消える
  • ref は React 18 以前は props ではない(key と同じで React への指示)。19 からは props として渡る。 子に渡す方法は React 19 の前後で違うので、npm ls react で自分の版を確かめる
  • useImperativeHandle は、子が公開する操作を絞る道具。 多用しない
  • 要素がついた瞬間に動かしたいなら、コールバック ref。 useCallback で包み忘れると再描画のたびに付け外しと測り直しが走る

この記事を書く前の自分に一言で渡すなら、これです。

useRef は「画面に関係しないもの置き場」。 画面に出るものを入れた瞬間に、原因の分からないバグになる。


参考リンク


次に読む

この記事は 【深掘り】React の 7 / 24 本目です。

記事
← 前の記事useMemoとuseCallback — 付けるほど遅くなる
→ 次の記事Context — 入れたら全部再描画される

上から順に読めば積み上がるように並べています。 飛ばしても構いませんが、詰まったら前の回に戻ってください。

全体の順路は はじめに にあります。

roadmap.sh のどこをやっているか

Frontend›React — Refs
  • DOMへの参照と、再描画を起こさない箱
  • forwardRef / コールバック ref

この記事は、上の項目を実際に手を動かして確かめる回です。

よかったらシェアしてね!
  • URLをコピーしました!
  • URLをコピーしました!

コメント

コメントする

目次