JSX とコンポーネント
関数コンポーネント
React コンポーネントは JSX を返す JavaScript 関数です。コンポーネント名は大文字で始める必要があります(小文字 = HTML タグ)。Props は属性として渡されパラメータで分割代入されます。JSX は React.createElement() の糖衣構文です。常に単一のルート要素を返します(または Fragment を使用)。コンポーネントは純粋でなければなりません — 同じ props = 同じ出力。
// Basic function component
function Welcome({ name }) {
return <h1>Hello, {name}!</h1>;
}
// Arrow function component
const Greeting = ({ name = 'Guest' }) => (
<p>Welcome, {name}!</p>
);
// Composing components
function App() {
return (
<div>
<Welcome name="Alice" />
<Welcome name="Bob" />
<Greeting />
</div>
);
}JSX 式
JSX は中括弧 {} で JavaScript 式を埋め込むことを許可します。変数、関数呼び出し、三項演算子、値を返す任意の式を配置できます。文(if、for、switch)は直接許可されません — 三項または IIFE を使用してください。ブール値(true、false)、null、undefined は何もレンダリングしません。数値と文字列はテキストとしてレンダリングされます。オブジェクトは有効な React 子ではありません。
function Expression({ user, items }) {
const fullName = user.first + ' ' + user.last;
const itemCount = items.length;
return (
<div>
{/* Expressions in curly braces */}
<h1>{fullName}</h1>
<p>{itemCount} items</p>
{/* Conditional */}
<p>{itemCount > 0 ? 'In stock' : 'Sold out'}</p>
{/* Method calls */}
<p>{fullName.toUpperCase()}</p>
{/* Numbers and booleans render as nothing */}
<p>{false}{null}{undefined}</p>
</div>
);
}Fragment と JSX 内のリスト
Fragment(<>...</>)は余分な DOM ノードを追加せずに複数要素をグループ化します — <div> で囲むよりクリーンです。key を渡す必要がある場合は <Fragment key={...}> を使用します。JSX 要素の配列には一意の key props が必要です。静的リストでは配列インデックスを key として機能しますが、動的リストではレンダリングバグを防ぐため安定した ID を使用してください。Fragment は不要なラッパー要素を減らすことでパフォーマンスを向上させます。
// Fragment: group without extra DOM node
function App() {
return (
<>
<header>Header</header>
<main>Content</main>
<footer>Footer</footer>
</>
);
}
// Array of elements (needs keys)
function List() {
const fruits = ['Apple', 'Banana', 'Cherry'];
return (
<ul>
{fruits.map((fruit, i) => (
<li key={i}>{fruit}</li>
))}
</ul>
);
}条件付きレンダリング
React は複数の条件付きレンダリングパターンを提供します。if/else ロジックには早期リターン。どちらかには三項(cond ? A : B)。表示/非表示には論理 AND(cond && <Component/>)。複雑な分岐には IIFE。JSX に複雑なロジックを埋め込むのを避け — 変数やヘルパー関数に抽出してください。switch 文にはルックアップオブジェクトや別の関数への抽出を使用します。偽値(0、'')はレンダリングされるため、数値には && ではなく三項を使用してください。
function Greeting({ isLoggedIn, user }) {
// 1. If/else (use early return)
if (!isLoggedIn) return <Login />;
// 2. Ternary operator
return (
<div>
{user ? <Dashboard user={user} /> : <Loading />}
{/* 3. Logical AND (render if truthy) */}
{user.isAdmin && <AdminPanel />}
{/* 4. IIFE for complex logic */}
{(() => {
if (user.role === 'admin') return <Admin />;
if (user.role === 'mod') return <Mod />;
return <User />;
})()}
</div>
);
}Children と Render Props
children prop は開始タグと終了タグ間の要素を含みます — コンポーザブルコンポーネント(カード、モーダル、レイアウト)に不可欠。Render props はデータを受け取り JSX を返す関数を prop として渡します — ロジック共有の HOC やフックの代替。Render props はフックでは一般的ではありませんが、コンポーネント注入パターンにはまだ有用です。children は明示的に渡す必要のない特別な prop です。
// children prop: content between tags
function Card({ title, children }) {
return (
<div className="card">
<h2>{title}</h2>
<div className="card-body">{children}</div>
</div>
);
}
// Usage
<Card title="Profile">
<p>Name: Alice</p>
<p>Age: 30</p>
</Card>
// Render prop pattern
function DataProvider({ render }) {
const data = fetchData();
return <div>{render(data)}</div>;
}Props
Props の受け渡し
Props は親から子に渡される読み取り専用データです。任意の JavaScript 値にできます:文字列、数値、ブール値、配列、オブジェクト、関数。文字列値は引用符を使用し(name='Alice')、他のすべての値は中括弧を使用します(age={30})。関数を props にすることで子から親への通信(コールバック)が可能です。Props は下方向に流れます — 子は props を変更できません。双方向データバインディングには、共通の親に状態をリフトします。
// Parent passes props to child
function App() {
return (
<User
name="Alice"
age={30}
isActive={true}
tags={['admin', 'dev']}
onClick={() => console.log('clicked')}
/>
);
}
// Child receives props
function User({ name, age, isActive, tags, onClick }) {
return (
<div onClick={onClick}>
<h1>{name}</h1>
<p>Age: {age}</p>
<p>Status: {isActive ? 'Active' : 'Inactive'}</p>
</div>
);
}デフォルトとオプション Props
デフォルト prop 値は分割代入で設定します(param = defaultValue)。prop が渡されない場合、undefined です。ショートサーキット(bio && <p>)または三項でオプション props を条件付きレンダリングします。PropTypes(レガシー)または TypeScript インターフェースで開発時に prop 型をバリデーションできます。defaultProps(クラスコンポーネント)は関数コンポーネントでは非推奨です — 分割代入のデフォルトを使用してください。
// Default values via destructuring
function Button({ color = 'blue', size = 'md', children }) {
return (
<button className={'btn btn-' + color + ' btn-' + size}>
{children}
</button>
);
}
// Optional props (undefined if not passed)
function Profile({ name, bio }) {
return (
<div>
<h1>{name}</h1>
{bio && <p>{bio}</p>}
</div>
);
}
// Usage
<Button>Click</Button> {/* color='blue', size='md' */}
<Profile name="Alice" /> {/* bio is undefined */}Spread と Rest Props
スプレッド演算子(...props)はすべての props を子要素に渡します — ラッパーコンポーネント(HOC、スタイル付きコンポーネント)に便利。Rest 演算子は特定のものを分割代入した後の残りの props を集めます。このパターンはラッパーコンポーネントが未知の props を DOM 要素に転送するデザインシステムで一般的です。注意:スプレッドは明示的な属性を上書きできます — 順序が重要です({...props} className='x' vs className='x' {...props})。
// Spread: pass all props to child
function Input(props) {
return <input {...props} className="input" />;
}
// Usage
<Input type="text" placeholder="Name" value="Alice" />
// Rest: collect remaining props
function Button({ label, ...rest }) {
return <button {...rest}>{label}</button>;
}
// Selective spreading
function Card({ title, children, ...divProps }) {
return (
<div {...divProps}>
<h2>{title}</h2>
{children}
</div>
);
}Prop Types と TypeScript
TypeScript インターフェースは props のコンパイル時型チェックを提供します — 新しい React プロジェクトの推奨アプローチ。オプション props には ? を使用します(isActive?: boolean)。PropTypes はランタイムバリデーション(開発時のみ)を提供し、TypeScript なしの JavaScript プロジェクトに有用です。isRequired は prop が提供されることを保証します。TypeScript はランタイム前に型エラーを捕捉し、大規模コードベースに優れています。
// TypeScript interface (recommended)
interface UserProps {
name: string;
age: number;
isActive?: boolean; // optional
onClick: (id: number) => void;
}
function User({ name, age, isActive = true, onClick }: UserProps) {
return <div onClick={() => onClick(1)}>{name}, {age}</div>;
}
// PropTypes (runtime checking, legacy)
import PropTypes from 'prop-types';
User.propTypes = {
name: PropTypes.string.isRequired,
age: PropTypes.number,
isActive: PropTypes.bool,
};Prop Drilling と Context
Prop drilling は props がそれらを使用しない複数のコンポーネントレイヤーを通過する時に発生します。2-3 レベルなら許容されます。より深いツリーには Context API、状態管理ライブラリ(Redux、Zustand)、またはコンポーネント合成を使用します。合成(props や children としてコンポーネントを渡す)は Context よりエレガントに drilling を解決することが多いです。問うべきこと:すべての中間コンポーネントがこのデータを必要とするか?そうでない場合、コンポーネント構造を再検討してください。
// Prop drilling: passing through multiple levels
function App() {
const [user, setUser] = useState(null);
return <Layout user={user} />;
}
function Layout({ user }) {
return <Sidebar user={user} />;
}
function Sidebar({ user }) {
return <UserInfo user={user} />;
}
// Solution: Context API (see State Management section)
// Avoid drilling more than 2-3 levelsuseState と State
基本 useState
useState は関数コンポーネントに state を追加する基本フックです。配列 [currentValue, setterFunction] を返します。初期値は任意の型にできます。セッターを呼び出すと新しい値で再レンダリングをトリガーします。State 更新は非同期です — setCount 呼び出し直後に値は変わりません。各コンポーネントインスタンスは独自の独立した state を持ちます。セッターは安定しています(レンダー間で同じ参照)。
import { useState } from 'react';
function Counter() {
// [currentValue, setterFunction] = useState(initialValue)
const [count, setCount] = useState(0);
return (
<div>
<p>Count: {count}</p>
<button onClick={() => setCount(count + 1)}>+1</button>
<button onClick={() => setCount(count - 1)}>-1</button>
<button onClick={() => setCount(0)}>Reset</button>
</div>
);
}関数型更新
新しい state が前の state に依存する場合、関数型更新を使用します:setCount(prev => prev + 1)。これにより複数の更新がバッチ化されていても最新の state で作業することが保証されます。関数型更新なしでは、連続した高速呼び出しが古い state を使用する可能性があります。React 18 は state 更新を自動的にバッチ化するため(promise や timeout 内でも)、正確性に関数型更新が不可欠です。
function Counter() {
const [count, setCount] = useState(0);
// BAD: may not work correctly with rapid updates
const incrementBad = () => setCount(count + 1);
// GOOD: functional update uses previous state
const incrementGood = () => setCount(prev => prev + 1);
// Batch updates
const addThree = () => {
setCount(prev => prev + 1);
setCount(prev => prev + 1);
setCount(prev => prev + 1);
};
return <button onClick={addThree}>Count: {count}</button>;
}オブジェクトと配列の State
state を直接変更しないでください — 常に新しいオブジェクト/配列を作成します。オブジェクトにはスプレッド演算子で既存のプロパティをコピーします:{...prev, [field]: value}。配列には追加はスプレッド([...prev, newItem])、削除は filter、更新は map を使用します。React は変更を検出するために参照を比較します — 変更されたオブジェクトは同じ参照を持つため React は再レンダリングしません。これは初心者向けの React バグの #1 ソースです。
function Form() {
const [form, setForm] = useState({ name: '', email: '', age: 0 });
// BAD: mutates state directly
// form.name = 'Alice'; setForm(form);
// GOOD: spread to create new object
const updateField = (field, value) => {
setForm(prev => ({ ...prev, [field]: value }));
};
return (
<input
value={form.name}
onChange={e => updateField('name', e.target.value)}
/>
);
}
// Array state
function TodoList() {
const [todos, setTodos] = useState([]);
const addTodo = (text) => setTodos(prev => [...prev, { id: Date.now(), text }]);
const removeTodo = (id) => setTodos(prev => prev.filter(t => t.id !== id));
}遅延初期 State
初期 state に高コストな計算が必要な場合、useState に関数を渡します(遅延初期化)。関数は毎回の再レンダリングではなく最初のレンダリングでのみ実行されます。これは localStorage の解析、IndexedDB からのフェッチ、CPU 集約的なセットアップに重要です。関数形式:useState(() => initialValue)。単純な値(数値、文字列)には値を直接渡してください — 遅延初期化は不要です。
import { useState } from 'react';
function ExpensiveInit() {
// BAD: runs on every render (even though result is ignored)
const [data, setData] = useState(computeExpensiveValue());
// GOOD: lazy initialization — function runs only once
const [data2, setData2] = useState(() => computeExpensiveValue());
// Reading from localStorage
const [user, setUser] = useState(() => {
const saved = localStorage.getItem('user');
return saved ? JSON.parse(saved) : null;
});
return <div>{data2}</div>;
}複数の State 変数
1 つの大きなオブジェクトではなく、独立した値には複数の useState 呼び出しを使用します。これにより更新がシンプルになり(スプレッド不要)、不要な再レンダリングを防ぎます。関連する値は単一の state オブジェクトにグループ化します(例:フォームフィールド)。複数のサブ値を持つ複雑な state ロジックには useReducer を検討してください。経験則:state 更新が独立なら別々の useState を、関連/相互依存なら useReducer または単一オブジェクトを使用します。
function LoginForm() {
// Multiple independent state variables
const [email, setEmail] = useState('');
const [password, setPassword] = useState('');
const [errors, setErrors] = useState({});
const [isSubmitting, setIsSubmitting] = useState(false);
const [rememberMe, setRememberMe] = useState(false);
const handleSubmit = (e) => {
e.preventDefault();
setIsSubmitting(true);
// ... validation and submission
};
return (
<form onSubmit={handleSubmit}>
<input value={email} onChange={e => setEmail(e.target.value)} />
<input type="password" value={password}
onChange={e => setPassword(e.target.value)} />
<button disabled={isSubmitting}>Submit</button>
</form>
);
}useEffect と副作用
基本 useEffect
useEffect はレンダリング後に副作用を実行します。effect 関数はコンポーネントがペイントされた後に実行されます。クリーンアップ関数(返される)は次の effect の前とアンマウント時に実行されます — タイマー、サブスクリプション、リスナーのクリアに不可欠。依存配列が effect の再実行タイミングを制御します:[] = マウント時一度、[dep] = dep 変更時、配列なし = 毎レンダー。メモリリークを防ぐため常にクリーンアップしてください。
import { useState, useEffect } from 'react';
function Timer() {
const [seconds, setSeconds] = useState(0);
// Runs after every render
useEffect(() => {
const interval = setInterval(() => {
setSeconds(s => s + 1);
}, 1000);
// Cleanup function runs before next effect or unmount
return () => clearInterval(interval);
}, []); // empty array = run once on mount
return <p>Seconds: {seconds}</p>;
}依存配列
依存配列は useEffect の動作に重要です。空配列 [] = マウント時のみ(componentDidMount のような)。依存あり [a, b] = マウント時と a または b 変更時。配列なし = 毎レンダー(望むことは稀)。依存の欠落は古いクロージャを引き起こします。不要な依存の含めすぎは過剰な再実行を引き起こします。ミスを捕捉するために exhaustive-deps ESLint ルールを使用します。effect で使用されるコンポーネントスコープか らのすべての値が deps にあるべきです。
function UserProfile({ userId }) {
const [user, setUser] = useState(null);
// Runs once on mount (empty deps)
useEffect(() => {
console.log('Component mounted');
}, []);
// Runs when userId changes
useEffect(() => {
fetch('/api/users/' + userId)
.then(r => r.json())
.then(setUser);
}, [userId]); // re-run when userId changes
// Runs on every render (no deps) - rarely needed
useEffect(() => {
console.log('Every render');
});
return <div>{user?.name}</div>;
}クリーンアップとサブスクリプション
クリーンアップはサブスクリプション、イベントリスナー、タイマー、WebSocket 接続に不可欠です。クリーンアップなしではメモリリークと重複ハンドラーが発生します。クリーンアップ関数は:(1) 次の effect 再実行の前、(2) コンポーネントアンマウント時に実行されます。WebSocket/イベントリスナーは常にクリーンアップで削除してください。effect に依存する state は、前の roomId からの古いデータの表示を避けるためクリーンアップでリセットします。
function ChatRoom({ roomId }) {
const [messages, setMessages] = useState([]);
useEffect(() => {
const ws = new WebSocket('wss://chat.example.com/' + roomId);
ws.onmessage = (event) => {
setMessages(prev => [...prev, JSON.parse(event.data)]);
};
// Cleanup: close connection when roomId changes or unmount
return () => {
ws.close();
setMessages([]); // reset for new room
};
}, [roomId]);
// Window event listener
useEffect(() => {
const handleResize = () => console.log(window.innerWidth);
window.addEventListener('resize', handleResize);
return () => window.removeEventListener('resize', handleResize);
}, []);
return <div>{messages.length} messages</div>;
}データフェッチ
useEffect でのデータフェッチには、アンマウント後の state 設定を防ぐためのキャンセルフラグが必要です(React 警告を引き起こす)。'cancelled' フラグはコンポーネントがまだマウントされている場合のみ setUsers/setError/setLoading が実行されることを保証します。本番アプリには、キャッシュ、重複排除、レース条件を自動処理するデータフェッチライブラリ(React Query、SWR)の使用を検討してください。空の依存配列 [] はマウント時に一度フェッチすることを保証します。
function UserList() {
const [users, setUsers] = useState([]);
const [loading, setLoading] = useState(true);
const [error, setError] = useState(null);
useEffect(() => {
let cancelled = false;
const fetchData = async () => {
try {
setLoading(true);
const res = await fetch('/api/users');
const data = await res.json();
if (!cancelled) setUsers(data);
} catch (err) {
if (!cancelled) setError(err.message);
} finally {
if (!cancelled) setLoading(false);
}
};
fetchData();
return () => { cancelled = true; };
}, []);
if (loading) return <p>Loading...</p>;
if (error) return <p>Error: {error}</p>;
return <ul>{users.map(u => <li key={u.id}>{u.name}</li>)}</ul>;
}useLayoutEffect vs useEffect
useEffect はブラウザのペイント後に非同期で実行されます — DOM 要素を測定している場合、ユーザーに短いフラッシュが見える可能性があります。useLayoutEffect は DOM 変更後だがペイント前に同期的に実行されます — 視覚的ちらつきを防ぎます。レイアウトに影響する DOM 測定(getBoundingClientRect、スクロール位置)には useLayoutEffect を使用します。それ以外には useEffect を使用します(ペイントをブロックしません)。サーバーでは useLayoutEffect は警告します — useIsomorphicLayoutEffect パターンを使用してください。
import { useState, useEffect, useLayoutEffect } from 'react';
function Tooltip({ text }) {
const [position, setPosition] = useState({ x: 0, y: 0 });
// useEffect: runs AFTER paint (user may see flash)
useEffect(() => {
const rect = document.getElementById('tip').getBoundingClientRect();
setPosition({ x: rect.x, y: rect.y });
}, [text]);
// useLayoutEffect: runs BEFORE paint (no flash)
useLayoutEffect(() => {
const rect = document.getElementById('tip').getBoundingClientRect();
setPosition({ x: rect.x, y: rect.y });
}, [text]);
return <div id="tip" style={{ left: position.x, top: position.y }}>{text}</div>;
}useRef、useMemo と useCallback
useRef の基礎
useRef はレンダー間で持続するミュータブルなオブジェクト { current: value } を返します。state とは異なり、ref.current の変更は再レンダリングをトリガーしません。一般的な用途:(1) DOM 要素へのアクセス(ref 属性経由)、(2) レンダリングに影響しないミュータブル値の格納(タイマー、前の値)、(3) コールバックで使用する最新値の格納。ref オブジェクトはレンダー間で同じアイデンティティを持ちます。初期値は useRef(initialValue) に渡されます。
import { useRef } from 'react';
function FocusInput() {
// ref to access DOM element
const inputRef = useRef(null);
const focus = () => inputRef.current.focus();
const clear = () => {
inputRef.current.value = '';
inputRef.current.focus();
};
return (
<div>
<input ref={inputRef} type="text" />
<button onClick={focus}>Focus</button>
<button onClick={clear}>Clear</button>
</div>
);
}ミュータブル値の useRef
useRef は再レンダリングをトリガーせずにレンダー間で持続するミュータブル値を格納します。これは以下に最適です:タイマー ID、WebSocket 参照、前の state の追跡、レンダー回数のカウント。ref.current の変更は再レンダリングを引き起こさないため、変更時に UI は更新されません — UI に影響する値には state を使用してください。レンダーカ ウントパターン(ref.current++)はデバッグに有用ですが本番ロジックには使用すべきではありません。
function Stopwatch() {
const [seconds, setSeconds] = useState(0);
const intervalRef = useRef(null);
const renderCount = useRef(0);
// Track render count (doesn't trigger re-render)
renderCount.current++;
const start = () => {
if (intervalRef.current) return;
intervalRef.current = setInterval(() => {
setSeconds(s => s + 1);
}, 1000);
};
const stop = () => {
clearInterval(intervalRef.current);
intervalRef.current = null;
};
return (
<div>
<p>{seconds}s (render #{renderCount.current})</p>
<button onClick={start}>Start</button>
<button onClick={stop}>Stop</button>
</div>
);
}useMemo
useMemo は計算値をメモ化(キャッシュ)し、依存関係が変更された時のみ再計算します。高コストな計算(フィルタリング、ソート、複雑な計算)に使用して毎レンダーでの再実行を回避します。依存配列は useEffect のように動作します。過剰使用はパフォーマンスを損なう可能性があります(メモ化自体にオーバーヘッドがある)— 本当に高コストな操作のみメモ化してください。useMemo は子の再レンダリングを防ぐためのオブジェクト参照の保持にも有用です。
import { useState, useMemo } from 'react';
function ProductList({ products, filter }) {
const [search, setSearch] = useState('');
// Memoize expensive computation
const filtered = useMemo(() => {
console.log('Filtering...');
return products
.filter(p => p.category === filter)
.filter(p => p.name.includes(search));
}, [products, filter, search]); // recompute only when these change
// Memoize a value
const totalPrice = useMemo(() =>
filtered.reduce((sum, p) => sum + p.price, 0),
[filtered]);
return (
<div>
<input value={search} onChange={e => setSearch(e.target.value)} />
<p>Total: ${totalPrice}</p>
{filtered.map(p => <div key={p.id}>{p.name}</div>)}
</div>
);
}useCallback
useCallback は関数をメモ化し、依存関係が変更されない限りレンダー間で同じ参照を返します。これによりメモ化された子コンポーネント(memo() でラップ)の不要な再レンダリングを防ぎます。useCallback なしでは、親の毎レンダーで新しい関数参照が作成され、memo() 子が再レンダリングされます。最適化された子コンポーネントにコールバックを渡す時に useCallback を使用します。useMemo と同様に過剰使用しないでください — メモ化された子に props として渡される関数のみに。
import { useState, useCallback, memo } from 'react';
// Memoized child component
const Button = memo(function Button({ onClick, label }) {
console.log('Button rendered');
return <button onClick={onClick}>{label}</button>;
});
function App() {
const [count, setCount] = useState(0);
const [text, setText] = useState('');
// Without useCallback: new function every render
// const handleClick = () => setCount(c => c + 1);
// With useCallback: stable function reference
const handleClick = useCallback(() => {
setCount(c => c + 1);
}, []); // empty deps = stable forever
return (
<div>
<input value={text} onChange={e => setText(e.target.value)} />
<Button onClick={handleClick} label="Click" />
<p>Count: {count}</p>
</div>
);
}Ref のフォワーディング
forwardRef は親コンポーネントが子コンポーネントの DOM 要素に ref を渡すことを可能にします。useImperativeHandle は ref が公開するものをカスタマイズします — DOM ノードの代わりに特定のメソッド(focus、clear、getValue)を公開できます。これは命令的 API を持つ再利用可能な入力コンポーネントの作成に有用です。React 19 は ref を簡素化しました(ref は通常の prop になりました)が、ライブラリには forwardRef がまだ必要です。命令的ハンドルの過剰使用を避けてください — 宣言的 props を優先します。
import { useRef, forwardRef, useImperativeHandle } from 'react';
// forwardRef: pass ref to child component
const FancyInput = forwardRef(function FancyInput(props, ref) {
return <input ref={ref} className="fancy" {...props} />;
});
// useImperativeHandle: expose specific methods
const CustomInput = forwardRef(function CustomInput(props, ref) {
const inputRef = useRef(null);
useImperativeHandle(ref, () => ({
focus: () => inputRef.current.focus(),
clear: () => { inputRef.current.value = ''; },
getValue: () => inputRef.current.value,
}));
return <input ref={inputRef} />;
});
// Usage
function App() {
const ref = useRef(null);
return (
<>
<CustomInput ref={ref} />
<button onClick={() => ref.current.focus()}>Focus</button>
<button onClick={() => ref.current.clear()}>Clear</button>
</>
);
}useReducer と Context
useReducer の基礎
useReducer は複雑な state ロジックの useState の代替です。Reducer は純粋関数です:(state, action) => newState。Action は何が起きたかを記述し、reducer が state をどう更新するかを決定します。このパターンにより state 遷移が予測可能でテスト可能になります。dispatch は安定しています(同じ参照)。常に新しい state オブジェクトを返してください(変更しない)。デフォルトケースは未知の action に対してエラーをスローすべきです。state が複数のサブ値を持つか次の state が複雑なロジックに依存する時に useReducer を使用します。
import { useReducer } from 'react';
// Reducer function: (state, action) => newState
function counterReducer(state, action) {
switch (action.type) {
case 'increment':
return { count: state.count + 1 };
case 'decrement':
return { count: state.count - 1 };
case 'reset':
return { count: 0 };
case 'set':
return { count: action.payload };
default:
throw new Error('Unknown action: ' + action.type);
}
}
function Counter() {
const [state, dispatch] = useReducer(counterReducer, { count: 0 });
return (
<div>
<p>Count: {state.count}</p>
<button onClick={() => dispatch({ type: 'increment' })}>+</button>
<button onClick={() => dispatch({ type: 'decrement' })}>-</button>
<button onClick={() => dispatch({ type: 'reset' })}>Reset</button>
<button onClick={() => dispatch({ type: 'set', payload: 10 })}>Set 10</button>
</div>
);
}複雑な Reducer
複雑な reducer は複数の関連する state を管理します。各 action タイプは特定の state 遷移を処理します。常に前の state をスプレッドして({...state})無関係なフィールドを保持します。ネストされた更新(todo の切り替えなど)には、map で更新されたアイテムを持つ新しい配列を作成します。Reducer は純粋でなければなりません — 副作用なし、API 呼び出しなし。テスト可能性のために reducer を別ファイルに抽出します。非常に複雑な state には Redux Toolkit のようなライブラリを検討してください。
const initialState = {
todos: [],
filter: 'all',
loading: false,
};
function todoReducer(state, action) {
switch (action.type) {
case 'add':
return { ...state, todos: [...state.todos, action.todo] };
case 'toggle':
return {
...state,
todos: state.todos.map(t =>
t.id === action.id ? { ...t, done: !t.done } : t
),
};
case 'delete':
return { ...state, todos: state.todos.filter(t => t.id !== action.id) };
case 'set_filter':
return { ...state, filter: action.filter };
case 'set_loading':
return { ...state, loading: action.loading };
default:
return state;
}
}
function TodoApp() {
const [state, dispatch] = useReducer(todoReducer, initialState);
// dispatch({ type: 'add', todo: { id: 1, text: 'Learn React', done: false } })
}Context API
Context API は prop drilling なしでコンポーネントツリー全体で state を共有します。createContext(defaultValue) で作成します。value prop で Provider でコンシューマーをラップします。useContext(Context) で消費します。Context 値の変更はすべてのコンシューマーの再レンダリングをトリガーします。パフォーマンスのために、コンテキストを分割(ThemeContext、UserContext)してコンポーネントが特定のコンテキスト変更時にのみ再レンダリングするようにします。デフォルト値は Provider がコンシューマーをラップしていない時に使用されます。
import { createContext, useContext, useState } from 'react';
// 1. Create context with default value
const ThemeContext = createContext('light');
const UserContext = createContext(null);
// 2. Provider component
function App() {
const [theme, setTheme] = useState('light');
const [user, setUser] = useState(null);
return (
<ThemeContext.Provider value={{ theme, setTheme }}>
<UserContext.Provider value={{ user, setUser }}>
<Page />
</UserContext.Provider>
</ThemeContext.Provider>
);
}
// 3. Consume context
function Page() {
const { theme } = useContext(ThemeContext);
const { user } = useContext(UserContext);
return <div className={'page theme-' + theme}>Hello {user?.name}</div>;
}Reducer 付き Context
Context と useReducer の組み合わせは軽量なグローバル state 管理システム(ミニ Redux)を作成します。Provider は state と dispatch の両方を公開します。カスタムフック(useStore)はプロバイダー外で使用された場合のエラーハンドリングを提供します。このパターンは中規模アプリに最適です。非常に大規模で頻繁な更新があるアプリには、すべてのコンシューマーが毎回の state 変更で再レンダリングされるのを避けるため、コンテキストの分割や Redux/Zustand の使用を検討してください。
import { createContext, useContext, useReducer } from 'react';
// Combine Context + useReducer for global state
const StoreContext = createContext(null);
function StoreProvider({ children }) {
const [state, dispatch] = useReducer(reducer, initialState);
return (
<StoreContext.Provider value={{ state, dispatch }}>
{children}
</StoreContext.Provider>
);
}
// Custom hook for easy consumption
function useStore() {
const context = useContext(StoreContext);
if (!context) throw new Error('useStore must be used within StoreProvider');
return context;
}
// Usage
function Component() {
const { state, dispatch } = useStore();
return <button onClick={() => dispatch({ type: 'action' })}>Click</button>;
}useContext パフォーマンス
context 値が変更されると、すべてのコンシューマーが再レンダリングされます — 値の小さな一部のみを使用していても。最適化するには:(1) コンポーネントが必要なもののみサブスクライブするようコンテキストを分割。(2) useMemo で context 値をメモ化して値が実際に変更されていない時の再レンダリングを防止。(3) 細粒度サブスクリプションのためにセレクター(use-context-selector ライブラリ)を使用。高頻度更新(マウス位置など)では Context はパフォーマンス問題を引き起こす可能性があります — ref や外部ストアを検討してください。