use-deep-compare-effect

What is use-deep-compare-effect?

The `use-deep-compare-effect` package is a React hook that works similarly to `useEffect`, but it performs a deep comparison of the dependencies to determine if they have changed. This is particularly useful when dealing with complex objects or arrays as dependencies, where shallow comparison would not suffice.

What are use-deep-compare-effect's main functionalities?

Deep Comparison of Dependencies

This feature allows you to use a deep comparison for the dependencies of the effect. In this example, `useDeepCompareEffect` will only re-run the effect if `complexObject` has changed deeply, not just shallowly.

import { useDeepCompareEffect } from 'use-deep-compare-effect';

function MyComponent({ complexObject }) {
  useDeepCompareEffect(() => {
    // Effect logic here
    console.log('complexObject has changed');
  }, [complexObject]);

  return <div>Check the console for updates</div>;
}

Other packages similar to use-deep-compare-effect

react-use

The `react-use` package is a collection of essential React hooks, including `useDeepCompareEffect`. It offers a wide range of hooks for various use cases, making it a more comprehensive solution compared to `use-deep-compare-effect`, which focuses solely on deep comparison for effects.

use-deep-compare

The `use-deep-compare` package provides a hook for deep comparison of dependencies, similar to `use-deep-compare-effect`. However, it is more focused on providing a utility for deep comparison rather than being a full-fledged effect hook.

README

use-deep-compare-effect 🐋

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

---

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 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 Object.is) 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.

Table of Contents

• Installation
• Usage
• Other Solutions
• Issues
  • 🐛 Bugs
  • 💡 Feature Requests
• Contributors ✨
• LICENSE

Installation

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

Usage

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.

NOTE: Be careful when your dependency is an object which contains function. If that function is defined on the object during a render, then it's changed and the effect callback will be called every render. Issue has more context.

Example:

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

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

  useDeepCompareEffect(
    () => {
      // 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

use-custom-compare-effect

Issues

Looking to contribute? Look for the Good First Issue label.

🐛 Bugs

Please file an issue for bugs, missing documentation, or unexpected behavior.

See Bugs

💡 Feature Requests

Please file an issue to suggest new features. Vote on feature requests by adding a 👍. This helps maintainers prioritize what to work on.

See Feature Requests

Contributors ✨

Thanks goes to these people (emoji key):

Kent C. Dodds 💻 📖 🚇 ⚠️	Edygar de Lima Oliveira 💻 ⚠️	Justin Dorfman 🔍	Anton Halim 📖	Michaël De Boey 💻	Tobias Büschel 📖	Peter Hozák 👀
Ricardo Busquet 👀	Dave Johansen 🐛	Sam Knutson 📖	Albert Lucianto 🐛 💻 ⚠️	Jasper Chang 📖	cvolant 💻

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

LICENSE

MIT