In React, we use Hooks like useState to store and update data.

But sometimes, we need to store a value without causing the component to re-render.

We may also need to directly access an HTML element, such as an input field or button.

This is where useRef comes in.

1. What is useRef?

useRef is a React Hook that allows us to store a value that stays between renders.

It is commonly used for two things:

  • Accessing HTML elements directly.
  • Storing values without causing a re-render.

In simple words, useRef helps us remember values or access elements without triggering a re-render when the ref changes.

2. How to use useRef?

First, import useRef from React.

import { useRef } from "react"; 

Then create a ref inside your component.

const myRef = useRef(null); 

A ref contains a property called current.

We can access or update its value using:

myRef.current 

3. Accessing an HTML Element Using useRef

Let's understand with a simple example.

Imagine we have an input field and want to automatically focus on it when we click a button.

import { useRef } from "react"; function App() { // Creating a ref const inputRef = useRef(null); function handleClick() { // Focusing the input field inputRef.current.focus(); } return ( <div> <input ref={inputRef} placeholder="Enter your name" /> <button onClick={handleClick}> Focus Input </button> </div> ); } export default App; 

How does it work?

  1. useRef(null) creates a ref.
  2. We connect the ref to the input using ref={inputRef}.
  3. When we click the button, inputRef.current gives us access to the input element.
  4. .focus() automatically places the cursor inside the input field.

This is one of the most common uses of useRef.

4. Storing Values Without Re-rendering

Another use of useRef is storing values without causing a component to re-render.

Let's see an example of a simple counter.

import { useRef } from "react"; function App() { const countRef = useRef(0); function handleClick() { countRef.current++; console.log(countRef.current); } return ( <div> <h2>Click the button</h2> <button onClick={handleClick}> Increase </button> </div> ); } export default App; 

Every time we click the button, the value inside countRef.current increases.

But notice something important:

The value is updated, but the component does not re-render.

We can see the updated value in the console, but the UI will not automatically display the new value.

If we need the UI to update whenever a value changes, we should use useState instead.

5. useRef vs useState

Both Hooks can store values, but they behave differently.

useRef useState
Stores a value between renders Stores component state
Updating .current does not cause a re-render Updating state causes a re-render
Commonly used to access HTML elements Commonly used to update the UI
Updated value is available through .current Updated value is available through the state variable

Example:

  • Use useState when displaying a counter that updates on the screen.
  • Use useRef when storing a counter value that doesn't need to update the screen.

6. Where Do We Use useRef?

Some common examples are:

  • Input Fields: Automatically focus on an input field.
  • DOM Elements: Access an HTML element directly.
  • Timers: Store a timer ID returned by setInterval.
  • Previous Values: Store a previous value between renders.
  • Tracking Values: Keep a value without triggering re-renders.

7. Important Points to Remember

  • useRef is a React Hook.
  • It stores values between renders.
  • We access its value using .current.
  • Updating .current does not trigger a re-render.
  • It can be used to access HTML elements directly.
  • Use useState when a change needs to update the UI.