# fast-equals 中文文档

规范地址：https://npmcn.com/package/fast-equals/

版本：6\.2\.2
npm 元数据更新时间：2026-11-01T21:48:35.597Z
中文译文更新时间：2026-11-05T16:29:27.123Z
软件包许可：MIT

本文由上游 README 翻译，可能存在偏差，请结合原文核对 API、命令与配置。版权与许可归原作者所有。

原始 npm 页面：https://www.npmjs.com/package/fast-equals
原文对照：https://npmcn.com/package/fast-equals/?lang=original
项目主页：https://github.com/planttheidea/fast-equals#readme
源码仓库：https://github.com/planttheidea/fast-equals

## 关键信息（来自 npm 元数据）

- 包体积（解压后）：128 kB，8 个文件
- 模块格式：ESM + CJS
- TypeScript 类型：包内自带
- Node.js 要求：\>=6\.0\.0
- 运行依赖：0 个
- 首次发布：2017-10-15T20:56:15.678Z
- 最新版本发布：2026-11-01T21:48:35.464Z
- 近 30 天下载量：195414500（2026-10-05 至 2026-11-03，npm 官方下载统计）
- 已发布版本数：87（近 12 个月 22 个）

## 中文简介

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

## 安装

```sh
npm install fast-equals
```

也可以使用：`pnpm add fast-equals`、`yarn add fast-equals`、`bun add fast-equals`

## README

> 快速对等

执行 [快点燃](https://npmcn.com/package/fast-equals/#readme-benchmarks) 两个对象之间的平等比较,同时允许灵活性 各种用例。 它没有依赖性,在被精密化和被克齐化时为~2.65kB.

以下类型处理出箱: 1

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

为深、浅、浅、浅、浅、浅、深、浅、浅、浅、浅、浅、浅、浅、深、浅、浅、浅、浅、浅、浅、浅、深、浅、浅、浅、浅、深、浅、浅、浅、浅、浅、浅、浅、浅、浅、浅、浅、浅、浅、浅、浅、浅、浅、深、浅、浅、浅、浅、浅、浅、浅、浅、浅、浅、浅、浅、浅、浅、浅、浅、浅、浅、浅、浅、浅、浅、浅、浅、浅、浅、浅、浅、浅、浅、浅、浅、浅、, [`SameValue`](https://262.ecma-international.org/7.0/#sec-samevalue), (中文(简体) ), [`SameValueZero`](https://262.ecma-international.org/7.0/#sec-samevaluezero),或 [严格平等](https://262.ecma-international.org/7.0/#sec-strict-equality-comparison) 比较。 还有你 可选择支持循环对象,或进行与非传统属性定义的"严格"比较, 或两者兼有。 也可以根据应用程序的使用大小写自定义任何特定类型比较.

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

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

如果你有任何问题, 想要求一个新的功能, 或者有任何问题, [请提交一个问题](https://github.com/planttheidea/fast-equals/issues)。 。 。 .

-   [使用量](https://npmcn.com/package/fast-equals/#readme-usage)
-   [可用方法](https://npmcn.com/package/fast-equals/#readme-available-methods)
    -   [深等号](https://npmcn.com/package/fast-equals/#readme-deepequal)
        -   [比较 `Map`编号](https://npmcn.com/package/fast-equals/#readme-comparing-maps)
    -   [浅等价](https://npmcn.com/package/fast-equals/#readme-shallowequal)
    -   [同一数值](https://npmcn.com/package/fast-equals/#readme-samevalueequal)
    -   [同为等价](https://npmcn.com/package/fast-equals/#readme-samevaluezeroequal)
    -   [严格平等](https://npmcn.com/package/fast-equals/#readme-strictequal)
    -   [圆深平方](https://npmcn.com/package/fast-equals/#readme-circulardeepequal)
    -   [圆筒平面](https://npmcn.com/package/fast-equals/#readme-circularshallowequal)
    -   [严格](https://npmcn.com/package/fast-equals/#readme-strictdeepequal)
    -   [严格平面](https://npmcn.com/package/fast-equals/#readme-strictshallowequal)
    -   [严格圆深等分](https://npmcn.com/package/fast-equals/#readme-strictcirculardeepequal)
    -   [严格圆形平面](https://npmcn.com/package/fast-equals/#readme-strictcircularshallowequal)
    -   [创建 CustomEqual](https://npmcn.com/package/fast-equals/#readme-createcustomequal)
        -   [严格Null Prototype 比较](https://npmcn.com/package/fast-equals/#readme-strictnullprototypecomparison)
        -   [获取未支持的客户端](https://npmcn.com/package/fast-equals/#readme-getunsupportedcustomcomparator)
        -   [食谱](https://npmcn.com/package/fast-equals/#readme-recipes)
-   [基准](https://npmcn.com/package/fast-equals/#readme-benchmarks)

## 使用量

```ts
import { deepEqual } from 'fast-equals';

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

## 可用方法

### 深等号

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

```ts
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`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map#key_equality)。 。 。 . 如果按照这一分类进行比较,则始终如下: `false`数字 :

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

deepEqual(mapA, mapB);
```

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

### 浅等价

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

```ts
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`](https://262.ecma-international.org/7.0/#sec-samevalue) 比较所通过和 返回表示对象等值的布尔。 简而言之,这意味着:

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

```ts
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`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/is), (中文(简体) ), `sameValueEqual` 这仅仅是这种方法的再出口._

### 同为等价

执行 a [`SameValueZero`](https://262.ecma-international.org/7.0/#sec-samevaluezero) 比较两个对象 并返回表示对象等值的布尔值。 简而言之,这意味着:

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

```ts
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 [严格平等](https://262.ecma-international.org/7.0/#sec-strict-equality-comparison) 比较 两个对象传递并返回一个布尔表示对象的偏好平等。 简而言之,这个 表示:

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

```ts
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`,所以只有在 你知道有圆形物体存在.

```ts
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`, (中文(简体) ), [将钥匙和价值进行比较,以实现深度平等](https://npmcn.com/package/fast-equals/#readme-comparing-maps)。 。 。 .

### 圆筒平面

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

```ts
const array = ['foo'];

array.push(array);

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

### 严格

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

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

```ts
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` 对象

```ts
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` 对象

```ts
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` 对象

```ts
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`,这是工厂方法,接收内部使用的默认选项,并允许您覆盖 默认值。 这通常适用于极端边缘情况,或支持遗留环境.

签字情况如下:

```ts
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;
```

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

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

#### 严格Null Prototype 比较

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

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

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

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

#### 获取未支持的客户端

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

#### 食谱

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

-   [遗产环境支持 `RegExp` 比较者](https://npmcn.com/package/fast-equals/recipes/legacy-regexp-support.md)
-   [明确财产检查](https://npmcn.com/package/fast-equals/recipes/explicit-property-check.md)
-   [使用 `meta` 比较](https://npmcn.com/package/fast-equals/recipes/using-meta-in-comparison.md)
-   [比较非标准属性](https://npmcn.com/package/fast-equals/recipes/non-standard-properties.md)
-   [对循环平等比较者的遗留环境支持](https://npmcn.com/package/fast-equals/recipes/legacy-circular-equal-support.md)
-   [自定义比较器支持](https://npmcn.com/package/fast-equals/recipes/special-objects.md)

## 基准

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

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

```bash
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    │
└────────────────────────────────────────┴────────────────┘
```

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

-   `Map`s, (中文(简体) ), `Promise`s,和 `Set`s 完全排除在基准之外,因为除了图书馆之外没有其他图书馆 `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 是什么？

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

### 如何安装 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 和提交记录判断。