Reputation: 3843
We use a third party library (over which there is limited control) that takes a callback as argument to a function. What is the correct way to provide that callback with the latest state? In class components, this would be done through the use of this
. In React hooks, due to the way state is encapsulated in the functions of React.useState()
, if a callback gets the state through React.useState()
, it will be stale (the value when the callback was setup). But if it sets the state, it will have access to the latest state through the passed argument. This means we can potentially get the latest state in such a callback with React hooks by setting the state to be the same as it was. This works, but is counter-intuitive.
With the following code, every time the callback accesses it, it's back at its default value. The console will keep printing Count is: 0
no matter how many times I click.
function Card(title) {
const [count, setCount] = React.useState(0)
const [callbackSetup, setCallbackSetup] = React.useState(false)
function setupConsoleCallback(callback) {
console.log("Setting up callback")
setInterval(callback, 3000)
}
function clickHandler() {
setCount(count+1);
if (!callbackSetup) {
setupConsoleCallback(() => {console.log(`Count is: ${count}`)})
setCallbackSetup(true)
}
}
return (<div>
Active count {count} <br/>
<button onClick={clickHandler}>Increment</button>
</div>);
}
const el = document.querySelector("#root");
ReactDOM.render(<Card title='Example Component' />, el);
I've had no problem setting state within a callback, only in accessing the latest state.
If I was to take a guess, I'd think that any change of state creates a new instance of the Card function. And that the callback is referring to the old one. Based on the documentation at https://reactjs.org/docs/hooks-reference.html#functional-updates, I had an idea to take the approach of calling setState in the callback, and passing a function to setState, to see if I could access the current state from within setState. Replacing
setupConsoleCallback(() => {console.log(`Count is: ${count}`)})
with
setupConsoleCallback(() => {setCount(prevCount => {console.log(`Count is: ${prevCount}`); return prevCount})})
Does work. I need to call setState to access the previous state. Even though I have no intention of setting the state.
How can I access the latest state information from within a callback?
Upvotes: 277
Views: 145104
Reputation: 723
It's a common pattern in React. you have a callback (for exampler an event) and inside that callback you need to access updated value of state.
One way is to use useRef
and probably an useEffect
to keep useRef
value up to date.
But there is a better way: in the event just change one state (maybe an flag) and within useEffect
put your main code:
function Card(title) {
const [var, setVar] = useState(1);
someElement.addEventListener('event',()=>{
/*Some code should be here but we move the code
Into useEffect and then trigger that useEffect*/
setVar(2);
});
useEffect(()=>{
/*The code you want to run in event should be here*/
},[var]);
}
Upvotes: 2
Reputation: 10226
I've written a hook that makes it easy to do this, as well as a hook meant specifically for keydown events which are a common case where this is run into: https://stackoverflow.com/a/76624505/1296178
The useEffectUnscoped
hook is a generic implementation that stores an object in a ref (i.e. a state variable or a function that references a state variable that needs to be up to date).
useKeyDown
is a cleaner hook meant more specifically for keydown events.
Upvotes: 1
Reputation: 24630
You can use the react-usestateref
NPM package (disclosure: I am its creator), which creates a modified useState
that implements the useRef
approach in Brandon's answer. This useState
is a compatible drop-in replacement for the standard React useState
, that also gives you a mutable reference that always holds the current state.
You use it like this:
import useState from 'react-usestateref';
...
// inside the component:
const [count, setCount, countRef] = useState(0);
// countRef.current always gives you the latest state -- it's
// automatically updated whenever you call 'setCount'.
...
console.log(countRef.current);
setCount(20);
console.log(countRef.current); // logs '20'
Another approach, instead of using useRef
or modifying useState
, is to use the fact that, if you call setState
with a callback, it passes the current state value into that callback; so you can write:
const [state, setState] = useState(defaultValue);
useEffect(() => {
var currentState;
setState(currentState_ => {
currentState = currentState_;
return currentState_; // don't actually change the state
})
alert(currentState); // the current state.
})
Upvotes: 76
Reputation: 2271
I had similar problem but in my case I was using redux with hooks and also I was not mutating state in the same component. I had method which on callback used state value score
and it (callback) had old score.
So my sollution for that is quite simple. It's not as ellegant as previous ones but in my case it did the job so I'm putting it here with hope that it will help someone.
const score = useSelector((state) => state.score);
const scoreRef = useRef(score);
useEffect(() => {
scoreRef.current = score ;
}, [score])
General idea is to store newest state in ref :)
Upvotes: 1
Reputation: 7680
I really like @davnicwil's answer and hopefully with the source code of useState
, it might be more clear what he meant.
// once when the component is mounted
constructor(initialValue) {
this.args = Object.freeze([initialValue, this.updater]);
}
// every time the Component is invoked
update() {
return this.args
}
// every time the setState is invoked
updater(value) {
this.args = Object.freeze([value, this.updater]);
this.el.update()
}
In the usage, if initialValue
starts as a number or string, ex. 1.
const Component = () => {
const [state, setState] = useState(initialValue)
}
Walkthrough
useState
, this.args
= [1, ]useState
, this.args
no changesetState
is invoked with 2, this.args
= [2, ]useState
, this.args
no changeNow, if you do something especially with a deferred usage of the value.
function doSomething(v) {
// I need to wait for 10 seconds
// within this period of time
// UI has refreshed multiple times
// I'm in step 4)
console.log(v)
}
// Invoke this function in step 1)
doSomething(value)
You will be given an "old" value, because you pass the current copy (at that time) to it at the first place. Although this.args
gets the latest copy every time, it doesn't mean an old copy get changed. The value you passed isn't reference based. This could be a feature!!
Summary
In order to change it,
object
for the value;useRef
to get latest
value;Although the approach above all fix it (in other answers), the root cause of the problem is that you pass an old value to a function and expect it to run with a future value. I think this is where it went wrong at the first place, which isn't very clear if you just look at the solutions.
Upvotes: 3
Reputation: 81653
You can access the latest state
in setState
callback. But the intention is not clear, we never want to setState
in this case, it may confuse other people when they read your code. So you may want to wrap it in another hook that can express what you want better
function useExtendedState<T>(initialState: T) {
const [state, setState] = React.useState<T>(initialState);
const getLatestState = () => {
return new Promise<T>((resolve, reject) => {
setState((s) => {
resolve(s);
return s;
});
});
};
return [state, setState, getLatestState] as const;
}
const [counter, setCounter, getCounter] = useExtendedState(0);
...
getCounter().then((counter) => /* ... */)
// you can also use await in async callback
const counter = await getCounter();
Upvotes: 11
Reputation: 31007
I encountered a similar bug trying to do exactly the same thing you're doing in your example - using a setInterval
on a callback that references props
or state
from a React component.
Hopefully I can add to the good answers already here by coming at the problem from a slightly different direction - the realisation that it's not even a React problem, but a plain old Javascript problem.
I think what catches one out here is thinking in terms of the React hooks model, where the state variable, just a local variable after all, can be treated as though it's stateful within the context of the React component. You can be sure that at runtime, the value of the variable will always be whatever React is holding under the hood for that particular piece of state.
However, as soon as you break out of the React component context - using the variable in a function inside a setInterval
for instance, the abstraction breaks and you're back to the truth that that state variable really is just a local variable holding a value.
The abstraction allows you to write code as if the value at runtime will always reflect what's in state. In the context of React, this is the case, because what happens is whenever you set the state the entire function runs again and the value of the variable is set by React to whatever the updated state value is. Inside the callback, however, no such thing happens - that variable doesn't magically update to reflect the underlying React state value at call time. It just is what it is when the callback was defined (in this case 0
), and never changes.
Here's where we get to the solution: if the value pointed to by that local variable is in fact a reference to a mutable object, then things change. The value (which is the reference) remains constant on the stack, but the mutable value(s) referenced by it on the heap can be changed.
This is why the technique in the accepted answer works - a React ref provides exactly such a reference to a mutable object. But I think it's really important to emphasise that the 'React' part of this is just a coincidence. The solution, like the problem, has nothing to do with React per-se, it's just that a React ref happens to be one way to get a reference to a mutable object.
You can also use, for instance, a plain Javascript class, holding its reference in React state. To be clear, I'm not suggesting this is a better solution or even advisable (it probably isn't!) but just using it to illustrate the point that there is no 'React' aspect to this solution - it's just Javascript:
class Count {
constructor (val) { this.val = val }
get () { return this.val }
update (val) {
this.val += val
return this
}
}
function Card(title) {
const [count, setCount] = React.useState(new Count(0))
const [callbackSetup, setCallbackSetup] = React.useState(false)
function setupConsoleCallback(callback) {
console.log("Setting up callback")
setInterval(callback, 3000)
}
function clickHandler() {
setCount(count.update(1));
if (!callbackSetup) {
setupConsoleCallback(() => {console.log(`Count is: ${count.get()}`)})
setCallbackSetup(true)
}
}
return (
<div>
Active count {count.get()} <br/>
<button onClick={clickHandler}>Increment</button>
</div>
)
}
const el = document.querySelector("#root");
ReactDOM.render(<Card title='Example Component' />, el);
You can see there that simply by having the state point to a reference, that doesn't change, and mutating the underlying values that the reference points to, you get the behaviour you're after both in the setInterval
closure and in the React component.
Again, this is not idiomatic React, but just illustrates the point about references being the ultimate issue here. Hope it's helpful!
Upvotes: 53
Reputation: 8159
I would use a combination of setInterval()
and useEffect()
.
setInterval()
on its own is problematic, as it might pop after the component has been unmounted. In your toy example this is not a problem, but in the real world it's likely that your callback will want to mutate your component's state, and then it would be a problem.useEffect()
on its own isn't enough to cause something to happen in some period of time.useRef()
is really for those rare occasions where you need to break React's functional model because you have to work with some functionality that doesn't fit (e.g. focusing an input or something), and I would avoid it for situations like this.Your example isn't doing anything very useful, and I'm not sure whether you care about how regular the timer pops are. So the simplest way of achieving roughly what you want using this technique is as follows:
import React from 'react';
const INTERVAL_FOR_TIMER_MS = 3000;
export function Card({ title }) {
const [count, setCount] = React.useState(0)
React.useEffect(
() => {
const intervalId = setInterval(
() => console.log(`Count is ${count}`),
INTERVAL_FOR_TIMER_MS,
);
return () => clearInterval(intervalId);
},
// you only want to restart the interval when count changes
[count],
);
function clickHandler() {
// I would also get in the habit of setting this way, which is safe
// if the increment is called multiple times in the same callback
setCount(num => num + 1);
}
return (
<div>
Active count {count} <br/>
<button onClick={clickHandler}>Increment</button>
</div>
);
}
The caveat is that if the timer pops, then you click a second later, then the next log will be 4 seconds after the previous log because the timer is reset when you click.
If you want to solve that problem, then the best thing will probably be to use Date.now()
to find the current time and use a new useState()
to store the next pop time you want, and use setTimeout()
instead of setInterval()
.
It's a bit more complicated as you have to store the next timer pop, but not too bad. Also that complexity can be abstracted by simply using a new function. So to sum up here's a safe "Reacty" way of starting a periodic timer using hooks.
import React from 'react';
const INTERVAL_FOR_TIMER_MS = 3000;
const useInterval = (func, period, deps) => {
const [nextPopTime, setNextPopTime] = React.useState(
Date.now() + period,
);
React.useEffect(() => {
const timerId = setTimeout(
() => {
func();
// setting nextPopTime will cause us to run the
// useEffect again and reschedule the timeout
setNextPopTime(popTime => popTime + period);
},
Math.max(nextPopTime - Date.now(), 0),
);
return () => clearTimeout(timerId);
}, [nextPopTime, ...deps]);
};
export function Card({ title }) {
const [count, setCount] = React.useState(0);
useInterval(
() => console.log(`Count is ${count}`),
INTERVAL_FOR_TIMER_MS,
[count],
);
return (
<div>
Active count {count} <br/>
<button onClick={() => setCount(num => num + 1)}>
Increment
</button>
</div>
);
}
And as long as you pass all the dependencies of the interval function in the deps
array (exactly like with useEffect()
), you can do whatever you like in the interval function (set state etc.) and be confident nothing will be out of date.
Upvotes: 0
Reputation: 39212
For your scenario (where you cannot keep creating new callbacks and passing them to your 3rd party library), you can use useRef
to keep a mutable object with the current state. Like so:
function Card(title) {
const [count, setCount] = React.useState(0)
const [callbackSetup, setCallbackSetup] = React.useState(false)
const stateRef = useRef();
// make stateRef always have the current count
// your "fixed" callbacks can refer to this object whenever
// they need the current value. Note: the callbacks will not
// be reactive - they will not re-run the instant state changes,
// but they *will* see the current value whenever they do run
stateRef.current = count;
function setupConsoleCallback(callback) {
console.log("Setting up callback")
setInterval(callback, 3000)
}
function clickHandler() {
setCount(count+1);
if (!callbackSetup) {
setupConsoleCallback(() => {console.log(`Count is: ${stateRef.current}`)})
setCallbackSetup(true)
}
}
return (<div>
Active count {count} <br/>
<button onClick={clickHandler}>Increment</button>
</div>);
}
Your callback can refer to the mutable object to "read" the current state. It will capture the mutable object in its closure, and every render the mutable object will be updated with the current state value.
Upvotes: 303
Reputation: 788
The only method i know is to call the setState(current_value => ...) function and use the current_value in ur logic. Just make sure you return it back. Ex:
const myPollingFunction = () => {
setInterval(() => {
setState(latest_value => {
// do something with latest_value
return latest_value;
}
}, 1000);
};
Upvotes: 3
Reputation: 4587
Instead of trying to access the most recent state within a callback, use useEffect
. Setting your state with the function returned from setState
will not immediately update your value. The state updates are batched and updated
It may help if you think of useEffect()
like setState
's second parameter (from class based components).
If you want to do an operation with the most recent state, use useEffect()
which will be hit when the state changes:
const {
useState,
useEffect
} = React;
function App() {
const [count, setCount] = useState(0);
const decrement = () => setCount(count-1);
const increment = () => setCount(count+1);
useEffect(() => {
console.log("useEffect", count);
}, [count]);
console.log("render", count);
return (
<div className="App">
<p>{count}</p>
<button onClick={decrement}>-</button>
<button onClick={increment}>+</button>
</div>
);
}
const rootElement = document.getElementById("root");
ReactDOM.render( < App / > , rootElement);
<script src="https://cdnjs.cloudflare.com/ajax/libs/react/16.8.6/umd/react.production.min.js"></script>
<script src="https://cdnjs.cloudflare.com/ajax/libs/react-dom/16.8.6/umd/react-dom.production.min.js"></script>
<div id="root"></div>
Update
You can create a hook for your setInterval
and call it like this:
const {
useState,
useEffect,
useRef
} = React;
function useInterval(callback, delay) {
const savedCallback = useRef();
// Remember the latest callback.
useEffect(() => {
savedCallback.current = callback;
}, [callback]);
// Set up the interval.
useEffect(() => {
function tick() {
savedCallback.current();
}
if (delay !== null) {
let id = setInterval(tick, delay);
return () => clearInterval(id);
}
}, [delay]);
}
function Card(title) {
const [count, setCount] = useState(0);
const callbackFunction = () => {
console.log(count);
};
useInterval(callbackFunction, 3000);
useEffect(()=>{
console.log('Count has been updated!');
}, [count]);
return (<div>
Active count {count} <br/>
<button onClick={()=>setCount(count+1)}>Increment</button>
</div>);
}
const el = document.querySelector("#root");
ReactDOM.render(<Card title='Example Component'/>, el);
<script src="https://cdnjs.cloudflare.com/ajax/libs/react/16.8.6/umd/react.production.min.js"></script>
<script src="https://cdnjs.cloudflare.com/ajax/libs/react-dom/16.8.6/umd/react-dom.production.min.js"></script>
<div id="root"></div>
Some further info on useEffect()
Upvotes: 5