React Hook recipe from https://usehooks.com. Demo: https://codesandbox.io/s/pwnl6v7z6m

use-previous-example.jsx

import { useState, useEffect, useRef } from 'react';

// Usage
function App() {
  // State value and setter for our example
  const [count, setCount] = useState(0);
  
  // Get the previous value (was passed into hook on last render)
  const prevCount = usePrevious(count);
  
  // Display both current and previous count value
  return (
    <div>
      <h1>Now: {count}, before: {prevCount}</h1>
      <button onClick={() => setCount(count + 1)}>Increment</button>
    </div>
   );
}

// Hook
function usePrevious(value) {
  // The ref object is a generic container whose current property is mutable ...
  // ... and can hold any value, similar to an instance property on a class
  const ref = useRef();
  
  // Store current value in ref
  useEffect(() => {
    ref.current = value;
  }, [value]); // Only re-run if value changes
  
  // Return previous value (happens before update in useEffect above)
  return ref.current;
}

Love all the comments in the custom hook function!

Just an optimization, not sooooo inportant

useEffect(() => {
    ref.current = value;
  }, [value]); // only run if and only if value is changed

@ritwickdey Thanks, code updated!

I wrote the following alternative which (even if it looks a bit complicated) can get around with just a single useState and should increase performance a lot because it does not need to check if the effect needs to run on every render.

import { useState, Dispatch, SetStateAction } from 'react';

type SetStateFn<T> = (previousValue: T) => T;

type IValueWrapper<T> = [
    /** value */
    T,
    /** setValue */
    Dispatch<SetStateAction<T>>,
    /** previousValue */
    T | undefined
];

/**
 * Drop-in replacement for react useState which also returns previousValue.
 * @return [value, setValue, previousValue]
 */
export default function useStateWithPrevious<T>(initialValue: T) {
    const createSetStateDispatch: (previousValue: T) => Dispatch<SetStateAction<T>> = previousValue => value => {
        const newValue = typeof value === 'function' ? (value as SetStateFn<T>)(previousValue) : value;
        setValueWrapper([
            newValue,
            createSetStateDispatch(newValue),
            previousValue,
        ]);
    };
    const [valueWrapper, setValueWrapper] = useState<IValueWrapper<T>>(() => [
        initialValue,
        createSetStateDispatch(initialValue),
        undefined,
    ]);
    return valueWrapper;
}

Clean up

function usePrevious(value) {
  // The ref object is a generic container whose current property is mutable ...
  // ... and can hold any value, similar to an instance property on a class
  const ref = useRef();
  
  // Store current value in ref
  useEffect(() => {
    ref.current = value;
    // Clean Up
    return () => {
          ref.current = null;
    }
  }, [value]); // Only re-run if value changes

(cc @AmaanKulshreshtha )

The function doesn't quite do what I expected it to do. If another state changes and renders the component again, ref.current === value applies.
I have adapted the function so that it reacts as I expect it to:

function usePrevious(value) {
  const ref = useRef({ v: value, prev: undefined });

  // update `ref` only, if the value really changes,
  // the previous value is kept persistent in `prev`,
  // so it also contains the previous value for
  // further renders with the same `value`.
  if (ref.current.v !== value) {
    ref.current = {
      prev: ref.current.v, 
      v: value 
    };
  }

  return ref.current.prev;
}

import { useState, useEffect, useRef } from 'react';
to
import React, { useState, useEffect, useRef } from 'react';