Skip to content
🐋 It's react's useEffect hook, except using deep comparison on the inputs, not reference equality
Branch: master
Clone or download
allcontributors and kentcdodds docs: add edygar as a contributor (#5)
* docs: update

* docs: update .all-contributorsrc
Latest commit 4e235bc Apr 7, 2019

use-deep-compare-effect 🐋

It's react's useEffect hook, except using deep comparison on the inputs, not reference equality

Build Status Code Coverage version downloads MIT License

All Contributors PRs Welcome Code of Conduct

Watch on GitHub Star on GitHub Tweet

WARNING: Please only use this if you really can't find a way to use React.useEffect. There's often a better way to do what you're trying to do than do a deep comparison.

The problem

React's built-in useEffect hook has a second argument called the "dependencies array" and it allows you to optimize when React will call your effect callback. React will do a comparison between each of the values (via to determine whether your effect callback should be called.

The problem is that if you need to provide an object for one of those dependencies and that object is new every render, then even if none of the properties changed, your effect will get called anyway.

Here's an example situation:

function Query({query, variables}) {
  // some code...

    () => {},
    // because of the way the Query component is used below, `variables` is a
    // new object every render. This is the problem.
    [query, variables],

  return <div>{/* awesome UI here */}</div>

function QueryPageThing({username}) {
  const query = `
    query getUserData($username: String!) {
      user(login: $username) {
  const variables = {username}
  // poof! Every render `variables` will be a new object!
  return <Query query={query} variables={variables} />

NOTE: you could also solve this problem if the QueryPageThing created the variables object like this: const variables = React.useMemo(() => ({username}), [username]). Then you wouldn't need this package. But sometimes you're writing a custom hook and you don't have control on what kinds of things people are passing you (or you want to give them a nice ergonomic API that can handle new objects every render).

If that <Query /> component uses

This solution

This is a drop-in replacement for React.useEffect for this use-case only.

Note, if you try to use useDeepCompareEffect with only primitive values, you will receive an error because you should use React.useEffect instead.

Table of Contents


This module is distributed via npm which is bundled with node and should be installed as one of your project's dependencies:

npm install --save use-deep-compare-effect


You use it in place of React.useEffect.

NOTE: Only use this if your values are objects or arrays that contain objects. Otherwise you should just use React.useEffect. In case of "polymorphic" values (eg: sometimes object, sometimes a boolean), use useDeepCompareEffectNoCheck, but do it at your own risk, as maybe there can be better approaches to the problem.


import React from 'react'
import ReactDOM from 'react-dom'
import useDeepCompareEffect from 'use-deep-compare-effect'

function Query({query, variables}) {
  // some code...

    () => {
      // make an HTTP request or whatever with the query and variables
      // optionally return a cleanup function if necessary
    // query is a string, but variables is an object. With the way Query is used
    // in the example above, `variables` will be a new object every render.
    // useDeepCompareEffect will do a deep comparison and your callback is only
    // run when the variables object actually has changes.
    [query, variables],

  return <div>{/* awesome UI here */}</div>

Other Solutions

I'm not aware of any, if you are please make a pull request and add it here!


Thanks goes to these people (emoji key):

Kent C. Dodds
Kent C. Dodds

💻 📖 🚇 ⚠️
Edygar de Lima Oliveira
Edygar de Lima Oliveira

💻 ⚠️

This project follows the all-contributors specification. Contributions of any kind welcome!



You can’t perform that action at this time.