比较运算符

a-calc 3.x 引入了完整的比较运算符支持，可以在表达式中进行数值比较，返回布尔值结果。

支持的运算符

运算符	含义	示例
>	大于	5 > 3 → true
<	小于	5 < 3 → false
>=	大于等于	5 >= 5 → true
<=	小于等于	5 <= 4 → false
==	等于	5 == 5 → true
!=	不等于	5 != 3 → true

注意

a-calc 只支持 == 进行相等比较，不支持 ===。这是因为 a-calc 主要处理数值，不需要严格类型比较。

基本用法

import { calc } from 'a-calc'

// 基本比较
calc('5 > 3')   // true
calc('5 < 3')   // false
calc('5 >= 5')  // true
calc('5 <= 4')  // false
calc('5 == 5')  // true
calc('5 != 3')  // true

// 使用变量
calc('x > y', { x: 10, y: 5 })  // true
calc('a == b', { a: 3, b: 3 })  // true

精确比较

a-calc 使用高精度 Decimal 进行比较，避免浮点数精度问题：

// JavaScript 原生比较的问题
0.1 + 0.2 === 0.3  // false（JavaScript 浮点数精度问题）

// a-calc 精确比较
calc('0.1 + 0.2 == 0.3')  // true（a-calc 使用精确计算）

// 更多精确比较示例
calc('0.1 * 3 == 0.3')  // true
calc('1.0000000000000001 == 1')  // false（保持精度）

链式比较

a-calc 支持 Python 风格的链式比较，可以同时进行多个比较：

// 范围检查
calc('1 < 5 < 10')   // true（1 < 5 且 5 < 10）
calc('1 < 5 > 10')   // false（1 < 5 但 5 不大于 10）

// 使用变量
calc('min < x < max', { min: 0, x: 5, max: 10 })  // true
calc('a < b < c < d', { a: 1, b: 2, c: 3, d: 4 })  // true

// 等价于多个条件的 && 组合
calc('1 < x && x < 10', { x: 5 })  // true（与链式比较结果相同）

链式比较原理

a < b < c 等价于 (a < b) && (b < c)，但更简洁直观。

与其他运算符组合

与算术运算组合

// 比较计算结果
calc('x + y > 10', { x: 5, y: 6 })   // true
calc('x * 2 == y', { x: 5, y: 10 })  // true
calc('a / b < 1', { a: 3, b: 5 })    // true

// 复杂表达式
calc('(a + b) * 2 >= c', { a: 3, b: 4, c: 14 })  // true

与逻辑运算组合

// 与 && 组合
calc('x > 0 && y > 0', { x: 5, y: 3 })  // true
calc('x > 0 && y > 0', { x: 5, y: -1 }) // false

// 与 || 组合
calc('x < 0 || y < 0', { x: 5, y: -1 })  // true
calc('x < 0 || y < 0', { x: 5, y: 3 })   // false

// 组合使用
calc('(x > 0 && x < 10) || x == 100', { x: 5 })    // true
calc('(x > 0 && x < 10) || x == 100', { x: 100 })  // true

与条件表达式组合

// 作为条件使用
calc('x > 0 ? x : 0', { x: 5 })   // '5'
calc('x > 0 ? x : 0', { x: -3 })  // '0'

// 复杂条件
calc('a > b ? a - b : b - a', { a: 10, b: 7 })  // '3'（计算差值的绝对值）

运算符优先级

比较运算符的优先级在算术运算符之下，在逻辑运算符之上：

运算符类型	优先级
** (幂)	8
* / % //	7
+ -	6
> < >= <=	5
== !=	4
&&	3
||	2
? :	1

// 算术运算先于比较
calc('1 + 2 > 2')  // true（先计算 1+2=3，再比较 3>2）

// 比较运算先于逻辑
calc('1 > 0 && 2 > 1')  // true（先比较，再逻辑与）

// 使用括号改变优先级
calc('1 > (0 && 2) > 1')  // 解析错误，逻辑运算返回布尔值

实际应用示例

价格区间判断

// 判断价格是否在预算范围内
calc('price >= minBudget && price <= maxBudget', {
    price: 500,
    minBudget: 100,
    maxBudget: 1000
})  // true

// 使用链式比较更简洁
calc('minBudget <= price <= maxBudget', {
    price: 500,
    minBudget: 100,
    maxBudget: 1000
})  // true

库存状态

// 判断库存状态
const stockStatus = (stock) => {
    if (calc('stock == 0', { stock })) return '缺货'
    if (calc('stock < 10', { stock })) return '库存紧张'
    if (calc('stock < 100', { stock })) return '库存正常'
    return '库存充足'
}

stockStatus(0)   // '缺货'
stockStatus(5)   // '库存紧张'
stockStatus(50)  // '库存正常'
stockStatus(200) // '库存充足'

折扣计算

// 根据消费金额确定折扣
const getDiscount = (amount) => calc(`
    amount >= 1000 ? 0.7 :
    (amount >= 500 ? 0.8 :
    (amount >= 200 ? 0.9 : 1))
`, { amount })

getDiscount(1500)  // '0.7'（7折）
getDiscount(600)   // '0.8'（8折）
getDiscount(300)   // '0.9'（9折）
getDiscount(100)   // '1'（原价）

成绩等级

// 根据分数判断等级
const getGrade = (score) => calc(`
    score >= 90 ? "A" :
    (score >= 80 ? "B" :
    (score >= 70 ? "C" :
    (score >= 60 ? "D" : "F")))
`, { score })

getGrade(95)  // 'A'
getGrade(85)  // 'B'
getGrade(55)  // 'F'

注意事项

1. 类型转换：比较运算会将操作数转换为数值进行比较
2. 精度保证：使用 Decimal.js 进行精确比较，避免浮点数问题
3. 返回类型：比较运算始终返回布尔值 true 或 false
4. 与格式化：比较结果为布尔值时，格式化参数会被忽略