fast-equals

中文文档

6.2.2发布于 2026/11/02MITTypeScriptESM + CJS零依赖近 30 天下载 2亿

用于各种用途的快速平等比较工具

文档目录15 节

使用量
可用方法
深等号
浅等价
同一数值
同为等价
严格平等
圆深平方
圆筒平面
严格
严格平面
严格圆深等分
严格圆形平面
创建 CustomEqual
基准

快速对等

执行快点燃两个对象之间的平等比较,同时允许灵活性各种用例。它没有依赖性,在被精密化和被克齐化时为~2.65kB.

以下类型处理出箱: 1

普通物体(包括 react 要素和 Arguments(中文(简体) )
阵列
ArrayBuffer 编号 : TypedArray 编号 : DataView 实例
Date 对象
RegExp 对象
Map 编号 : Set 可移动
Promise 对象和可选对象
Error 对象,包括子类及其自身属性
URL 对象
初级包装器(new Boolean() 编号 : new Number() 编号 : new String()框中输入 BigInt(中文(简体) )
自定义类例,包括土著类的子类

为深、浅、浅、浅、浅、浅、深、浅、浅、浅、浅、浅、浅、浅、深、浅、浅、浅、浅、浅、浅、浅、深、浅、浅、浅、浅、深、浅、浅、浅、浅、浅、浅、浅、浅、浅、浅、浅、浅、浅、浅、浅、浅、浅、深、浅、浅、浅、浅、浅、浅、浅、浅、浅、浅、浅、浅、浅、浅、浅、浅、浅、浅、浅、浅、浅、浅、浅、浅、浅、浅、浅、浅、浅、浅、浅、浅、浅、, SameValue, (中文(简体) ), SameValueZero,或严格平等比较。还有你可选择支持循环对象,或进行与非传统属性定义的"严格"比较, 或两者兼有。也可以根据应用程序的使用大小写自定义任何特定类型比较.

默认情况下, npm 应当根据您的消耗量(ESM vs CommunityJS)解决包的正确构建. 然而,如果您想要强制使用特定的建筑,它们可以在这里找到:

无害环境管理 fast-equals/dist/es/index.mjs
常见JS QQ fast-equals/dist/cjs/index.cjs

如果你有任何问题, 想要求一个新的功能, 或者有任何问题, 请提交一个问题。。。 .

使用量
可用方法
基准

使用量

import { deepEqual } from 'fast-equals';

console.log(deepEqual({ foo: 'bar' }, { foo: 'bar' })); // true

可用方法

深等号

对传递的两个对象进行深刻的平等比较,并返回代表等值的布尔物体.

import { deepEqual } from 'fast-equals';

const objectA = { foo: { bar: 'baz' } };
const objectB = { foo: { bar: 'baz' } };

console.log(objectA === objectB); // false
console.log(deepEqual(objectA, objectB)); // true

比较 `Map`编号

Map 对象支持复杂的密钥(对象、阵列等),但密钥查找的 spec Map 数据基于 SameValueZero。。。 . 如果按照这一分类进行比较,则始终如下: false数字 :

const mapA = new Map([[{ foo: 'bar' }, { baz: 'quz' }]]);
const mapB = new Map([[{ foo: 'bar' }, { baz: 'quz' }]]);

deepEqual(mapA, mapB);

为了支持所有内容的真正平等, fast-equals 将对关键和价值进行深刻的平等比较双人因此,上述情况将是: true。。。 .

浅等价

对传递的两个对象进行浅等比较,并返回代表值的布尔物体的等同性.

import { shallowEqual } from 'fast-equals';

const nestedObject = { bar: 'baz' };

const objectA = { foo: nestedObject };
const objectB = { foo: nestedObject };
const objectC = { foo: { bar: 'baz' } };

console.log(objectA === objectB); // false
console.log(shallowEqual(objectA, objectB)); // true
console.log(shallowEqual(objectA, objectC)); // false

同一数值

执行 a SameValue 比较所通过和返回表示对象等值的布尔。简而言之,这意味着:

+0 财务报告和审定财务报表 -0 不平等
NaN 等于 NaN
所有其他项目都以优惠平等为基础(a === b(中文(简体) )

import { sameValueEqual } from 'fast-equals';

const mainObject = { foo: NaN, bar: 'baz' };

const objectA = 'baz';
const objectB = NaN;
const objectC = { foo: NaN, bar: 'baz' };

console.log(sameValueEqual(mainObject.bar, objectA)); // true
console.log(sameValueEqual(mainObject.foo, objectB)); // true
console.log(sameValueEqual(mainObject, objectC)); // false

页:1: 在支持环境 Object.is, (中文(简体) ), sameValueEqual 这仅仅是这种方法的再出口.

同为等价

执行 a SameValueZero 比较两个对象并返回表示对象等值的布尔值。简而言之,这意味着:

+0 财务报告和审定财务报表 -0 平等
NaN 等于 NaN
所有其他项目都以优惠平等为基础(a === b(中文(简体) )

import { sameValueZeroEqual } from 'fast-equals';

const mainObject = { foo: NaN, bar: 'baz' };

const objectA = 'baz';
const objectB = NaN;
const objectC = { foo: NaN, bar: 'baz' };

console.log(sameValueZeroEqual(mainObject.bar, objectA)); // true
console.log(sameValueZeroEqual(mainObject.foo, objectB)); // true
console.log(sameValueZeroEqual(mainObject, objectC)); // false

严格平等

执行 a 严格平等比较两个对象传递并返回一个布尔表示对象的偏好平等。简而言之,这个表示:

+0 财务报告和审定财务报表 -0 平等
NaN 不等同于 NaN
所有其他项目都以优惠平等为基础(a === b(中文(简体) )

import { strictEqual } from 'fast-equals';

const mainObject = { foo: NaN, bar: 'baz' };

const objectA = 'baz';
const objectB = NaN;
const objectC = { foo: NaN, bar: 'baz' };

console.log(strictEqual(mainObject.bar, objectA)); // true
console.log(strictEqual(mainObject.foo, objectB)); // false
console.log(strictEqual(mainObject, objectC)); // false

页:1:这主要是一种方便功能,例如需要默认的功能平等参照. 当然, 比较一下就快了 a === b. ) (中文(简体) )

圆深平方

进行与 deepEqual 但支持圆形对象。慢过 deepEqual,所以只有在你知道有圆形物体存在.

function Circular(value) {
  this.me = {
    deeply: {
      nested: {
        reference: this,
      },
    },
    value,
  };
}

console.log(circularDeepEqual(new Circular('foo'), new Circular('foo'))); // true
console.log(circularDeepEqual(new Circular('foo'), new Circular('bar'))); // false

和以前一样 deepEqual, (中文(简体) ), 将钥匙和价值进行比较,以实现深度平等。。。 .

圆筒平面

进行与 shallowEqual 但支持圆形对象。慢过 shallowEqual因此,仅如果您知道存在圆形物体,则使用.

const array = ['foo'];

array.push(array);

console.log(circularShallowEqual(array, ['foo', array])); // true
console.log(circularShallowEqual(array, [array])); // false

严格

进行与 deepEqual 但要严格比较对象。这包括:

正在检查符号属性
检查对象比较中的不可假定属性
检查对象上属性的完整描述符以匹配
检查数组中的非索引属性
正在检查非密钥属性 Map 编号 : Set 对象
检查自己的属性 Date 对象

const array = [{ foo: 'bar' }];
const otherArray = [{ foo: 'bar' }];

array.bar = 'baz';
otherArray.bar = 'baz';

console.log(strictDeepEqual(array, otherArray)); // true
console.log(strictDeepEqual(array, [{ foo: 'bar' }])); // false

严格平面

进行与 shallowEqual 但要严格比较对象。这包括:

检查对象比较中的不可假定属性
检查对象上属性的完整描述符以匹配
检查数组中的非索引属性
正在检查非密钥属性 Map 编号 : Set 对象
检查自己的属性 Date 对象

const array = ['foo'];
const otherArray = ['foo'];

array.bar = 'baz';
otherArray.bar = 'baz';

console.log(strictShallowEqual(array, otherArray)); // true
console.log(strictShallowEqual(array, ['foo'])); // false

严格圆深等分

进行与 circularDeepEqual 但要严格比较对象。这包括:

检查中 Symbol 对象的属性
检查对象比较中的不可假定属性
检查对象上属性的完整描述符以匹配
检查数组中的非索引属性
正在检查非密钥属性 Map 编号 : Set 对象
检查自己的属性 Date 对象

function Circular(value) {
  this.me = {
    deeply: {
      nested: {
        reference: this,
      },
    },
    value,
  };
}

const first = new Circular('foo');

Object.defineProperty(first, 'bar', {
  enumerable: false,
  value: 'baz',
});

const second = new Circular('foo');

Object.defineProperty(second, 'bar', {
  enumerable: false,
  value: 'baz',
});

console.log(strictCircularDeepEqual(first, second)); // true
console.log(strictCircularDeepEqual(first, new Circular('foo'))); // false

严格圆形平面

进行与 circularShallowEqual 但要严格比较对象。这包括:

检查对象比较中的不可假定属性
检查对象上属性的完整描述符以匹配
检查数组中的非索引属性
正在检查非密钥属性 Map 编号 : Set 对象
检查自己的属性 Date 对象

const array = ['foo'];
const otherArray = ['foo'];

array.push(array);
otherArray.push(array); // Shallow comparison requires the same nested reference.

array.bar = 'baz';
otherArray.bar = 'baz';

console.log(strictCircularShallowEqual(array, otherArray)); // true
console.log(strictCircularShallowEqual(array, ['foo', array])); // false

创建 CustomEqual

创建自定义平等参照器,用于对象中的嵌入值。与 deepEqual 财务报告和审定财务报表 shallowEqual,这是工厂方法,接收内部使用的默认选项,并允许您覆盖默认值。这通常适用于极端边缘情况,或支持遗留环境.

签字情况如下:

interface Cache<Key extends object, Value> {
  delete(key: Key): boolean;
  get(key: Key): Value | undefined;
  set(key: Key, value: any): any;
}

interface ComparatorConfig<Meta> {
  areArrayBuffersEqual: EqualityComparator<Meta>;
  areArraysEqual: EqualityComparator<Meta>;
  areDataViewsEqual: EqualityComparator<Meta>;
  areDatesEqual: EqualityComparator<Meta>;
  areErrorsEqual: EqualityComparator<Meta>;
  areFunctionsEqual: EqualityComparator<Meta>;
  areMapsEqual: EqualityComparator<Meta>;
  areNumbersEqual: EqualityComparator<Meta>;
  areObjectsEqual: EqualityComparator<Meta>;
  arePrimitiveWrappersEqual: EqualityComparator<Meta>;
  areRegExpsEqual: EqualityComparator<Meta>;
  areSetsEqual: EqualityComparator<Meta>;
  areTypedArraysEqual: EqualityComparator<Meta>;
  areUrlsEqual: EqualityComparator<Meta>;
  getUnsupportedCustomComparator:
    (<Type>(a: Type, b: Type, state: State<Meta>, tag: string) => EqualityComparator<Meta> | undefined) | undefined;
  strictNullPrototypeComparison?: boolean;
}

function createCustomEqual<Meta>(options: {
  circular?: boolean;
  createCustomConfig?: (defaultConfig: ComparatorConfig<Meta>) => Partial<ComparatorConfig<Meta>>;
  createInternalComparator?: (
    compare: <A, B>(a: A, b: B, state: State<Meta>) => boolean,
  ) => (a: any, b: any, indexOrKeyA: any, indexOrKeyB: any, parentA: any, parentB: any, state: State<Meta>) => boolean;
  createState?: () => { cache?: Cache; meta?: Meta };
  strict?: boolean;
  strictNullPrototypeComparison?: boolean;
}): <A, B>(a: A, b: B) => boolean;

创建自定义平等比较器。这样可以完全控制一种讲求平等的方法的建立,如果您使用案例需要更高程度的性能、遗留的环境支持或任何其他非标准使用。这个食谱提供不同用例中的用法实例,但如果您有特定的目标,并且会像援助感觉自由提交问题。。。 .

页:1数字 : Map 执行中比较了键和值的平等性。使用自定义比较器和比较时键的等同性,重复索引作为两个 indexOrKeyA 财务报告和审定财务报表 indexOrKeyB 帮助使用中将关键事项排序为平等.

严格Null Prototype 比较

默认为 true,它保持一个无原型物体(Object.create(null)(a) 与原为相同的平原不平等对象。准备吧 false 来比较这两个字典,例如: ProseMiror 节点属性或者说 Object.groupBy 结果.

const equal = createCustomEqual({ strictNullPrototypeComparison: false });
const attrs = Object.assign(Object.create(null), { aspectRatio: 16 / 9 });

equal(attrs, { ...attrs }); // true

这是构造器检查的唯一例外: 无效原型对象对阵列仍然不平等, Maps,日期, 以及不同的阶级建筑师彼此之间仍然不平等它适用于嵌入值并且能够与 circular, (中文(简体) ), strict和自定义比较器.

获取未支持的客户端

如果您想要比较标记未处理的对象( 如自定义) Symbol.toStringTag 或一个 WeakMap您可以提供 getUnsupportedCustomComparator 方法。它得到两个数值, 比较状态, 和标签,并返回用于它们的比较器。正在返回 undefined 将值视为不平等。见此食谱举个例子.

食谱

已经创建了一些食谱,以提供使用实例 createCustomEqual即使不直接适用对于你正在解决的问题, 他们可以提供指导如何构建你的解决方案.

基准

所有基准都是在使用NodeJS版本的有64GB内存的i9-1100H Ubuntu Linux 24.04笔记本电脑上实现的 24.15.0,并基于基于以下对象类型高度平等的运行比较平均值:

初级String, (中文(简体) ), Number, (中文(简体) ), null, (中文(简体) ), undefined(中文(简体) )
Function
Object
Array
Date
RegExp
react 要素
上述所有类型组合在一起的混合对象

Testing mixed objects equal...
┌────────────────────────────────────────┬────────────────┐
│ Name                                   │ Ops / sec      │
├────────────────────────────────────────┼────────────────┤
│ fast-equals (passed)                   │ 1763109.81851  │
├────────────────────────────────────────┼────────────────┤
│ fast-deep-equal (passed)               │ 1297247.799465 │
├────────────────────────────────────────┼────────────────┤
│ react-fast-compare (passed)            │ 1271146.258704 │
├────────────────────────────────────────┼────────────────┤
│ shallow-equal-fuzzy (passed)           │ 1235115.693854 │
├────────────────────────────────────────┼────────────────┤
│ nano-equal (failed)                    │ 964815.367752  │
├────────────────────────────────────────┼────────────────┤
│ fast-equals (circular) (passed)        │ 834232.686567  │
├────────────────────────────────────────┼────────────────┤
│ dequal (passed)                        │ 759417.072806  │
├────────────────────────────────────────┼────────────────┤
│ dequal/lite (passed)                   │ 751901.517376  │
├────────────────────────────────────────┼────────────────┤
│ underscore.isEqual (passed)            │ 447789.934941  │
├────────────────────────────────────────┼────────────────┤
│ assert.deepStrictEqual (passed)        │ 433256.455121  │
├────────────────────────────────────────┼────────────────┤
│ es-toolkit (passed)                    │ 343382.909087  │
├────────────────────────────────────────┼────────────────┤
│ fast-equals (strict) (passed)          │ 294211.792998  │
├────────────────────────────────────────┼────────────────┤
│ lodash.isEqual (passed)                │ 290477.460766  │
├────────────────────────────────────────┼────────────────┤
│ fast-equals (strict circular) (passed) │ 232110.748904  │
├────────────────────────────────────────┼────────────────┤
│ deep-eql (passed)                      │ 161408.4511    │
├────────────────────────────────────────┼────────────────┤
│ deep-equal (passed)                    │ 951.279346     │
└────────────────────────────────────────┴────────────────┘

Testing mixed objects not equal...
┌────────────────────────────────────────┬────────────────┐
│ Name                                   │ Ops / sec      │
├────────────────────────────────────────┼────────────────┤
│ fast-equals (passed)                   │ 5402008.064431 │
├────────────────────────────────────────┼────────────────┤
│ fast-equals (circular) (passed)        │ 3687783.563818 │
├────────────────────────────────────────┼────────────────┤
│ fast-deep-equal (passed)               │ 3479884.479164 │
├────────────────────────────────────────┼────────────────┤
│ react-fast-compare (passed)            │ 3356141.586592 │
├────────────────────────────────────────┼────────────────┤
│ fast-equals (strict) (passed)          │ 2927133.435788 │
├────────────────────────────────────────┼────────────────┤
│ fast-equals (strict circular) (passed) │ 1566187.833636 │
├────────────────────────────────────────┼────────────────┤
│ dequal/lite (passed)                   │ 1316031.262808 │
├────────────────────────────────────────┼────────────────┤
│ dequal (passed)                        │ 1298255.762153 │
├────────────────────────────────────────┼────────────────┤
│ shallow-equal-fuzzy (failed)           │ 1219217.578795 │
├────────────────────────────────────────┼────────────────┤
│ nano-equal (passed)                    │ 1074115.593615 │
├────────────────────────────────────────┼────────────────┤
│ underscore.isEqual (passed)            │ 659016.868085  │
├────────────────────────────────────────┼────────────────┤
│ lodash.isEqual (passed)                │ 374944.853605  │
├────────────────────────────────────────┼────────────────┤
│ es-toolkit (passed)                    │ 355882.255615  │
├────────────────────────────────────────┼────────────────┤
│ deep-eql (passed)                      │ 182235.73069   │
├────────────────────────────────────────┼────────────────┤
│ assert.deepStrictEqual (passed)        │ 20975.582116   │
├────────────────────────────────────────┼────────────────┤
│ deep-equal (passed)                    │ 3760.574487    │
└────────────────────────────────────────┴────────────────┘

影响基准的洞穴(和比较的准确性):

Maps, (中文(简体) ), Promises,和 Sets 完全排除在基准之外,因为除了图书馆之外没有其他图书馆 deep-eql 完全支持它们的比较
fast-deep-equal, (中文(简体) ), react-fast-compare 财务报告和审定财务报表 nano-equal 在对象上投掷 null 作为原型 (单位:千美元)Object.create(null)(中文(简体) )
assert.deepStrictEqual 不支持 NaN 或者说 SameValue 日期平等
deep-eql 不支持 SameValue 平等与零平等(正与负0不相等)
deep-equal 不支持 NaN 并且不严格比较对象类型,或日期/正则解释值,也不使用 SameValue 日期平等
fast-deep-equal 不支持 NaN 或者说 SameValue 日期平等
nano-equal 不严格比较对象属性结构、阵列长度或对象类型,也不 SameValue 日期平等
react-fast-compare 不支持 NaN 或者说 SameValue 日期平等,而不作比较 function 平等
shallow-equal-fuzzy 不严格比较对象类型或正则解释值,也不 SameValue 日期平等
underscore.isEqual 不支持 SameValue 原始人或日期的平等

所有这些都有可能夸大各图书馆的数目,而与之相比,这些图书馆的数量可能增加 fast-equals但它确实苹果对苹果最接近的比较我可以创建一个合理的样本大小。应当指出 react 元素可以是循环对象,而无论简单的元素不是;我保留了 react 比较非常基本,允许将列入.

版本与发布记录

fast-equals 共发布 87 个版本，首次发布于 2017/10/16；过去 12 个月发布了 22 个版本。

版本	发布日期	距今
`6.2.2`latest	2026/11/02	4 天前
`6.2.1`	2026/10/15	22 天前
`5.4.5`latest-v5	2026/10/14	22 天前
`6.2.0`	2026/10/14	22 天前
`6.1.1`	2026/10/09	28 天前
`5.4.4`	2026/10/09	28 天前

其他发布通道：next → 6.0.0-rc.1，latest-v5 → 5.4.5。

关于 fast-equals 的常见问题

fast-equals 是什么？

用于各种用途的快速平等比较工具

如何安装 fast-equals？

在项目目录运行 npm install fast-equals，或使用 pnpm add / yarn add / bun add。

fast-equals 支持 TypeScript 吗？

支持。包内自带 TypeScript 类型声明（package.json 声明了 types 入口），安装后即可获得类型提示，无需再安装 @types 包。

fast-equals 支持 ESM 还是 CommonJS？

同时提供 ES Module 与 CommonJS 入口，import 和 require() 都可以使用，打包工具会自动选择合适的版本。

fast-equals 需要什么版本的 Node.js？

package.json 的 engines 字段要求 Node.js >=6.0.0。版本不符时 npm 默认只给出警告，开启 engine-strict 后会拒绝安装。

fast-equals 可以商用吗？

fast-equals 使用 MIT 许可。宽松许可：允许商业使用、修改和再分发，通常只需在分发时保留原版权与许可声明。以上为概括，不构成法律意见，请以许可原文为准。

fast-equals 的下载量有多少？

根据 npm 官方下载统计，fast-equals 在 2026/10/05 – 2026/11/03 这 30 天内被下载 195,414,500 次，日均约 6,513,817 次。下载量会把 CI 构建、镜像同步和作为其他包依赖的安装一并计入，适合横向比较热度，不能直接等同于使用人数。

fast-equals 还在维护吗？

最新版本 6.2.2 发布于 2026/11/02（4 天前）；至今共发布 87 个版本，其中过去 12 个月发布了 22 个；首次发布于 2017/10/16。发布频率只是参考信号：功能稳定的工具可能很少需要更新，建议结合源码仓库的 issue 和提交记录判断。