The Hitchhikers Guide to Refs
Tags: react, javascript, refs
Published: 2019-03-14 12:29:10

---
title: The Hitchhikers Guide to Refs
published: true
description: Ever got confused about refs in React? This article is about to set the record straight.
tags: reactjs, javascript, refs
cover_image: https://images.unsplash.com/photo-1444703686981-a3abbc4d4fe3?ixlib=rb-1.2.1&ixid=eyJhcHBfaWQiOjEyMDd9&auto=format&fit=crop&w=1000&q=80
canonical_url: https://www.selbekk.io/blog/2019/03/the-hitchhikers-guide-to-refs/
---

React has this feature called refs. A ref is what the React docs call an "escape hatch", and lets you interact with instances of stuff. They should be used sparingly, but can be pretty useful at times.

This article will guide you through the sometimes confusing world of refs in React, and how, when and why you should use them. We'll go through what refs are, the different ways to create them, use them and when they're the right choice for _your_ challenge. Let's go! 💥

## What's a ref?

A ref - short for reference - is a way to reference... well, something. Typically that something is a DOM node or a class component. More precisely, **a ref is a reference to the instance of a node or component**.

In the case of a DOM node, you get access to its JavaScript API. Just like you'd created it in JavaScript yourself, like this:

```js
const buttonRef = document.createElement('button');
```

This means you get access to a ton of imperative APIs, like `.focus()` or `.click()`

When you add a ref to a class component, you get access to its instance. That means you can call all its instance methods, if you need to. This might be useful if you need to fetch some state from a child component, or trigger some sort of side-effect that can't easily be triggered by passing a changed prop.

## How do you create a ref?

Alright, so we've looked at what a ref is - but how do we use it? Turns out, there's a few ways. Let's dive in!

### React.createRef()

The simplest way to create a ref is by using the API provided to us by React. By calling `React.createRef()`, we receive a ref we can place on whatever we want:

```js
function App() {
  const inputRef = React.createRef();
  return (
    <>
      <input ref={inputRef} />
      <button onClick={() => inputRef.current.focus()}>
        Click to focus
      </button>
    </>
  );
}
```

Here, we put the reference on the input field by passing it to the `ref` prop, and then we call it from the button's click handler. If you click the button, the input field will be focused. Not something you do every day, perhaps, but you get the gist.

> #### .current what?
> When you call `React.createRef()`, you get back an object that has a single property, `current`. Why do we need this seemingly annoying middle-man - couldn't we just assign what we wanted directly?
>
> Turns out, there's a reason for this! If we created the ref directly, there would be no way for React to update this ref - we'd have to create a new reference from scratch. By having this mutable object property, though, React _can_ update it in place, without having to recreate it again. You can look at [this issue](https://github.com/facebook/react/issues/12588) for a better explanation. 

`React.createRef()` is a pretty new addition to React (it was added in 16.3.0). It was added to simplify this entire refs process. Have a look at the [RFC](https://github.com/reactjs/rfcs/blob/master/text/0017-new-create-ref.md#basic-example) if you want to dive into why it was added in the first place.

## `useRef`

`useRef` is a hook, and will therefore only work in function components. That doesn't mean that it's not a great tool! As a matter of fact, this is what I use to write 99 % of my refs these days.

When you call `useRef` you get an immutable object instance with a mutable `current` value, like `React.createRef()`. You can pass in an initial value if you'd like. Here's an example!

```js
function App() {
  const inputRef = React.useRef(null);
  return (
    <>
      <input ref={inputRef} />
      <button onClick={() => inputRef.current.focus()}>
        Click to focus
      </button>
    </>
  );
}
```

### Callback refs

Before React 16.3 came out, the preferred way of creating a ref was by something we called "callback refs". Basically it put you in charge of creating and storing the reference somewhere. It looked like this:

```js
class App extends React.Component {
  render() {
    return (
      <>
        <input ref={ref => this.inputRef = ref} />
        <button onClick={() => this.inputRef.focus()}>
          Click to focus
        </button>
      </>
    );
  }
}
```

This works just fine too, but it was considered a bit clunky to understand for a few reasons. First of all, now we had to decide on where I'd like to save my ref. Second, there was a [caveat of inlining the function itself](https://reactjs.org/docs/refs-and-the-dom.html#caveats-with-callback-refs). If the callback function was inlined (like above), it would be called twice - once with the `ref` argument being `null`, and once with it being set to the actual instance. 

You can still use this approach today, but save it for when you need the flexibility it offers. If you're dynamically creating references, for example - that might be a use case for this.

### String refs (vintage)

If you're working on an older codebase, you might stumble across code like this:

```js
class App extends React.Component {
  render() {
    return (
      <>
        <input ref="input" />
        <button onClick={() => this.refs.input.focus()}>
          Click to focus
        </button>
      </>
    );
  }
}
```

This approach is called "string refs", and is scheduled for deprecation sometime in the future. The API is nice and simple, but there's [a few drawbacks](https://github.com/facebook/react/pull/8333#issuecomment-271648615) to them. 

If you see them in your codebase, refactor them to look like the previous example instead, or use `React.createRef()` to create the ref for you. Your future self will thank you!

## When to use refs (and when to avoid them)

As I mentioned in the introduction, React calls refs an "escape hatch". Why's that? To answer that, we need to remember that React is declarative.

> ### Declarative vs imperative
> I always forget what's what, so here's a quick rule of thumb for those of you who think like me:
>
> Declarative code tells you what you want. Imperative code tells you how to get there.
>
> React is declarative in the way that you write what you want (an H2 with a class of "large"), instead of specifying how that's going to happen. Declarative code rules!

In a perfect world, everything would be declarative - but the web isn't built that way. For good reason, I might add. Instead, we sometimes need to "escape" down into the imperative world. Some examples are:

- focusing an input (yeah yeah, we've covered this one)
- accessing imperative APIs from other libraries (i.e. jQuery)
- accessing DOM APIs (speech recognition, animation, you name it)
- invoking functionality on child components

For all of these use cases, we gain that imperative access by creating a reference to them. Once we have that, we can go to town, calling methods and being imperative all day long.

### Refs should be the exception to the rule

Although there are some real usecases for refs - they aren't something you should be grabbing for every time you want something to happen in your apps. Typically, a small refactor, lifting some state up or creating a declarative abstraction over imperative APIs is what you want to do.

In other words - try solving your challenge without refs first. If you can't see a good solution, then consider a ref.

## Forwarding refs

`ref` is a special prop in React. Like `key`, it's not passed along as a part of the `props` hash passed to the component. Instead, it's "captured" by React, and is never really exposed to the component being referenced.

Now, 9 times out of 10, this is what you want. If you're creating a reusable button or input component, however, the `ref` prop passed might have been meant for the actual DOM field.

Back in the days, you'd have to create a new prop (`inputRef` or `domRef` or what have you), and then apply that prop to your DOM node, like this:

```js
function InputField(props) {
  return <input ref={props.inputRef} />;
}
```

This would lead to a lot of confusing APIs! Now, we have `React.forwardRef`:

```js
React.forwardRef((props, ref) => {
  return <input ref={ref} {...props} />;
});
```

This will just forward whatever `ref` is sent to the correct place!

It's not an API you're going to use a lot - but it's a great thing to know it's there. You can read more about `forwardRef` in [the documentation](https://reactjs.org/docs/forwarding-refs.html).

## useRef - changing how we think about refs

Up until very recently, `refs` were about what we've talked about so far - references to DOM nodes or class component instances. However, with the introduction of hooks came `useRef` - and it changes everything. Again.

As you saw earlier, you can use `useRef` in a similar fashion to `React.createRef` in function components to create a reference. However, `useRef` doesn't limit itself to just instances of stuff!

As a matter of fact, `useRef` lends itself to any value, instance, function or whatever else you might want to keep around between renders. Think of it as the "instance variable" of function components.

Here's an example. I often create an `InputGroup` component in my apps to automatically create a UUID id for my input fields, like so:

```js
import uuid from 'uuid/v4';

class InputGroup extends React.Component {
  this.id = `input-${uuid()}`;
  render() {
    return (
      <div>
        <label htmlFor={this.id}>{this.props.label}</label>
        {children({ id: this.id })}
      </div>
    );
  }
}
```

It's annoying to have to use a class component here - I'm not using any fancy React features! Let's refactor it to a function component instead:

```js
import uuid from 'uuid/v4';

function InputGroup(props) {
  const id = useRef(uuid());
  return (
    <div>
      <label htmlFor={id}>{props.label}</label>
      {children({ id })}
    </div>
  );
}
```

This is pretty neat - I can now share values across calls to my function component! I suggest you go check out [the official documentation on `useRef`](https://reactjs.org/docs/hooks-reference.html#useref) - it has some nice examples to learn from.

> This is kind of an aside to the topic of refs - but I included it for completeness sake. Since you can create DOM refs the same way - it's a nice trick to know about.

## Conclusion

Refs are a great tool to have in your React toolbox. They're perfect for when you need to trigger some imperative DOM API, or you need to access to the instance of a class component. You should **use refs sparingly**, and only if you need to access imperative APIs for some reason. Consider lifting state up instead of referencing class component instances.

There are plenty of ways to create refs, but the easiest is `React.useRef` for function components, or for `React.createRef` for any component. You might stumble across callback refs or string refs in legacy codebases, but new code shouldn't use them without a good reason.

Finally, `useRef` lets us create refs to not only DOM nodes and component instances, but to any value, function or component. 

## Want more material?

Here's a few useful links to other content that describe the same as above, with other words and granularities:

- [The official docs on refs](https://reactjs.org/docs/refs-and-the-dom.html)
- [CSS Tricks' article on refs](https://css-tricks.com/working-with-refs-in-react/)
- [HackerNoon's article on refs (from 2017)](https://hackernoon.com/refs-in-react-all-you-need-to-know-fb9c9e2aeb81)
- [A gentle introduction to refs](https://medium.com/@mrewusi/a-gentle-introduction-to-refs-in-react-f407101a5ea6)