# @art-suite/art-core-ts-compare 中文文档

规范地址：https://npmcn.com/package/%40art-suite/art-core-ts-compare/

版本：0\.1\.2
npm 元数据更新时间：2026-06-19T10:23:02.915Z
中文译文更新时间：2026-11-06T20:39:32.089Z
软件包许可：MIT

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

原始 npm 页面：https://www.npmjs.com/package/%40art-suite/art-core-ts-compare
原文对照：https://npmcn.com/package/%40art-suite/art-core-ts-compare/?lang=original
项目主页：https://github.com/art-suite/art-suite-ts#readme
源码仓库：https://github.com/art-suite/art-suite-ts

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

- 包体积（解压后）：49.9 kB，9 个文件
- 模块格式：ESM + CJS
- TypeScript 类型：包内自带
- 运行依赖：2 个
- 首次发布：2025-06-23T14:20:56.403Z
- 最新版本发布：2026-06-19T10:23:02.793Z
- 近 30 天下载量：3226（2026-10-07 至 2026-11-05，npm 官方下载统计）
- 已发布版本数：12（近 12 个月 6 个）

## 中文简介

类型脚本比较工具库

## 安装

```sh
npm install @art-suite/art-core-ts-compare
```

也可以使用：`pnpm add @art-suite/art-core-ts-compare`、`yarn add @art-suite/art-core-ts-compare`、`bun add @art-suite/art-core-ts-compare`

## README

# @art-site/art-core-ts-compare (英语)

深度平等,不平等,低于和大于比较 - 完全与自定义对象支持相通.

## 快速启动 - 平等函数

使用此库的最简单方法是具有标准平等功能:

```ts
import { eq, neq, lt, gt, lte, gte } from "@art-suite/art-core-ts-compare";

// Basic equality
eq(5, 5); // true
eq([1, 2], [1, 2]); // true
eq({ a: 1 }, { a: 1 }); // true
eq(null, null); // true

// Inequality
neq(5, 10); // true
neq([1, 2], [1, 3]); // true
neq({ a: 1 }, { a: 2 }); // true

// Less than / Greater than
lt(5, 10); // true
lt("a", "z"); // true
lt([1, 2], [1, 2, 3]); // true
lt({ a: 1 }, { a: 1, b: 2 }); // true (missing key)

gt(10, 5); // true
gt("z", "a"); // true
gt([1, 2, 3], [1, 2]); // true

// Less than or equal / Greater than or equal
lte(5, 5); // true
lte(5, 10); // true
gte(10, 10); // true
gte(10, 5); // true

// Custom objects with comparison methods
class Box {
  constructor(public value: number) {}
  compare(other: any) {
    if (!(other instanceof Box)) return -1;
    return this.value - other.value;
  }
}

eq(new Box(5), new Box(5)); // true
lt(new Box(2), new Box(5)); // true
```

## Power User - 深相比较函数

对于高级使用案例 `compare` 函数提供精细控制 :

## 深度比较规格

此函数执行 **深度比较** 在两个 JavaScript 值和返回之间:

-   A 类 **负数** 如果左值小于右值.
-   A 类 **正数** 如果左值大于右值.
-   `0` 如果数值被认为相等.
-   `NaN` 如果数值不具有可比性(不同类型或不相容的比较).

### 范围

主要用于比较 **JSON 类值**数字 :

-   `null`,布尔,数字,字符串
-   阵列
-   普通对象

它还支持 **自定义对象** 用于执行比较接口.

### 自定义比较方法

如果 **左外观** 定义以下方法之一,将在此优先级中使用:

1.  **`.compare(right: unknown): number`** (最高优先级) 必须返回负数, 0 或正数 。 用于分拣.
    
2.  **`.lt(right: unknown): boolean` 财务报告和审定财务报表 `.gt(right: unknown): boolean`** 仅在 `.compare` 没有。 回返 `-1` 若为 `a.lt(b)` 没错, `1` 若为 `a.gt(b)` 是真的,或者说 `0` 如果两者都不是.
    
3.  **`.eq(right: unknown): boolean`** (最低优先级) 仅在 `.compare` 不存在不平等的方法。 若为 `true`返回 `0`如果 `false`,返回到类型比较.
    

这些方法可能会被抛出。 调用人负责处理出错.

### 比较规则

#### 初级类型

-   **数字**:通过减法比较(`a - b`为提高效率.
-   **字符串**: 通过 `String.prototype.localeCompare()` 进行适当的地方认识比较.
-   **布尔**: 转换为数字(`Number(a) - Number(b)`用于比较.
-   **`null`** 被视为少于任何非`null` 数值.
-   **`undefined`** 被视为大于 `null` 但比任何数字或字符串都要少.
-   **`NaN`** 不等于任何东西,包括本身.

#### 阵列

按元素比较的元素 :

-   逐一比较每个指数.
-   第一个非零结果返回.
-   如果所有元素均匀,则先排序更短的数组.

#### 普通对象

-   密钥从对象和排序词典上合并.
-   按排序的每个密钥 :
    -   如果一个键是 **在一个对象中缺失,在另一个对象中存在**中,丢失键的对象总是被认为较少(先来),而不论当前值或键顺序.
    -   如果两个对象都有密钥,它们的值会被相继比较.
-   如果所有键和值都是平等的,则对象是平等的.

**密钥比较进程**:当对象有不同的密钥时,将密钥转换为数组字符串,按词法排序,再与数组作比较. 这保证了无论对象的原始密钥顺序如何,顺序一致.

**实例:**

-   `{a: 1}` 对 `{a: 1, b: 2}` ——第一是减少(缺失) `b`(中文(简体) )
-   `{a: 1, b: 0}` 对 `{a: 1}` ——第二少(缺) `b`(中文(简体) )
-   `{}` 对 `{a: undefined}` ——第一是减少(缺失) `a`(中文(简体) )
-   `{a: null}` 对 `{}` ——第二少(缺) `a`(中文(简体) )
-   `{x: 1}` 对 `{y: 1}` → `[x]` < `[y]`这样 `compare({x: 1}, {y: 1})` 返回时 `-1`
-   `{y: 1}` 对 `{x: 1}` → `[y]` > 翻译: `[x]`这样 `compare({y: 1}, {x: 1})` 返回时 `1`

#### 不兼容的比较

函数返回 `NaN` 当:

-   **不同类型**: 比较不同原始类型的值(例如数字对字符串,布尔对数)
-   **不兼容的对象**: 非对象 `==` 不要执行自定义比较方法
-   **不支持的类型**:函数、符号、类或其他非 JSON 等值

**说明**:阵列和平面对象总是可以比较的(分别是元素和按键),即使它们内部含有不相容的值.

### 处理错误

此函数 **可能抛出** 如果:

-   自定义 `.compare` 或者说 `.eq` 方法抛出.
-   不相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相.

消费者(例如,平等包装)预期会发现错误并将它们视为不平等或未能进行比较.

### 脚本使用示例

```ts
deepCompare(5, 10); // -5 (using subtraction)
deepCompare("z", "a"); // 1 (using localeCompare)
deepCompare(null, 0); // -1
deepCompare([1, 2], [1, 2, 3]); // -1
deepCompare({ a: 1 }, { a: 1 }); // 0
deepCompare({ a: 1 }, { a: 2 }); // -1

deepCompare({ a: 1 }, { a: 1, b: 2 }); // -1 (missing b)
deepCompare({ a: 1, b: 0 }, { a: 1 }); // 1 (other is missing b)
deepCompare({}, { a: undefined }); // -1 (missing a)
deepCompare({ a: null }, {}); // 1 (other is missing a)
deepCompare({ x: 1 }, { y: 1 }); // 1 ({y: 1} is missing x)
deepCompare({ y: 1 }, { x: 1 }); // -1 ({y: 1} is missing x)

// Incompatible comparisons return NaN
deepCompare(5, "hello"); // NaN
deepCompare(true, 42); // NaN
deepCompare(() => {}, {}); // NaN

class Box {
  constructor(public value: number) {}
  compare(other: any) {
    if (!(other instanceof Box)) return -1;
    return this.value - other.value;
  }
}

deepCompare(new Box(2), new Box(5)); // -3

class Tag {
  constructor(public name: string) {}
  eq(other: any) {
    return other instanceof Tag && other.name === this.name;
  }
}

deepCompare(new Tag("a"), new Tag("a")); // 0
deepCompare(new Tag("a"), new Tag("b")); // fallback result (non-zero)

class Range {
  constructor(public start: number, public end: number) {}
  lt(other: any): boolean {
    return other instanceof Range && this.end < other.start;
  }
  gt(other: any): boolean {
    return other instanceof Range && this.start > other.end;
  }
}

deepCompare(new Range(1, 3), new Range(4, 6)); // -1 (1-3 < 4-6)
deepCompare(new Range(4, 6), new Range(1, 3)); // 1 (4-6 > 1-3)
deepCompare(new Range(1, 3), new Range(2, 4)); // 0 (overlapping ranges)
```

### 保证

-   返回所有类似JSON结构的稳定比较结果.
-   尊重 `.compare()` 财务报告和审定财务报表 `.eq()` 如果在 **左外观**。 。 。 .
-   回返 `NaN` 用于不兼容类型比较.
-   绝不吞噬内部错误——如下: `localeCompare`\- 风格严格.

## 常见问题

### @art-suite/art-core-ts-compare 是什么？

类型脚本比较工具库

### 如何安装 @art-suite/art-core-ts-compare？

在项目目录运行 npm install @art-suite/art-core-ts-compare，或使用 pnpm add / yarn add / bun add。

### @art-suite/art-core-ts-compare 支持 TypeScript 吗？

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

### @art-suite/art-core-ts-compare 支持 ESM 还是 CommonJS？

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

### @art-suite/art-core-ts-compare 可以商用吗？

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

### @art-suite/art-core-ts-compare 的下载量有多少？

根据 npm 官方下载统计，@art-suite/art-core-ts-compare 在 2026/10/07 – 2026/11/05 这 30 天内被下载 3,226 次，日均约 108 次。下载量会把 CI 构建、镜像同步和作为其他包依赖的安装一并计入，适合横向比较热度，不能直接等同于使用人数。

### @art-suite/art-core-ts-compare 还在维护吗？

最新版本 0\.1\.2 发布于 2026/06/19（4 个月前）；至今共发布 12 个版本，其中过去 12 个月发布了 6 个；首次发布于 2025/06/23。发布频率只是参考信号：功能稳定的工具可能很少需要更新，建议结合源码仓库的 issue 和提交记录判断。

