1---
2title: Use Functional setState Updates
3impact: MEDIUM
4impactDescription: prevents stale closures and unnecessary callback recreations
5tags: react, hooks, useState, useCallback, callbacks, closures
6---
7 
8## Use Functional setState Updates
9 
10When updating state based on the current state value, use the functional update form of setState instead of directly referencing the state variable. This prevents stale closures, eliminates unnecessary dependencies, and creates stable callback references.
11 
12**Incorrect (requires state as dependency):**
13 
14```tsx
15function TodoList() {
16  const [items, setItems] = useState(initialItems)
17  
18  // Callback must depend on items, recreated on every items change
19  const addItems = useCallback((newItems: Item[]) => {
20    setItems([...items, ...newItems])
21  }, [items])  // ❌ items dependency causes recreations
22  
23  // Risk of stale closure if dependency is forgotten
24  const removeItem = useCallback((id: string) => {
25    setItems(items.filter(item => item.id !== id))
26  }, [])  // ❌ Missing items dependency - will use stale items!
27  
28  return <ItemsEditor items={items} onAdd={addItems} onRemove={removeItem} />
29}
30```
31 
32The first callback is recreated every time `items` changes, which can cause child components to re-render unnecessarily. The second callback has a stale closure bug—it will always reference the initial `items` value.
33 
34**Correct (stable callbacks, no stale closures):**
35 
36```tsx
37function TodoList() {
38  const [items, setItems] = useState(initialItems)
39  
40  // Stable callback, never recreated
41  const addItems = useCallback((newItems: Item[]) => {
42    setItems(curr => [...curr, ...newItems])
43  }, [])  // ✅ No dependencies needed
44  
45  // Always uses latest state, no stale closure risk
46  const removeItem = useCallback((id: string) => {
47    setItems(curr => curr.filter(item => item.id !== id))
48  }, [])  // ✅ Safe and stable
49  
50  return <ItemsEditor items={items} onAdd={addItems} onRemove={removeItem} />
51}
52```
53 
54**Benefits:**
55 
561. **Stable callback references** - Callbacks don't need to be recreated when state changes
572. **No stale closures** - Always operates on the latest state value
583. **Fewer dependencies** - Simplifies dependency arrays and reduces memory leaks
594. **Prevents bugs** - Eliminates the most common source of React closure bugs
60 
61**When to use functional updates:**
62 
63- Any setState that depends on the current state value
64- Inside useCallback/useMemo when state is needed
65- Event handlers that reference state
66- Async operations that update state
67 
68**When direct updates are fine:**
69 
70- Setting state to a static value: `setCount(0)`
71- Setting state from props/arguments only: `setName(newName)`
72- State doesn't depend on previous value
73 
74**Note:** If your project has [React Compiler](https://react.dev/learn/react-compiler) enabled, the compiler can automatically optimize some cases, but functional updates are still recommended for correctness and to prevent stale closure bugs.
75