React Hooks - Ref 在 useEffect 中不可用

Question

I am using ReactHooks. I am trying to access ref of User component in useEffect function, but I am getting elRef.current value as null , though I passed elRef.current as second argument to useEffect . I am supposed to get reference to an element, but outside (function body) of useEffect , ref value is available. Why is that? How can I get elRef.current value inside useEffect ?

code

import React, { Component, useState, useRef, useEffect } from "react";

const useFetch = url => {
  const [data, setData] = useState(null);
  const [isLoading, setIsLoading] = useState(false);
  const [error, setError] = useState(null);

  useEffect(
    () => {
      setIsLoading(true);
      fetch(url)
        .then(response => {
          if (!response.ok) throw Error(response.statusText);
          return response.json();
        })
        .then(json => {
          setIsLoading(false);
          setData(json.data);
        })
        .catch(error => {
          setIsLoading(false);
          setError(error);
        });
    },
    [url]
  );

  return { data, isLoading, error };
};

const User = ({ id }) => {
  const elRef = useRef(null);
  const { data: user } = useFetch(`https://reqres.in/api/users/${id}`);

  useEffect(() => {
    console.log("ref", elRef.current);
  }, [elRef.current]);
  if (!user) return null;
  return <div ref={elRef}>{user.first_name + " " + user.last_name}</div>;
};

class App extends Component {
  state = {
    userId: 1
  };

  handleNextClick = () => {
    this.setState(prevState => ({
      userId: prevState.userId + 1
    }));
  };

  handlePrevNext = () => {
    this.setState(prevState => ({
      userId: prevState.userId - 1
    }));
  };
  render() {
    return (
      <div>
        <button
          onClick={() => this.handlePrevClick()}
          disabled={this.state.userId === 1}
        >
          Prevoius
        </button>
        <button onClick={() => this.handleNextClick()}>Next</button>
        <User id={this.state.userId} />
      </div>
    );
  }
}

export default App;

Codesandbox link

Thanks !

Answer 1

You should use useCallback instead of useRef as suggested in the reactjs docs .

React will call that callback whenever the ref gets attached to a different node.

Replace this:

const elRef = useRef(null);
useEffect(() => {
    console.log("ref", elRef.current);
}, [elRef.current]);

with this:

const elRef = useCallback(node => {
    if (node !== null) {
        console.log("ref", node); // node = elRef.current
    }
}, []);

Answer 2

It's a predictable behaviour.

As mentioned @estus you faced with this because first time when it's called on componentDidMount you're getting null (initial value) and get's updated only once on next elRef changing because, actually, reference still being the same.

If you need to reflect on every user change, you should pass [user] as second argument to function to make sure useEffect fired when user is changed.

Here is updated sandbox.

Hope it helped.

Answer 3

useEffect is used as both componentDidMount and componentDidUpdate, at the time of component mount you added a condition:

if (!user) return null;
return <div ref={elRef}>{user.first_name + " " + user.last_name}</div>;

because of the above condition at the time of mount, you don't have the user, so it returns null and div is not mounted in the DOM in which you are adding ref, so inside useEffect you are not getting elRef's current value as it is not rendered.

And on the click of next as the div is mounted in the dom you got the value of elRef.current.

Answer 4

The assumption here is that useEffect needs to detect changes to ref.current , so needs to have the ref or ref.current in the dependencies list. I think this is due to es-lint being a bit over-pedantic.

Actually, the whole point of useEffect is that it guarantees not to run until the rendering is complete and the DOM is ready to go. That is how it handles side-effects.

So by the time useEffect is executed, we can be sure that elRef.current is set.

The problem with your code is that you don't run the renderer with <div ref={elRef}...> until after user is populated. So the DOM node you want elRef to reference doesn't yet exist. That is why you get the null logging - nothing to do with dependencies.

---

BTW: one possible alternative is to populate the div inside the effect hook:

useEffect(
  () => {
    if(!user) return;
    elRef.current.innerHTML = `${user.first_name} ${user.last_name}`;
  }, [user]
);

That way the if (!user) return null; line in the User component is unnecessary. Remove it, and elRef.current is guaranteed to be populated with the div node from the very beginning.

Answer 5

When you use a function as a ref , it is called with the instance when it is ready. So the easiest way to make the ref observable is to use useState instead of useRef :

const [element, setElement] = useState<Element | null>(null);
return <div ref={setElement}></div>;

Then you can use it in dependency arrays for other hooks, just like any other const value:

useEffect(() => {
  if (element) console.log(element);
}, [element]);

Answer 6

set a useEffect on the elem's.current:

 let elem = useRef(); useEffect(() => { //... }, [elem.current]);