
```javascript
import React, { useState, useEffect, useRef } from '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]);
}
```

via <https://overreacted.io/making-setinterval-declarative-with-react-hooks/>


A special case for doing intervals in React via hooks.

useInterval


```javascript
function useStateRef(initialState) {
   const [state, setState] = useState(initialState);
   const ref = useRef(state);
   const dispatch = useCallback((val) => {
       ref.current = typeof val === 'function' ?
       val(ref.current) :
       val;
       setState(ref.current);
   }, []);

   return [state, dispatch, ref];
}
```

Example:

```javascript
const [myState, setMyState, myStateRef] = useStateRef(defaultState);
useEffect(() => {
   if(SOMES_CONDITION_STUFF) {
       setTimeoutOrIntervalSomething(() => {
           console.log(myState.current, 'is always correct');
       });
    }
});
```


A way to escape the functional component closure and keep state working.

#codesnippet