# deep-eql

> Improved deep equality testing for Node.js and the browser.

Latest version **5.0.2** (published 2024-06-03) · MIT license · 0 weekly downloads

## Install

```sh
npm install deep-eql
pnpm add deep-eql
yarn add deep-eql
bun add deep-eql
```

## Health

**Score 43/100 (D)** — status: abandoned.

Positive: has types package; esm support; no vulnerabilities; high maintenance score; high quality score.

Warnings: low downloads.

Negative: abandoned.

## Facts

| | |
|---|---|
| Version | 5.0.2 |
| Published | 2024-06-03 |
| First published | 2013-09-18 |
| Weekly downloads | 0 |
| License | MIT |
| TypeScript types | separate (@types/deep-eql) |
| Module format | ESM + CommonJS |
| Node | >=6 |
| Dependencies | 0 |
| Unpacked size | 23.3 KB |
| Known vulnerabilities | 0 |
| Install scripts | no |
| GitHub stars | 112 |
| Author | Jake Luer |
| Maintainers | chaijs |
| Keywords | chai util, deep equal, object equal, testing |

## Links

- npm: https://www.npmjs.com/package/deep-eql
- Repository: https://github.com/chaijs/deep-eql
- Homepage: https://github.com/chaijs/deep-eql#readme
- Issues: https://github.com/chaijs/deep-eql/issues
- npm.io page: https://npm.io/package/deep-eql

## Alternatives

- [duck](https://npm.io/package/duck.md) — 4.2M weekly downloads
- [ava](https://npm.io/package/ava.md) — 560.2K weekly downloads
- [storybook-addon-module-mock](https://npm.io/package/storybook-addon-module-mock.md) — 71.7K weekly downloads
- [vest](https://npm.io/package/vest.md) — 50.1K weekly downloads
- [@ethereum-waffle/mock-contract](https://npm.io/package/@ethereum-waffle/mock-contract.md) — 40.0K weekly downloads

## Recent versions

- 5.0.2 (latest) — 2024-06-03
- 4.1.4 (legacy) — 2024-06-05
- 5.0.1 — 2023-10-25
- 5.0.0 — 2023-10-18
- 4.1.3 — 2022-12-05
- 4.1.2 — 2022-11-07
- 4.1.1 — 2022-09-20
- 4.1.0 — 2022-06-27
- 4.0.1 — 2022-02-28
- 4.0.0 — 2018-10-15
- 3.0.1 — 2017-09-06
- 3.0.0 — 2017-08-05
- 2.0.2 — 2017-05-05
- 2.0.1 — 2016-11-15
- 2.0.0 — 2016-11-03
- … 8 more at https://npm.io/package/deep-eql/versions

## README

<h1 align=center>
  <a href="http://chaijs.com" title="Chai Documentation">
    <img alt="deep-eql" src="https://raw.githubusercontent.com/chaijs/deep-eql/main/deep-eql-logo.svg"/>
  </a>
</h1>

<p align=center>
  Improved deep equality testing for <a href="http://nodejs.org/">node</a> and the browser.
</p>

<p align=center>
  <a href="https://github.com/chaijs/deep-eql/actions">
    <img
      alt="build:?"
      src="https://github.com/chaijs/deep-eql/workflows/Build/badge.svg"
    />
  </a><a href="https://coveralls.io/r/chaijs/deep-eql">
    <img
      alt="coverage:?"
      src="https://img.shields.io/coveralls/chaijs/deep-eql/master.svg?style=flat-square"
    />
  </a><a href="https://www.npmjs.com/packages/deep-eql">
    <img
      alt="dependencies:?"
      src="https://img.shields.io/npm/dm/deep-eql.svg?style=flat-square"
    />
  </a><a href="">
    <img
      alt="devDependencies:?"
      src="https://img.shields.io/david/chaijs/deep-eql.svg?style=flat-square"
    />
  </a>
  <br>
  <a href="https://chai-slack.herokuapp.com/">
    <img
      alt="Join the Slack chat"
      src="https://img.shields.io/badge/slack-join%20chat-E2206F.svg?style=flat-square"
    />
  </a>
  <a href="https://gitter.im/chaijs/deep-eql">
    <img
      alt="Join the Gitter chat"
      src="https://img.shields.io/badge/gitter-join%20chat-D0104D.svg?style=flat-square"
    />
  </a>
</p>

## What is Deep-Eql?

Deep Eql is a module which you can use to determine if two objects are "deeply" equal - that is, rather than having referential equality (`a === b`), this module checks an object's keys recursively, until it finds primitives to check for referential equality. For more on equality in JavaScript, read [the comparison operators article on mdn](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Comparison_Operators).

As an example, take the following:

```js
1 === 1 // These are primitives, they hold the same reference - they are strictly equal
1 == '1' // These are two different primitives, through type coercion they hold the same value - they are loosely equal
{ a: 1 } !== { a: 1 } // These are two different objects, they hold different references and so are not strictly equal - even though they hold the same values inside
{ a: 1 } != { a: 1 } // They have the same type, meaning loose equality performs the same check as strict equality - they are still not equal.

var deepEql = require("deep-eql");
deepEql({ a: 1 }, { a: 1 }) === true // deepEql can determine that they share the same keys and those keys share the same values, therefore they are deeply equal!
```

## Installation

### Node.js

`deep-eql` is available on [npm](http://npmjs.org).

    $ npm install deep-eql

## Usage

The primary export of `deep-eql` is function that can be given two objects to compare. It will always return a boolean which can be used to determine if two objects are deeply equal.

### Rules

- Strict equality for non-traversable nodes according to [`Object.is`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/is):
  - `eql(NaN, NaN).should.be.true;`
  - `eql(-0, +0).should.be.false;`
- All own and inherited enumerable properties are considered:
  - `eql(Object.create({ foo: { a: 1 } }), Object.create({ foo: { a: 1 } })).should.be.true;`
  - `eql(Object.create({ foo: { a: 1 } }), Object.create({ foo: { a: 2 } })).should.be.false;`
- When comparing `Error` objects, only `name`, `message`, and `code` properties are considered, regardless of enumerability:
  - `eql(Error('foo'), Error('foo')).should.be.true;`
  - `eql(Error('foo'), Error('bar')).should.be.false;`
  - `eql(Error('foo'), TypeError('foo')).should.be.false;`
  - `eql(Object.assign(Error('foo'), { code: 42 }), Object.assign(Error('foo'), { code: 42 })).should.be.true;`
  - `eql(Object.assign(Error('foo'), { code: 42 }), Object.assign(Error('foo'), { code: 13 })).should.be.false;`
  - `eql(Object.assign(Error('foo'), { otherProp: 42 }), Object.assign(Error('foo'), { otherProp: 13 })).should.be.true;`
- Arguments are not Arrays:
  - `eql([], arguments).should.be.false;`
  - `eql([], Array.prototype.slice.call(arguments)).should.be.true;`

---
_Source: https://npm.io/package/deep-eql · Machine-readable twin of the npm.io package page. Health data is recomputed on every publish._