How do React hooks work in React Native?

Question

IT Interview Practice · Accepted Answer

**Hooks** (useState, useEffect, useContext, and more) are React features for managing state and side effects in functional components — and they work the same in React Native. Understanding the key hooks is essential for building React Native components.

## useState — state

```jsx
const [count, setCount] = useState(0);     // state + setter; setting it re-renders
const [user, setUser] = useState(null);
```

## useEffect — side effects

```jsx
// useEffect runs side effects (data fetching, subscriptions) after render
useEffect(() => {
  fetchData();                  // runs after render
  // optional CLEANUP (returned function) — runs on unmount / before re-running
  const sub = subscribe();
  return () => sub.unsubscribe();   // CLEAN UP (prevent leaks)
}, [dependency]);                    // dependency array → when to re-run
// → [] = run once on mount; [dep] = run when dep changes; none = every render
```

`useEffect` handles side effects (fetching data, subscriptions, timers) with a dependency array controlling when it runs, and an optional cleanup function (important for preventing leaks).

## Other key hooks

```text
useContext → consume context (shared data without prop drilling)
useRef → a mutable reference that persists across renders (e.g. reference a component,
  store a value without re-rendering)
useMemo → memoize an expensive computed value (performance)
useCallback → memoize a function (avoid unnecessary re-creation/re-renders)
useReducer → manage complex state with a reducer
CUSTOM HOOKS → extract reusable stateful logic (e.g. useFetch, useAuth)
```

## Rules of hooks

```text
⚠️ Only call hooks at the TOP LEVEL of a component (not in conditions/loops/nested functions)
⚠️ Only call hooks from React components or custom hooks
→ These rules ensure hooks work correctly (React relies on call order).
```

## Why it matters

Understanding React hooks is essential for React Native because **hooks are the standard way to manage state and side effects in functional components**, which are how modern React Native apps are built, so it's must-know knowledge.

Hooks work identically in React Native as in React for web, making this knowledge directly transferable. **useState** (managing state, triggering re-renders) is fundamental for any component with changing data. **useEffect** is particularly important: it handles **side effects** (data fetching, subscriptions, timers) with a dependency array controlling when it runs and an **optional cleanup function** (crucial for preventing leaks by unsubscribing/cleaning up) — understanding useEffect, its dependency array, and cleanup is essential since side effects (like fetching data when a screen loads) are common and getting useEffect wrong causes bugs (infinite loops from wrong dependencies, leaks from missing cleanup).

Understanding **other key hooks** — useContext (consuming shared data without prop drilling), useRef (persistent mutable references), useMemo/useCallback (memoization for performance), useReducer (complex state), and **custom hooks** (extracting reusable stateful logic like useFetch or useAuth — a powerful pattern for code reuse) — covers the toolkit for building real components.

Understanding the **rules of hooks** (calling them only at the top level and only from components/custom hooks, since React relies on call order) is essential to avoid subtle bugs.

Since hooks are the standard mechanism for state and side effects in modern functional React Native components (and the knowledge transfers directly from React), and since understanding the key hooks (especially useState and useEffect with its cleanup) and the rules is essential for building correct components, understanding React hooks is essential, frequently-applied React Native knowledge — fundamental to building modern React Native components, central to managing state and side effects, and directly transferable from web React, a core skill for React Native development.

useState — state

useEffect — side effects

Other key hooks

Rules of hooks

Why it matters

Related questions