Big update!Introducing GitHub Bot Commands. Learn more
Log inDemoInstall


Package Overview
File Explorer

Advanced tools


Fastest deep equal comparison for React. Great for React.memo & shouldComponentUpdate. Also really fast general-purpose deep comparison.


Version published
Weekly downloads
increased by7.02%

Weekly downloads



3.2.0 (2020-05-28)

  • #80. Update types to use generic anys.
  • #77. Add tests for our TypeScript type definitions.




Downloads Bundle Size Travis Status AppVeyor Status Coverage Status npm version Maintenance Status

The fastest deep equal comparison for React. Very quick general-purpose deep comparison, too. Great for React.memo and shouldComponentUpdate.

This is a fork of the brilliant fast-deep-equal with some extra handling for React.

benchmark chart

(Check out the benchmarking details.)


$ yarn add react-fast-compare # or $ npm install react-fast-compare


  • ES5 compatible; works in node.js (0.10+) and browsers (IE9+)
  • deeply compares any value (besides objects with circular references)
  • handles React-specific circular references, like elements
  • checks equality Date and RegExp objects
  • should as fast as fast-deep-equal via a single unified library, and with added guardrails for circular references.
  • small: under 650 bytes minified+gzipped


const isEqual = require("react-fast-compare"); // general usage console.log(isEqual({ foo: "bar" }, { foo: "bar" })); // true // React.memo // only re-render ExpensiveComponent when the props have deeply changed const DeepMemoComponent = React.memo(ExpensiveComponent, isEqual); // React.Component shouldComponentUpdate // only re-render AnotherExpensiveComponent when the props have deeply changed class AnotherExpensiveComponent extends React.Component { shouldComponentUpdate(nextProps) { return !isEqual(this.props, nextProps); } render() { // ... } }

Do I Need React.memo (or shouldComponentUpdate)?

What's faster than a really fast deep comparison? No deep comparison at all.

—This Readme

Deep checks in React.memo or a shouldComponentUpdate should not be used blindly. First, see if the default React.memo or PureComponent will work for you. If it won't (if you need deep checks), it's wise to make sure you've correctly indentified the bottleneck in your application by profiling the performance. After you've determined that you do need deep equality checks and you've identified the minimum number of places to apply them, then this library may be for you!

Benchmarking this Library

The absolute values are much less important than the relative differences between packages.

Benchmarking source can be found here. Each "operation" consists of running all relevant tests. The React benchmark uses both the generic tests and the react tests; these runs will be slower simply because there are more tests in each operation.

The results below are from a local test on a laptop.

Generic Data

react-fast-compare x 157,863 ops/sec ±0.54% (94 runs sampled) fast-deep-equal x 149,877 ops/sec ±0.76% (93 runs sampled) lodash.isEqual x 33,298 ops/sec ±0.70% (93 runs sampled) nano-equal x 144,836 ops/sec ±0.51% (94 runs sampled) shallow-equal-fuzzy x 110,192 ops/sec ±0.57% (95 runs sampled) fastest: react-fast-compare

react-fast-compare and fast-deep-equal should be the same speed for these tests; any difference is just noise. react-fast-compare won't be faster than fast-deep-equal, because it's based on it.

React and Generic Data

react-fast-compare x 64,102 ops/sec ±0.36% (94 runs sampled) fast-deep-equal x 63,844 ops/sec ±0.43% (94 runs sampled) lodash.isEqual x 6,243 ops/sec ±0.72% (90 runs sampled) fastest: react-fast-compare,fast-deep-equal

Two of these packages cannot handle comparing React elements, because they contain circular reference: nano-equal and shallow-equal-fuzzy.

Running Benchmarks

$ yarn install $ yarn run benchmark

Differences between this library and fast-deep-equal

react-fast-compare is based on fast-deep-equal, with some additions:

  • react-fast-compare has try/catch guardrails for stack overflows from undetected (non-React) circular references.
  • react-fast-compare has a single unified entry point for all uses. No matter what your target application is, import equal from 'react-fast-compare' just works. fast-deep-equal has multiple entry points for different use cases.

This version of react-fast-compare tracks [email protected].

Bundle Size

There are a variety of ways to calculate bundle size for JavaScript code. You can see our size test code in the compress script in package.json. Bundlephobia's calculation is slightly higher, as they do not mangle during minification.




Please see our contributions guide.

Maintenance Status

Active: Formidable is actively working on this project, and we expect to continue for work for the foreseeable future. Bug reports, feature requests and pull requests are welcome.



What is react-fast-compare?

Fastest deep equal comparison for React. Great for React.memo & shouldComponentUpdate. Also really fast general-purpose deep comparison.

Is react-fast-compare popular?

The npm package react-fast-compare receives a total of 8,186,076 weekly downloads. As such, react-fast-compare popularity was classified as popular.

Is react-fast-compare well maintained?

We found that react-fast-compare demonstrated a not healthy version release cadence and project activity because the last version was released a year ago.It has 34 open source maintainers collaborating on the project.

Last updated on 28 May 2020

Did you know?

Socket installs a Github app to automatically flag issues on every pull request and report the health of your dependencies. Find out what is inside your node modules and prevent malicious activity before you update the dependencies.

Install Socket
Socket[email protected]


Stay in touch

Get open source security insights delivered straight into your inbox.

  • Terms
  • Privacy
  • Security

Made with ⚡️ by Socket Inc