@art-site/art-core-ts-compare (英语)
深度平等,不平等,低于和大于比较 - 完全与自定义对象支持相通.
快速启动 - 平等函数
使用此库的最简单方法是具有标准平等功能:
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,布尔,数字,字符串- 阵列
- 普通对象
它还支持 自定义对象 用于执行比较接口.
自定义比较方法
如果 左外观 定义以下方法之一,将在此优先级中使用:
-
.compare(right: unknown): number(最高优先级) 必须返回负数, 0 或正数 。 用于分拣. -
.lt(right: unknown): boolean财务报告和审定财务报表.gt(right: unknown): boolean仅在.compare没有。 回返-1若为a.lt(b)没错,1若为a.gt(b)是真的,或者说0如果两者都不是. -
.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方法抛出. - 不相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相相.
消费者(例如,平等包装)预期会发现错误并将它们视为不平等或未能进行比较.
脚本使用示例
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- 风格严格.