sh-tools 2.3.9 → 2.3.11

package/README.md

@@ -1,39 +1,172 @@
 # sh-tools
 
-#### 介绍
-{**以下是 Gitee 平台说明，您可以替换此简介**
-Gitee 是 OSCHINA 推出的基于 Git 的代码托管平台（同时支持 SVN）。专为开发者提供稳定、高效、安全的云端软件开发协作平台
-无论是个人、团队、或是企业，都能够用 Gitee 实现代码托管、项目管理、协作开发。企业项目请看 [https://gitee.com/enterprises](https://gitee.com/enterprises)}
+## 概述
 
-#### 软件架构
-软件架构说明
+SH-Tools 提供了一个强大的表达式求值器模块，支持复杂的数学运算、逻辑判断、函数调用和模板字符串解析。特别适合动态计算、规则引擎和配置化计算场景。
 
+## 安装
+npm install sh-tools
 
-#### 安装教程
+## 引入方式
+import { utils, expr } from 'sh-tools'
 
-1.  xxxx
-2.  xxxx
-3.  xxxx
 
-#### 使用说明
+## 核心 API
+| 函数名 | 参数 | 返回值 | 描述 | 示例 |
+|--------|------|--------|------|------|
+| `utils.calculate(expression, data?)` | `expression: string` - 表达式字符串<br>`data?: object` - 数据上下文 | `any` - 计算结果 | 计算表达式并返回结果，支持 `{}` 模板 | `utils.calculate("1+2*3")` → `7`<br>`utils.calculate("用户{name}", {name:"张三"})` → `"用户张三"` |
+| `utils.calculateLog(expression, data?)` | `expression: string`<br>`data?: object` | `{result, log, treeLog}` - 结果和日志 | 计算表达式并返回详细执行日志 | `utils.calculateLog("sum([1,2,3])")` → `{result: 6, log: [...], treeLog: [...]}` |
+| `expr.registerFunction(name, fn, override?)` | `name: string\|object` - 函数名或对象<br>`fn: Function` - 函数实现<br>`override?: boolean` - 是否覆盖 | `void` | 注册自定义函数 | `expr.registerFunction('double', x=>x*2)`<br>`expr.registerFunction({square: x=>x*x})` |
+| `expr.extendOperator(symbol, config, override?)` | `symbol: string` - 运算符<br>`config: object` - 配置<br>`override?: boolean` - 是否覆盖 | `void` | 扩展自定义运算符 | `expr.extendOperator('//', {precedence:11, fn:(a,b)=>Math.floor(a/b)})` |
 
-1.  xxxx
-2.  xxxx
-3.  xxxx
 
-#### 参与贡献
+# 内置函数
 
-1.  Fork 本仓库
-2.  新建 Feat_xxx 分支
-3.  提交代码
-4.  新建 Pull Request
+## 数学函数
 
+| 函数名 | 参数 | 返回值 | 描述 | 示例 |
+|--------|------|--------|------|------|
+| `abs` | `x: number` | `number` | 绝对值 | `abs(-10)` → `10` |
+| `ceil` | `x: number` | `number` | 向上取整 | `ceil(3.14)` → `4` |
+| `floor` | `x: number` | `number` | 向下取整 | `floor(3.14)` → `3` |
+| `round` | `x: number` | `number` | 四舍五入 | `round(3.14)` → `3` |
+| `pow` | `base: number, exponent: number` | `number` | 幂运算 | `pow(2, 3)` → `8` |
+| `sqrt` | `x: number` | `number` | 平方根 | `sqrt(9)` → `3` |
+| `sin` | `x: number` | `number` | 正弦 | `sin(0)` → `0` |
+| `cos` | `x: number` | `number` | 余弦 | `cos(0)` → `1` |
+| `tan` | `x: number` | `number` | 正切 | `tan(0)` → `0` |
+| `log` | `x: number` | `number` | 自然对数 | `log(10)` → `2.302...` |
+| `exp` | `x: number` | `number` | e的幂次 | `exp(1)` → `2.718...` |
+| `random` | `min?: number, max?: number` | `number` | 随机数 | `random()` → `0.123`<br>`random(1,10)` → `5` |
+| `min` | `...args: number[]` 或 `arr: number[]` | `number` | 最小值 | `min(5,2,8,1)` → `1`<br>`min([5,2,8,1])` → `1` |
+| `max` | `...args: number[]` 或 `arr: number[]` | `number` | 最大值 | `max(5,2,8,1)` → `8`<br>`max([5,2,8,1])` → `8` |
+| `add` | `a: number, b: number` | `number` | 加法（精确） | `add(0.1, 0.2)` → `0.3` |
+| `subtract` | `a: number, b: number` | `number` | 减法（精确） | `subtract(0.3, 0.1)` → `0.2` |
+| `multiply` | `a: number, b: number` | `number` | 乘法（精确） | `multiply(0.1, 0.2)` → `0.02` |
+| `divide` | `a: number, b: number` | `number` | 除法（精确） | `divide(0.3, 0.1)` → `3` |
+| `toFixed` | `value: number, digits: number` | `string` | 保留小数位 | `toFixed(3.14159, 2)` → `"3.14"` |
+| `toInteger` | `value: any` | `number` | 转整数 | `toInteger("123")` → `123`<br>`toInteger(3.14)` → `3` |
+| `toNumber` | `value: any` | `number` | 转数字 | `toNumber("3.14")` → `3.14`<br>`toNumber("123")` → `123` |
+| `truncate` | `value: number, digits: number` | `number` | 截断小数位 | `truncate(3.14159, 2)` → `3.14` |
 
-#### 特技
+## 数组函数
+
+| 函数名 | 参数 | 返回值 | 描述 | 示例 |
+|--------|------|--------|------|------|
+| `sum` | `arr: number[]` | `number` | 求和 | `sum([1,2,3])` → `6` |
+| `mean` | `arr: number[]` | `number` | 平均值 | `mean([1,2,3,4])` → `2.5` |
+| `min` | `arr: number[]` | `number` | 最小值 | `min([5,2,8,1])` → `1` |
+| `max` | `arr: number[]` | `number` | 最大值 | `max([5,2,8,1])` → `8` |
+| `flatten` | `arr: any[]` | `any[]` | 扁平化数组 | `flatten([[1,2],[3,4]])` → `[1,2,3,4]` |
+| `uniq` | `arr: any[]` | `any[]` | 数组去重 | `uniq([1,2,2,3,3,3])` → `[1,2,3]` |
+| `includes` | `arr: any[], value: any` | `boolean` | 包含判断 | `includes([1,2,3], 2)` → `true` |
+| `first` | `arr: any[]` | `any` | 第一个元素 | `first([1,2,3])` → `1` |
+| `last` | `arr: any[]` | `any` | 最后一个元素 | `last([1,2,3])` → `3` |
+| `length` | `arr: any[]` | `number` | 数组长度 | `length([1,2,3,4,5])` → `5` |
+| `slice` | `arr: any[], start: number, end?: number` | `any[]` | 切片 | `slice([1,2,3,4,5], 1, 3)` → `[2,3]` |
+| `indexOf` | `arr: any[], value: any, fromIndex?: number` | `number` | 查找索引 | `indexOf([1,2,3,2], 2)` → `1` |
+| `union` | `...arrays: any[][]` | `any[]` | 数组合并并去重 | `union([1,2], [2,3], [3,4])` → `[1,2,3,4]` |
+| `pluck` | `arr: object[], property: string` | `any[]` | 提取属性值 | `pluck([{id:1},{id:2},{id:3}], 'id')` → `[1,2,3]` |
+| `orderBy` | `arr: any[], field: string, order?: 'asc'\|'desc'` | `any[]` | 排序 | `orderBy([{age:30},{age:25}], 'age', 'asc')` → `[{age:25},{age:30}]` |
+| `groupBy` | `arr: any[], field: string` | `object` | 分组 | `groupBy([{type:'A'},{type:'B'},{type:'A'}], 'type')` → `{A:[...], B:[...]}` |
+| `countBy` | `arr: any[], field: string` | `object` | 统计计数 | `countBy([{type:'A'},{type:'B'},{type:'A'}], 'type')` → `{A:2, B:1}` |
+| `toArrayTree` | `arr: any[], options?: object` | `any[]` | 转树形结构 | `toArrayTree([{id:1,pid:0},{id:2,pid:1}])` → `[{id:1,children:[{id:2}]}]` |
+| `toTreeArray` | `tree: any[], options?: object` | `any[]` | 树形转数组 | `toTreeArray([{id:1,children:[{id:2}]}])` → `[{id:1,pid:0},{id:2,pid:1}]` |
+| `invoke` | `arr: any[], methodName: string, ...args: any[]` | `any[]` | 调用方法 | `invoke([[1,2],[3,4]], 'join', ',')` → `['1,2','3,4']` |
+| `unzip` | `arr: any[][]` | `any[][]` | 解压数组 | `unzip([[1,'a'],[2,'b'],[3,'c']])` → `[[1,2,3],['a','b','c']]` |
+| `includeArrays` | `arr1: any[], arr2: any[]` | `boolean` | 数组包含 | `includeArrays([1,2,3,4], [2,3])` → `true` |
+
+## 字符串函数
+
+| 函数名 | 参数 | 返回值 | 描述 | 示例 |
+|--------|------|--------|------|------|
+| `trim` | `str: string` | `string` | 去除两端空格 | `trim('  hello  ')` → `'hello'` |
+| `trimLeft` | `str: string` | `string` | 去除左侧空格 | `trimLeft('  hello')` → `'hello'` |
+| `trimRight` | `str: string` | `string` | 去除右侧空格 | `trimRight('hello  ')` → `'hello'` |
+| `camelCase` | `str: string` | `string` | 转驼峰命名 | `camelCase('hello_world')` → `'helloWorld'`<br>`camelCase('hello-world')` → `'helloWorld'` |
+| `kebabCase` | `str: string` | `string` | 转烤串命名 | `kebabCase('helloWorld')` → `'hello-world'`<br>`kebabCase('HelloWorld')` → `'hello-world'` |
+| `startsWith` | `str: string, search: string` | `boolean` | 是否以指定字符串开头 | `startsWith('hello', 'he')` → `true`<br>`startsWith('hello', 'lo')` → `false` |
+| `endsWith` | `str: string, search: string` | `boolean` | 是否以指定字符串结尾 | `endsWith('hello', 'lo')` → `true`<br>`endsWith('hello', 'he')` → `false` |
+| `toValueString` | `value: any` | `string` | 转值字符串 | `toValueString(123)` → `'123'`<br>`toValueString(null)` → `''` |
+| `toNumberString` | `value: any, digits?: number` | `string` | 转数字字符串 | `toNumberString(3.14159, 2)` → `'3.14'` |
+
+## 日期函数
+
+| 函数名 | 参数 | 返回值 | 描述 | 示例 |
+|--------|------|--------|------|------|
+| `now` | 无 | `number` | 当前时间戳 | `now()` → `1640995200000` |
+| `timestamp` | 无 | `number` | 当前时间戳 | `timestamp()` → `1640995200000` |
+| `toDateString` | `date: any, format?: string` | `string` | 日期格式化 | `toDateString(1640995200000, 'YYYY-MM-DD')` → `'2022-01-01'` |
+| `getYearDiff` | `date1: string\|number, date2: string\|number` | `number` | 年份差 | `getYearDiff('2020-01-01', '2024-01-01')` → `4` |
+| `getMonthDiff` | `date1: string\|number, date2: string\|number` | `number` | 月份差 | `getMonthDiff('2024-01-01', '2024-06-01')` → `5` |
+| `getDayDiff` | `date1: string\|number, date2: string\|number` | `number` | 天数差 | `getDayDiff('2024-01-01', '2024-01-10')` → `9` |
+| `getHourDiff` | `time1: string\|number, time2: string\|number` | `number` | 小时差 | `getHourDiff('2024-01-01 10:00', '2024-01-01 15:30')` → `5.5` |
+| `getMinuteDiff` | `time1: string\|number, time2: string\|number` | `number` | 分钟差 | `getMinuteDiff('10:30', '11:45')` → `75` |
+| `getSecondDiff` | `time1: string\|number, time2: string\|number` | `number` | 秒数差 | `getSecondDiff('12:00:00', '12:01:30')` → `90` |
+| `getDayOfMonth` | `date: string\|number` | `number` | 当月第几天 | `getDayOfMonth('2024-01-15')` → `15` |
+
+## 对象函数
+
+| 函数名 | 参数 | 返回值 | 描述 | 示例 |
+|--------|------|--------|------|------|
+| `has` | `obj: object, key: string` | `boolean` | 检查属性是否存在 | `has({name:'John'}, 'name')` → `true` |
+| `get` | `obj: object, path: string, defaultValue?: any` | `any` | 深度获取属性值 | `get({user:{name:'John'}}, 'user.name')` → `'John'`<br>`get({}, 'user.name', '默认值')` → `'默认值'` |
+| `assign` | `target: object, ...sources: object[]` | `object` | 对象属性分配 | `assign({}, {a:1}, {b:2})` → `{a:1,b:2}` |
+| `merge` | `...objects: object[]` | `object` | 深度合并对象 | `merge({a:{x:1}}, {a:{y:2}, b:3})` → `{a:{x:1,y:2},b:3}` |
+| `pick` | `obj: object, keys: string[]` | `object` | 选取指定属性 | `pick({name:'John',age:30,city:'NY'}, ['name','age'])` → `{name:'John',age:30}` |
+| `omit` | `obj: object, keys: string[]` | `object` | 排除指定属性 | `omit({x:1,y:2,z:3}, ['z'])` → `{x:1,y:2}` |
+
+## 类型判断函数
+
+| 函数名 | 参数 | 返回值 | 描述 | 示例 |
+|--------|------|--------|------|------|
+| `isNaN` | `value: any` | `boolean` | 是否是NaN | `isNaN(NaN)` → `true`<br>`isNaN(123)` → `false` |
+| `isArray` | `value: any` | `boolean` | 是否是数组 | `isArray([1,2,3])` → `true`<br>`isArray({})` → `false` |
+| `isFloat` | `value: any` | `boolean` | 是否是浮点数 | `isFloat(3.14)` → `true`<br>`isFloat(3)` → `false` |
+| `isInteger` | `value: any` | `boolean` | 是否是整数 | `isInteger(3)` → `true`<br>`isInteger(3.14)` → `false` |
+| `isBoolean` | `value: any` | `boolean` | 是否是布尔值 | `isBoolean(true)` → `true`<br>`isBoolean('true')` → `false` |
+| `isString` | `value: any` | `boolean` | 是否是字符串 | `isString('hello')` → `true`<br>`isString(123)` → `false` |
+| `isNumber` | `value: any` | `boolean` | 是否是数字 | `isNumber(123)` → `true`<br>`isNumber('123')` → `false` |
+| `isPlainObject` | `value: any` | `boolean` | 是否是纯对象 | `isPlainObject({})` → `true`<br>`isPlainObject([])` → `false` |
+| `isDate` | `value: any` | `boolean` | 是否是日期对象 | `isDate(new Date())` → `true`<br>`isDate('2024-01-01')` → `false` |
+| `isEmpty` | `value: any` | `boolean` | 是否为空 | `isEmpty([])` → `true`<br>`isEmpty({})` → `true`<br>`isEmpty('')` → `true`<br>`isEmpty([1])` → `false` |
+| `isNull` | `value: any` | `boolean` | 是否是null | `isNull(null)` → `true`<br>`isNull(undefined)` → `false` |
+| `isMatch` | `obj: object, source: object` | `boolean` | 是否部分匹配 | `isMatch({a:1,b:2,c:3}, {a:1,b:2})` → `true` |
+| `isEqual` | `value1: any, value2: any` | `boolean` | 深度相等比较 | `isEqual({a:[1,2]}, {a:[1,2]})` → `true`<br>`isEqual({a:1}, {a:1,b:2})` → `false` |
+| `getSize` | `value: any` | `number` | 获取大小 | `getSize([1,2,3])` → `3`<br>`getSize({a:1,b:2})` → `2`<br>`getSize('hello')` → `5` |
+
+## 工具函数
+
+| 函数名 | 参数 | 返回值 | 描述 | 示例 |
+|--------|------|--------|------|------|
+| `first` | `arr: any[]` 或 `...args: any[]` | `any` | 第一个元素 | `first([1,2,3])` → `1`<br>`first(1,2,3)` → `1` |
+| `last` | `arr: any[]` 或 `...args: any[]` | `any` | 最后一个元素 | `last([1,2,3])` → `3`<br>`last(1,2,3)` → `3` |
+
+## 注意事项
+
+1. **参数类型**：所有函数参数都经过类型转换，字符串会自动转为数字等
+2. **空值处理**：大部分函数对空值有安全的处理机制
+3. **错误处理**：函数调用出错时会抛出清晰的错误信息
+4. **性能优化**：常用函数做了性能优化，适合高频调用
+
+## 使用示例
+
+```javascript
+import { utils } from 'sh-tools'
+
+// 数学计算
+utils.calculate("abs(-10) + pow(2, 3)")  // 18
+
+// 数组操作
+utils.calculate("sum([1,2,3,4,5]) / length([1,2,3,4,5])")  // 3
+
+// 字符串处理
+utils.calculate("trim('  hello  ') + ' ' + camelCase('world_test')")  // "hello worldTest"
+
+// 日期计算
+utils.calculate("getDayDiff('2024-01-01', '2024-01-10') + getHourDiff('10:00', '12:30')")  // 12.5
+
+// 对象操作
+utils.calculate("merge({a:1}, {b:2}, {c:3})")  // {a:1, b:2, c:3}
+```
 
-1.  使用 Readme\_XXX.md 来支持不同的语言，例如 Readme\_en.md, Readme\_zh.md
-2.  Gitee 官方博客 [blog.gitee.com](https://blog.gitee.com)
-3.  你可以 [https://gitee.com/explore](https://gitee.com/explore) 这个地址来了解 Gitee 上的优秀开源项目
-4.  [GVP](https://gitee.com/gvp) 全称是 Gitee 最有价值开源项目，是综合评定出的优秀开源项目
-5.  Gitee 官方提供的使用手册 [https://gitee.com/help](https://gitee.com/help)
-6.  Gitee 封面人物是一档用来展示 Gitee 会员风采的栏目 [https://gitee.com/gitee-stars/](https://gitee.com/gitee-stars/)

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "sh-tools",
-	"version": "2.3.9",
+	"version": "2.3.11",
 	"description": "基于fetch和xe-utils二次封装，支持宏公式计算",
 	"main": "packages/index.js",
 	"scripts": {
@@ -13,7 +13,7 @@
 	"author": "神秘的sh",
 	"license": "ISC",
 	"dependencies": {
-		"xe-utils": "^3.8.2"
+		"xe-utils": "^3.8.4"
 	},
 	"devDependencies": {
 		"@babel/core": "^7.12.16",

package/packages/expr/index.js

@@ -1,542 +1,550 @@
-import utilsModule from '../utils'
+import utils from '../utils'
+
+// ======================== Token 配置 ========================
+export const TOKEN_TYPES = [
+	{ type: 'JSON', reg: /#JSON#[\s\S]*?#JSON#/, handler: token => token },
+	{ type: 'STRING', reg: /(["'])(.*?)\1/, handler: token => token.slice(1, -1) },
+	{ type: 'NUMBER', reg: /\d+\.?\d*|\.\d+/, handler: token => Number(token) },
+	{
+		type: 'KEYWORD',
+		reg: /\b(?:if|else|null|undefined|true|false)\b/,
+		handler: token => {
+			switch (token) {
+				case 'null':
+					return null
+				case 'undefined':
+					return undefined
+				case 'true':
+					return true
+				case 'false':
+					return false
+				default:
+					return token
+			}
+		}
+	},
+	{ type: 'IDENTIFIER', reg: /[a-zA-Z_$][a-zA-Z0-9_$]*/, handler: token => token },
+	{ type: 'OPERATOR', reg: /===|!==|==|!=|<=|>=|<<|>>|>>>|\|\||&&|\*\*|[,.+\-*/%^&|<>!?()\[\]:]/, handler: token => token }
+]
+
+export const OPERATOR_CONFIG = {
+	// 三元运算符
+	'?': { precedence: 1, associativity: 'right', isTernary: true, fn: (c, a, b) => (c ? a : b) },
+	// 逻辑运算符
+	'||': { precedence: 2, associativity: 'left', fn: (a, b) => a || b },
+	'&&': { precedence: 3, associativity: 'left', fn: (a, b) => a && b },
+	// 位运算符
+	'|': { precedence: 4, associativity: 'left', fn: (a, b) => a | b },
+	'^': { precedence: 5, associativity: 'left', fn: (a, b) => a ^ b },
+	'&': { precedence: 6, associativity: 'left', fn: (a, b) => a & b },
+	// 比较运算符
+	'==': { precedence: 7, associativity: 'left', fn: (a, b) => a == b },
+	'!=': { precedence: 7, associativity: 'left', fn: (a, b) => a != b },
+	'===': { precedence: 7, associativity: 'left', fn: utils.isEqual },
+	'!==': { precedence: 7, associativity: 'left', fn: (a, b) => a !== b },
+	'<': { precedence: 8, associativity: 'left', fn: (a, b) => utils.compareValue(a, b) },
+	'>': { precedence: 8, associativity: 'left', fn: (a, b) => utils.compareValue(b, a) },
+	'<=': { precedence: 8, associativity: 'left', fn: (a, b) => !utils.compareValue(b, a) },
+	'>=': { precedence: 8, associativity: 'left', fn: (a, b) => !utils.compareValue(a, b) },
+	// 算术运算符
+	'+': { precedence: 10, associativity: 'left', fn: utils.add },
+	'-': { precedence: 10, associativity: 'left', fn: utils.subtract },
+	'*': { precedence: 11, associativity: 'left', fn: utils.multiply },
+	'/': { precedence: 11, associativity: 'left', fn: utils.divide },
+	'%': { precedence: 11, associativity: 'left', fn: (a, b) => a % b },
+	'**': { precedence: 12, associativity: 'right', fn: (a, b) => Math.pow(a, b) },
+	// 一元运算符
+	'!': { precedence: 13, associativity: 'right', isUnary: true, fn: a => !a },
+	'~': { precedence: 13, associativity: 'right', isUnary: true, fn: a => ~a }
+}
 
-/**
- * 表达式求值器 - 支持JSON标记解析、常用数学/数组/对象运算
- * @class ExprEvaluator
- * @description 通过#JSON#双标记精准解析嵌套JSON，聚焦核心运算场景
- */
-class ExprEvaluator {
-	// 静态常量 - 仅保留核心方法
-	static MATH_METHODS = ['abs', 'sin', 'cos', 'tan', 'log', 'exp', 'pow']
-	static UTIL_METHODS = {
-		base: [
-			'isNaN',
-			'isFinite',
-			'isArray',
-			'isFloat',
-			'isInteger',
-			'isBoolean',
-			'isString',
-			'isNumber',
-			'isPlainObject',
-			'isDate',
-			'isEmpty',
-			'isNull',
-			'isMatch',
-			'isEqual',
-			'getSize',
-			'first',
-			'last'
-		],
+// ======================== 工具函数 ========================
+function getUtilsFunctions() {
+	const utilMethods = {
+		base: ['isNaN', 'isArray', 'isFloat', 'isInteger', 'isBoolean', 'isString', 'isNumber', 'isPlainObject', 'isDate', 'isEmpty', 'isNull', 'isMatch', 'isEqual', 'getSize', 'first', 'last'],
 		object: ['has', 'get', 'assign', 'merge', 'pick', 'omit'],
-		array: [
-			'slice',
-			'indexOf',
-			'includes',
-			'includeArrays',
-			'sum',
-			'mean',
-			'zip',
-			'unzip',
-			'uniq',
-			'union',
-			'flatten',
-			'pluck',
-			'invoke',
-			'orderBy',
-			'groupBy',
-			'countBy',
-			'toArrayTree',
-			'toTreeArray'
-		],
-		date: ['toDateString', 'getYearDiff', 'getMonthDiff', 'getDayDiff', 'getHourDiff', 'getMinuteDiff', 'getSecondDiff', 'getYearDay', 'getYearWeek', 'getMonthWeek', 'getDayOfMonth'],
+		array: ['slice', 'indexOf', 'includes', 'includeArrays', 'sum', 'mean', 'unzip', 'uniq', 'union', 'flatten', 'pluck', 'invoke', 'orderBy', 'groupBy', 'countBy', 'toArrayTree', 'toTreeArray'],
+		date: ['now', 'timestamp', 'toDateString', 'getYearDiff', 'getMonthDiff', 'getDayDiff', 'getHourDiff', 'getMinuteDiff', 'getSecondDiff', 'getDayOfMonth'],
 		number: ['random', 'min', 'max', 'ceil', 'floor', 'round', 'truncate', 'toFixed', 'toNumber', 'toNumberString', 'toInteger', 'add', 'subtract', 'multiply', 'divide'],
-		string: ['toValueString', 'trim', 'trimLeft', 'trimRight', 'camelCase', 'kebabCase', 'startsWith', 'endsWith']
+		string: ['toValueString', 'trim', 'trimLeft', 'trimRight', 'camelCase', 'kebabCase']
 	}
+	return Object.values(utilMethods)
+		.flat()
+		.reduce((acc, method) => {
+			if (typeof utils[method] === 'function') acc[method] = utils[method]
+			else if (process.env.NODE_ENV === 'development') console.warn(`[ExprEvaluator] utils方法不存在: ${method}`)
+			return acc
+		}, {})
+}
 
-	// TOKEN_REG匹配
-	static TOKEN_REG = /\s*(?:#JSON#([\s\S]*?)#JSON#|"(?:\\.|[^"\\])*"|'(?:\\.|[^'\\])*'|if|else|[a-zA-Z_$][a-zA-Z0-9_$]*|\d+\.?\d*|\.\d+|===|!==|==|!=|<=|>=|\|\||&&|[,.+\-*/%^&|<>!?()\[\]:])\s*/g
+function getBuiltinFunctions() {
+	return {
+		...Object.fromEntries(['abs', 'sin', 'cos', 'tan', 'log', 'exp', 'pow'].map(name => [name, Math[name]])),
+		...getUtilsFunctions(),
+		startsWith: (str, value) => String(str || '').startsWith(value),
+		endsWith: (str, value) => String(str || '').endsWith(value),
+		length: value => value.length
+	}
+}
+
+function tokensToExpr(tokens, start, end) {
+	return tokens
+		.slice(start, end)
+		.map(t => t.raw)
+		.join('')
+		.replace(/\s+/g, ' ')
+		.trim()
+}
 
-	// 精简版OP_MAP：移除unary、shift，仅保留核心运算
-	static OP_MAP = {
-		equality: { '==': true, '!=': true, '===': true, '!==': true },
-		relational: { '<': true, '>': true, '<=': true, '>=': true },
-		arithmetic: { '+': true, '-': true, '*': true, '/': true, '%': true }
+// ======================== 分词器 ========================
+class Tokenizer {
+	tokenize(expr) {
+		const normalizedExpr = expr.replace(/[\n\r]/g, ' ').trim()
+		if (!normalizedExpr) throw new Error('表达式不能为空')
+		const tokens = []
+		let remaining = normalizedExpr
+		while (remaining) {
+			remaining = remaining.trim()
+			if (!remaining) break
+			let matchedType = null
+			let matchedValue = ''
+			for (const type of TOKEN_TYPES) {
+				const match = type.reg.exec(remaining)
+				if (match && match.index === 0) {
+					matchedType = type
+					matchedValue = match[0]
+					break
+				}
+			}
+			if (!matchedType) throw new Error(`无法识别的字符: ${remaining[0]}`)
+			tokens.push({
+				type: matchedType.type,
+				value: matchedType.handler(matchedValue),
+				raw: matchedValue
+			})
+			remaining = remaining.slice(matchedValue.length)
+		}
+		return tokens
 	}
+}
 
+// ======================== 解析器（简化日志版本） ========================
+class Parser {
 	constructor() {
-		this.functions = {} // 工具函数映射
-		this.operators = {} // 运算符执行函数
-		this._isInited = false // 懒加载标记
-		this._cachedUtilMethods = null // 缓存扁平化的工具方法列表
-
-		// 绑定this
-		this.parsePrimary = this.parsePrimary.bind(this)
-		this.parseFunctionArgs = this.parseFunctionArgs.bind(this)
+		this.functions = getBuiltinFunctions()
+		this.operators = { ...OPERATOR_CONFIG }
+		this.tokens = []
+		this.pos = 0
+		this.enableLog = true
+
+		// 日志相关 - 简化处理
+		this.executionLog = [] // 存储原始日志对象
+		this.idCounter = 1
+		this.parentStack = [] // 存储父节点的ID
 	}
 
-	/**
-	 * 类型归一化 - 为比较运算统一值类型（日期→数字→字符串）
-	 * @private
-	 * @param {any} value 待归一化的值
-	 * @returns {number|string} 归一化后的值（日期转时间戳，数字串转数字，其余转字符串）
-	 */
-	_normalizeCompareValue(value) {
-		// 1. 处理日期类型（日期对象/可解析的日期字符串）
-		if (value instanceof Date) {
-			return value.getTime() // 转时间戳（数字）
+	registerFunction(name, fn, override = false) {
+		if (typeof name === 'object') {
+			Object.entries(name).forEach(([key, func]) => this.registerFunction(key, func, override))
+			return
 		}
-		if (typeof value === 'string') {
-			// 尝试解析为日期（支持YYYY-MM-DD、YYYY/MM/DD、带时分秒的格式）
-			const date = new Date(value)
-			if (!isNaN(date.getTime())) {
-				return date.getTime()
-			}
-			// 尝试解析为数字（如"123"、"45.6"）
-			const num = Number(value)
-			if (!isNaN(num)) {
-				return num
-			}
-			// 普通字符串（去空格后比较）
-			return value.trim()
+		if (typeof fn !== 'function') throw new Error('注册的必须是函数')
+		if (!override && this.functions[name]) {
+			console.warn(`[ExprEvaluator] 函数 ${name} 已存在，使用 override=true 覆盖`)
+			return
+		}
+		this.functions[name] = fn
+	}
+
+	extendOperator(symbol, config, override = false) {
+		if (!config.precedence || !config.associativity || !config.fn) {
+			throw new Error('运算符配置必须包含 precedence、associativity、fn')
 		}
-		// 2. 处理数字类型（含数字对象）
-		if (typeof value === 'number' || (value && typeof value === 'object' && value.constructor === Number)) {
-			return Number(value)
+		if (!override && this.operators[symbol]) {
+			console.warn(`[ExprEvaluator] 运算符 ${symbol} 已存在，使用 override=true 覆盖`)
+			return
 		}
-		// 3. 其他类型（布尔值、null、undefined等）转字符串
-		return String(value)
+		this.operators[symbol] = config
 	}
 
-	/**
-	 * 懒加载初始化 - 仅首次调用evaluate时执行
-	 * @private
-	 */
-	_lazyInit() {
-		if (this._isInited) return
-		const utils = utilsModule.__esModule ? utilsModule.default : utilsModule
-
-		// 1. 初始化数学函数（仅保留核心）
-		ExprEvaluator.MATH_METHODS.forEach(method => {
-			this.functions[method] = Math[method]
-		})
-
-		// 2. 初始化工具函数
-		this._cachedUtilMethods = Object.values(ExprEvaluator.UTIL_METHODS).flat()
-		this._cachedUtilMethods.forEach(method => {
-			if (typeof utils[method] === 'function') {
-				this.functions[method] = utils[method]
-			} else if (process.env.NODE_ENV === 'development') {
-				console.warn(`[ExprEvaluator] 工具方法不存在: ${method}`)
-			}
-		})
-
-		// 3. 初始化核心运算符
-		this.operators = {
-			'?:': { precedence: 1, associativity: 'right', ternary: true, fn: (c, a, b) => (c ? a : b) },
-			'||': { precedence: 1, associativity: 'left', fn: (a, b) => a || b },
-			'&&': { precedence: 2, associativity: 'left', fn: (a, b) => a && b },
-			'|': { precedence: 3, associativity: 'left', fn: (a, b) => a | b },
-			'^': { precedence: 4, associativity: 'left', fn: (a, b) => a ^ b },
-			'&': { precedence: 5, associativity: 'left', fn: (a, b) => a & b },
-			'==': { precedence: 6, associativity: 'left', fn: (a, b) => a == b },
-			'!=': { precedence: 6, associativity: 'left', fn: (a, b) => a != b },
-			'!==': { precedence: 6, associativity: 'left', fn: (a, b) => a !== b },
-			'<': { precedence: 7, associativity: 'left', fn: (a, b) => this._normalizeCompareValue(a) < this._normalizeCompareValue(b) },
-			'>': { precedence: 7, associativity: 'left', fn: (a, b) => this._normalizeCompareValue(a) > this._normalizeCompareValue(b) },
-			'<=': { precedence: 7, associativity: 'left', fn: (a, b) => this._normalizeCompareValue(a) <= this._normalizeCompareValue(b) },
-			'>=': { precedence: 7, associativity: 'left', fn: (a, b) => this._normalizeCompareValue(a) >= this._normalizeCompareValue(b) },
-			'===': { precedence: 6, associativity: 'left', fn: utils.isEqual },
-			'+': { precedence: 9, associativity: 'left', fn: utils.add },
-			'-': { precedence: 9, associativity: 'left', fn: utils.subtract },
-			'*': { precedence: 10, associativity: 'left', fn: utils.multiply },
-			'/': { precedence: 10, associativity: 'left', fn: utils.divide },
-			'%': { precedence: 10, associativity: 'left', fn: (a, b) => a % b },
-			'!': { precedence: 12, associativity: 'right', prefix: true, fn: a => !a },
-			'~': { precedence: 12, associativity: 'right', prefix: true, fn: a => ~a }
+	// 创建日志条目
+	addLogEntry(expr, result) {
+		if (!this.enableLog) return null
+
+		const id = this.idCounter++
+		const parentId = this.parentStack.length > 0 ? this.parentStack[this.parentStack.length - 1] : null
+
+		const logEntry = {
+			id,
+			parentId,
+			expr,
+			result,
+			children: []
 		}
 
-		this._isInited = true
+		this.executionLog.push(logEntry)
+		return id
 	}
 
-	/**
-	 * 解析函数参数
-	 * @private
-	 * @param {string} closeChar 闭合字符
-	 * @returns {Array} 参数列表
-	 */
-	parseFunctionArgs(closeChar) {
-		const args = []
-		this.pos++
-
-		if (this.tokens[this.pos] !== closeChar) {
-			args.push(this.parseTernary())
-			while (this.tokens[this.pos] === ',') {
-				this.pos++
-				if (this.tokens[this.pos] === closeChar) break
-				args.push(this.parseTernary())
-			}
-		}
+	// 进入上下文
+	enterContext(id) {
+		this.parentStack.push(id)
+	}
+
+	// 退出上下文
+	exitContext() {
+		this.parentStack.pop()
+	}
+
+	parse(tokens, enableLog = true) {
+		this.tokens = tokens
+		this.pos = 0
+		this.enableLog = enableLog
+
+		// 重置状态
+		this.executionLog = []
+		this.idCounter = 1
+		this.parentStack = []
+
+		const result = this.parseExpression()
 
-		if (this.tokens[this.pos] !== closeChar) {
-			throw new Error(`函数参数未闭合：缺少 ${closeChar}（当前Token：${this.tokens[this.pos] || '空'}, 位置：${this.pos}）`)
+		if (this.pos < tokens.length) {
+			const remaining = tokens
+				.slice(this.pos)
+				.map(t => t.raw)
+				.join('')
+			throw new Error(`表达式多余内容: ${remaining}`)
 		}
-		this.pos++
-		return args
+
+		return { result, executionLog: this.executionLog }
 	}
 
-	/**
-	 * 解析数组字面量
-	 * @private
-	 * @returns {Array} 解析后的数组
-	 */
-	parseArrayLiteral() {
+	parseExpression(precedence = 1) {
 		const startPos = this.pos
-		this.pos++
-		const arr = []
+		let left = this.parsePrimary()
+
+		while (this.peek() && this.isOperator(this.peek()) && this.getOperatorPrecedence(this.peek()) >= precedence) {
+			const opToken = this.consume()
+			const opConfig = this.operators[opToken.value]
+
+			if (opConfig?.isTernary) {
+				// 三元运算符特殊处理
+				const condition = left
+				const conditionExpr = tokensToExpr(this.tokens, startPos, this.pos - 1)
+
+				// 记录条件
+				const conditionId = this.addLogEntry(conditionExpr, condition)
+
+				// 记录三元表达式开始
+				const ternaryStartPos = startPos
+
+				// 处理真分支
+				this.enterContext(conditionId)
+				const trueBranch = this.parseExpression(1)
+				this.exitContext()
+
+				this.consumeToken('OPERATOR', ':')
 
-		if (this.tokens[this.pos] !== ']') {
-			arr.push(this.parseTernary())
-			while (this.tokens[this.pos] === ',') {
-				this.pos++
-				if (this.tokens[this.pos] === ']') break
-				arr.push(this.parseTernary())
+				// 处理假分支
+				this.enterContext(conditionId)
+				const falseBranch = this.parseExpression(1)
+				this.exitContext()
+
+				const result = opConfig.fn(condition, trueBranch, falseBranch)
+
+				// 记录完整的三元表达式
+				const fullExpr = tokensToExpr(this.tokens, ternaryStartPos, this.pos)
+				this.addLogEntry(fullExpr, result)
+
+				left = result
+				continue
 			}
-		}
 
-		if (this.tokens[this.pos] !== ']') {
-			throw new Error(`数组未闭合：在位置 ${startPos} 开始的数组缺少 ]（当前Token：${this.tokens[this.pos] || '空'}, 位置：${this.pos}）`)
-		}
-		this.pos++
-		return arr
-	}
+			const nextPrecedence = opConfig.associativity === 'left' ? opConfig.precedence + 1 : opConfig.precedence
+			const right = this.parseExpression(nextPrecedence)
 
-	/**
-	 * 校验JSON格式
-	 * @private
-	 * @param {string} jsonStr JSON字符串
-	 * @returns {boolean} 是否有效
-	 */
-	_isValidJson(jsonStr) {
-		if (!jsonStr) return false
-		try {
-			JSON.parse(jsonStr)
-			return true
-		} catch {
-			return false
+			// 记录运算符表达式
+			if (this.enableLog) {
+				const leftStr = typeof left === 'object' ? JSON.stringify(left) : String(left)
+				const rightStr = typeof right === 'object' ? JSON.stringify(right) : String(right)
+				const expr = `${leftStr} ${opToken.value} ${rightStr}`
+				this.addLogEntry(expr, opConfig.fn(left, right))
+			}
+
+			left = opConfig.fn(left, right)
 		}
+
+		return left
 	}
 
-	/**
-	 * 解析基础Token
-	 * @private
-	 * @returns {any} 解析后的值
-	 */
 	parsePrimary() {
-		if (this.pos >= this.tokens.length) throw new Error('表达式意外结束')
-		const currentToken = this.tokens[this.pos]
-
-		// 解析双标记JSON
-		if (typeof currentToken === 'string' && currentToken.includes('#JSON#')) {
-			this.pos++
-			const jsonMatch = currentToken.match(/#JSON#([\s\S]*?)#JSON#/)
-			if (!jsonMatch || !this._isValidJson(jsonMatch[1])) {
-				throw new Error(`JSON解析失败：${jsonMatch?.[1] || currentToken}（原Token：${currentToken}）`)
-			}
-			return JSON.parse(jsonMatch[1])
+		const token = this.peek()
+		if (!token) throw new Error('表达式意外结束')
+
+		// if-else 表达式
+		if (token.type === 'KEYWORD' && token.value === 'if') {
+			return this.parseIfElse()
 		}
 
-		// 解析字符串字面量
-		if (typeof currentToken === 'string' && (currentToken.startsWith('"') || currentToken.startsWith("'"))) {
-			this.pos++
-			return currentToken.slice(1, -1)
+		// 括号表达式
+		if (token.type === 'OPERATOR' && token.value === '(') {
+			return this.parseParenthesizedExpression()
 		}
 
-		// 解析数组字面量
-		if (currentToken === '[') return this.parseArrayLiteral()
+		// JSON
+		if (token.type === 'JSON') {
+			return this.parseJsonLiteral()
+		}
 
-		// 解析括号表达式
-		if (currentToken === '(') {
-			this.pos++
-			const res = this.parseTernary()
-			if (this.tokens[this.pos] !== ')') {
-				throw new Error(`括号未闭合：缺少 )（当前Token：${this.tokens[this.pos] || '空'}, 位置：${this.pos}）`)
+		// 字面量
+		if (['STRING', 'NUMBER', 'KEYWORD'].includes(token.type)) {
+			const value = this.consume().value
+			if (this.enableLog && token.type !== 'KEYWORD') {
+				this.addLogEntry(token.raw, value)
 			}
-			this.pos++
-			return res
+			return value
 		}
 
-		// 解析函数调用
-		if (typeof currentToken === 'string' && /^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(currentToken)) {
-			const funcName = currentToken
-			this.pos++
+		// 一元运算符
+		if (this.isUnaryOperator(token)) {
+			const opToken = this.consume()
+			const opConfig = this.operators[opToken.value]
+			const operand = this.parsePrimary()
+			const result = opConfig.fn(operand)
 
-			const callType = this.tokens[this.pos]
-			if (callType === '(' || callType === '[') {
-				const args = this.parseFunctionArgs(callType === '(' ? ')' : ']')
-				if (!this.functions[funcName]) throw new Error(`未定义函数: ${funcName}`)
-				return this.functions[funcName](...args)
+			if (this.enableLog) {
+				const expr = `${opToken.value}${operand}`
+				this.addLogEntry(expr, result)
 			}
 
-			throw new Error(`不支持变量: ${funcName}（仅支持函数调用和字面量）`)
+			return result
 		}
 
-		// 解析数字
-		if (typeof currentToken === 'number' || /^\d+\.?\d*|\.\d+$/.test(currentToken)) {
-			this.pos++
-			return Number(currentToken)
+		// 数组
+		if (token.type === 'OPERATOR' && token.value === '[') {
+			return this.parseArrayLiteral()
 		}
 
-		throw new Error(`无效Token: ${currentToken}（位置：${this.pos}）`)
-	}
-
-	// ========== 精简后的解析链（仅保留核心运算） ==========
-	/**
-	 * 解析乘/除/取模运算
-	 * @private
-	 * @returns {number} 运算结果
-	 */
-	parseMultiplicative() {
-		let res = this.parsePrimary()
-		while (ExprEvaluator.OP_MAP.arithmetic[this.tokens[this.pos]] && ['*', '/', '%'].includes(this.tokens[this.pos])) {
-			const op = this.tokens[this.pos]
-			this.pos++
-			res = this.operators[op].fn(res, this.parsePrimary())
+		// 函数调用
+		if (token.type === 'IDENTIFIER') {
+			return this.parseFunctionCall()
 		}
-		return res
-	}
 
-	/**
-	 * 解析加/减运算
-	 * @private
-	 * @returns {number} 运算结果
-	 */
-	parseAdditive() {
-		let res = this.parseMultiplicative()
-		while (ExprEvaluator.OP_MAP.arithmetic[this.tokens[this.pos]] && ['+', '-'].includes(this.tokens[this.pos])) {
-			const op = this.tokens[this.pos]
-			this.pos++
-			res = this.operators[op].fn(res, this.parseMultiplicative())
-		}
-		return res
+		throw new Error(`无效Token: ${token.raw}`)
 	}
 
-	/**
-	 * 解析关系运算（<、>、<=、>=）
-	 * @private
-	 * @returns {boolean} 运算结果
-	 */
-	parseRelational() {
-		let res = this.parseAdditive()
-		while (ExprEvaluator.OP_MAP.relational[this.tokens[this.pos]]) {
-			const op = this.tokens[this.pos]
-			this.pos++
-			res = this.operators[op].fn(res, this.parseAdditive())
-		}
-		return res
-	}
+	parseParenthesizedExpression() {
+		const startPos = this.pos
+		this.consumeToken('OPERATOR', '(')
 
-	/**
-	 * 解析相等运算（==、!=、===、!==）
-	 * @private
-	 * @returns {boolean} 运算结果
-	 */
-	parseEquality() {
-		let res = this.parseRelational()
-		while (ExprEvaluator.OP_MAP.equality[this.tokens[this.pos]]) {
-			const op = this.tokens[this.pos]
-			this.pos++
-			res = this.operators[op].fn(res, this.parseRelational())
-		}
-		return res
-	}
+		// 记录括号开始
+		const parentId = this.addLogEntry('(', null)
+		this.enterContext(parentId)
 
-	/**
-	 * 解析按位与运算
-	 * @private
-	 * @returns {number} 运算结果
-	 */
-	parseBitwiseAnd() {
-		let res = this.parseEquality()
-		while (this.tokens[this.pos] === '&') {
-			this.pos++
-			res = this.operators['&'].fn(res, this.parseEquality())
+		let result
+		if (this.matchToken('KEYWORD', 'if')) {
+			result = this.parseIfElse()
+		} else {
+			result = this.parseExpression(1)
 		}
-		return res
-	}
 
-	/**
-	 * 解析按位异或运算
-	 * @private
-	 * @returns {number} 运算结果
-	 */
-	parseBitwiseXor() {
-		let res = this.parseBitwiseAnd()
-		while (this.tokens[this.pos] === '^') {
-			this.pos++
-			res = this.operators['^'].fn(res, this.parseBitwiseAnd())
-		}
-		return res
-	}
+		this.consumeToken('OPERATOR', ')')
 
-	/**
-	 * 解析按位或运算
-	 * @private
-	 * @returns {number} 运算结果
-	 */
-	parseBitwiseOr() {
-		let res = this.parseBitwiseXor()
-		while (this.tokens[this.pos] === '|') {
-			this.pos++
-			res = this.operators['|'].fn(res, this.parseBitwiseXor())
+		// 更新括号表达式
+		const expr = tokensToExpr(this.tokens, startPos, this.pos)
+		const log = this.executionLog.find(l => l.id === parentId)
+		if (log) {
+			log.expr = expr
+			log.result = result
 		}
-		return res
+
+		this.exitContext()
+		return result
 	}
 
-	/**
-	 * 解析逻辑与运算
-	 * @private
-	 * @returns {boolean} 运算结果
-	 */
-	parseLogicalAnd() {
-		let res = this.parseBitwiseOr()
-		while (this.tokens[this.pos] === '&&') {
-			this.pos++
-			res = this.operators['&&'].fn(res, this.parseBitwiseOr())
+	parseJsonLiteral() {
+		const token = this.consume()
+		try {
+			const jsonStr = token.raw.slice(6, -6)
+			const result = JSON.parse(jsonStr)
+
+			if (this.enableLog) {
+				this.addLogEntry(token.raw, result)
+			}
+
+			return result
+		} catch (e) {
+			throw new Error(`JSON解析失败: ${token.raw}，原因：${e.message}`)
 		}
-		return res
 	}
 
-	/**
-	 * 解析逻辑或运算
-	 * @private
-	 * @returns {boolean} 运算结果
-	 */
-	parseLogicalOr() {
-		let res = this.parseLogicalAnd()
-		while (this.tokens[this.pos] === '||') {
-			this.pos++
-			res = this.operators['||'].fn(res, this.parseLogicalAnd())
+	parseArrayLiteral() {
+		const startPos = this.pos
+		this.consumeToken('OPERATOR', '[')
+
+		// 记录数组开始
+		const arrayId = this.addLogEntry('[', null)
+		this.enterContext(arrayId)
+
+		const arr = []
+
+		if (!this.matchToken('OPERATOR', ']')) {
+			arr.push(this.parseExpression())
+			while (this.matchToken('OPERATOR', ',')) {
+				this.consumeToken('OPERATOR', ',')
+				arr.push(this.parseExpression())
+			}
 		}
-		return res
-	}
 
-	/**
-	 * 解析三元运算核心逻辑
-	 * @private
-	 * @returns {any} 运算结果
-	 */
-	parseTernaryCore() {
-		let res = this.parseLogicalOr()
-		if (this.tokens[this.pos] === '?') {
-			this.pos++
-			const a = this.parseTernaryCore()
-			if (this.tokens[this.pos] !== ':') throw new Error('三元运算符缺少冒号')
-			this.pos++
-			const b = this.parseTernaryCore()
-			res = this.operators['?:'].fn(res, a, b)
+		this.consumeToken('OPERATOR', ']')
+
+		// 更新数组表达式
+		const expr = tokensToExpr(this.tokens, startPos, this.pos)
+		const log = this.executionLog.find(l => l.id === arrayId)
+		if (log) {
+			log.expr = expr
+			log.result = arr
 		}
-		return res
+
+		this.exitContext()
+		return arr
 	}
 
-	/**
-	 * 解析if/else和三元运算
-	 * @private
-	 * @returns {any} 运算结果
-	 */
 	parseIfElse() {
-		if (this.tokens[this.pos] !== 'if') return this.parseTernaryCore()
-		this.pos++
+		const startPos = this.pos
 
-		if (this.tokens[this.pos] !== '(') {
-			throw new Error(`if语法错误：缺少左括号（当前Token：${this.tokens[this.pos] || '空'}, 位置：${this.pos}）`)
-		}
-		this.pos++
+		this.consumeToken('KEYWORD', 'if')
+		this.consumeToken('OPERATOR', '(')
 
-		const condition = this.parseTernaryCore()
-		if (this.tokens[this.pos] !== ')') {
-			throw new Error(`if语法错误：缺少右括号（当前Token：${this.tokens[this.pos] || '空'}, 位置：${this.pos}）`)
-		}
-		this.pos++
+		const condition = this.parseExpression()
+		this.consumeToken('OPERATOR', ')')
 
-		const thenValue = this.parseTernaryCore()
-		if (this.tokens[this.pos] !== 'else') {
-			throw new Error(`if语法错误：缺少else关键字（当前Token：${this.tokens[this.pos] || '空'}, 位置：${this.pos}）`)
-		}
-		this.pos++
+		const ifExpr = this.parseExpression()
 
-		const elseValue = this.parseTernaryCore()
-		return condition ? thenValue : elseValue
-	}
+		let elseExpr = undefined
 
-	/**
-	 * 入口解析方法
-	 * @private
-	 * @returns {any} 运算结果
-	 */
-	parseTernary() {
-		return this.parseIfElse()
-	}
+		if (this.matchToken('KEYWORD', 'else')) {
+			this.consumeToken('KEYWORD', 'else')
 
-	/**
-	 * 分词处理
-	 * @private
-	 * @param {string} expr 表达式
-	 * @returns {Array} 分词结果
-	 */
-	_tokenize(expr) {
-		const tokens = []
-		const reg = new RegExp(ExprEvaluator.TOKEN_REG.source, 'g')
-		let match
-
-		while ((match = reg.exec(expr)) !== null) {
-			const token = match[0].trim()
-			if (!token) continue
-
-			if (token.includes('#JSON#')) {
-				tokens.push(token)
-			} else if (token.startsWith('"') || token.startsWith("'")) {
-				tokens.push(token)
-			} else if (/^\d+\.?\d*|\.\d+$/.test(token)) {
-				tokens.push(Number(token))
+			if (this.matchToken('KEYWORD', 'if')) {
+				elseExpr = this.parseIfElse()
 			} else {
-				tokens.push(token)
+				elseExpr = this.parseExpression()
 			}
 		}
 
-		if (tokens.length === 0) throw new Error('表达式为空')
-		return tokens
+		const result = condition ? ifExpr : elseExpr
+
+		if (this.enableLog) {
+			const fullExpr = tokensToExpr(this.tokens, startPos, this.pos)
+			this.addLogEntry(fullExpr, result)
+		}
+
+		return result
 	}
 
-	/**
-	 * 对外求值方法
-	 * @public
-	 * @param {string} expr 表达式
-	 * @returns {any} 结果
-	 */
-	evaluate(expr) {
-		this._lazyInit()
+	parseFunctionCall() {
+		const startPos = this.pos
+		const funcName = this.consume().value
+		const openChar = this.matchToken('OPERATOR', '(') ? '(' : this.matchToken('OPERATOR', '[') ? '[' : null
+		if (!openChar) throw new Error(`不支持变量: ${funcName}（仅支持函数调用）`)
+		const closeChar = openChar === '(' ? ')' : ']'
 
-		if (typeof expr !== 'string') throw new Error('表达式必须是字符串')
-		const normalizedExpr = expr.replace(/[\n\r]/g, ' ').trim()
-		if (!normalizedExpr) throw new Error('表达式不能为空')
+		// 记录函数调用开始
+		const funcId = this.addLogEntry(`${funcName}${openChar}`, null)
+		this.enterContext(funcId)
 
-		try {
-			this.tokens = this._tokenize(normalizedExpr)
-			this.pos = 0
-			const result = this.parseTernary()
+		this.consumeToken('OPERATOR', openChar)
 
-			if (this.pos < this.tokens.length) {
-				throw new Error(`表达式多余内容: ${this.tokens.slice(this.pos).join('')}（位置：${this.pos}）`)
+		// 收集参数
+		const args = []
+		if (!this.matchToken('OPERATOR', closeChar)) {
+			args.push(this.parseExpression())
+			while (this.matchToken('OPERATOR', ',')) {
+				this.consumeToken('OPERATOR', ',')
+				args.push(this.parseExpression())
 			}
+		}
+
+		this.consumeToken('OPERATOR', closeChar)
+
+		// 执行函数调用
+		if (!this.functions[funcName]) {
+			throw new Error(`未定义函数: ${funcName}`)
+		}
+
+		const result = this.functions[funcName](...args)
 
+		// 更新函数调用表达式
+		const expr = tokensToExpr(this.tokens, startPos, this.pos)
+		const log = this.executionLog.find(l => l.id === funcId)
+		if (log) {
+			log.expr = expr
+			log.result = result
+		}
+
+		this.exitContext()
+		return result
+	}
+
+	// ======================== 工具方法 ========================
+	peek() {
+		return this.tokens[this.pos]
+	}
+	consume() {
+		return this.tokens[this.pos++]
+	}
+	matchToken(type, value) {
+		const token = this.peek()
+		return token && token.type === type && token.value === value
+	}
+	consumeToken(type, value) {
+		if (!this.matchToken(type, value)) throw new Error(`缺少Token: ${value}`)
+		return this.consume()
+	}
+	isOperator(token) {
+		return token.type === 'OPERATOR' && !!this.operators[token.value]
+	}
+	isUnaryOperator(token) {
+		return this.isOperator(token) && this.operators[token.value]?.isUnary
+	}
+	getOperatorPrecedence(token) {
+		return this.operators[token.value]?.precedence || 0
+	}
+}
+
+// ======================== 求值器 ========================
+class ExprEvaluator {
+	constructor() {
+		this.tokenizer = new Tokenizer()
+		this.parser = new Parser()
+	}
+	registerFunction(name, fn, override = false) {
+		this.parser.registerFunction(name, fn, override)
+	}
+	extendOperator(symbol, config, override = false) {
+		this.parser.extendOperator(symbol, config, override)
+	}
+	evaluateLog(expr, enableLog = true) {
+		try {
+			const tokens = this.tokenizer.tokenize(expr)
+			const { result, executionLog } = this.parser.parse(tokens, enableLog)
+			return { result, log: utils.orderBy(executionLog, 'parentId'), treeLog: utils.toArrayTree(executionLog) }
+		} catch (error) {
+			throw new Error(`[ExprEvaluator] ${error.message}（原表达式：${expr}）`)
+		}
+	}
+	evaluate(expr) {
+		try {
+			const tokens = this.tokenizer.tokenize(expr)
+			const { result } = this.parser.parse(tokens, false)
 			return result
 		} catch (error) {
-			throw new Error(`表达式计算失败: ${error.message}（原表达式：${expr}）`)
+			throw new Error(`[ExprEvaluator] ${error.message}（原表达式：${expr}）`)
 		}
 	}
 }
 
-// 单例导出
-const evaluator = new ExprEvaluator()
-export default evaluator
+// ======================== 单例导出 ========================
+const exprEvaluator = new ExprEvaluator()
+export default exprEvaluator

package/packages/index.js

@@ -2,6 +2,25 @@ import http from './api'
 import utils from './utils'
 import expr from './expr'
 
+// 再此扩展公式计算方法，防止循环依赖问题
+utils.mixin({
+	calculate(formula, data) {
+		if (!formula) return ''
+		if (data && utils.isPlainObject(data)) {
+			formula = utils.format(formula, data, true)
+		}
+		return expr.evaluate(formula)
+	},
+
+	calculateLog(formula, data) {
+		if (!formula) return ''
+		if (data && utils.isPlainObject(data)) {
+			formula = utils.format(formula, data, true)
+		}
+		return expr.evaluateLog(formula)
+	}
+})
+
 export { http, utils, expr }
 
 export default { http, utils, expr }

package/packages/utils/number.js

@@ -1,6 +1,4 @@
 import XEUtils from 'xe-utils'
-import stringUtil from './string'
-import formulaParser from '../expr'
 
 export default {
 	truncate(num, digits) {
@@ -10,13 +8,5 @@ export default {
 		} else {
 			return XEUtils.floor(num, digits)
 		}
-	},
-
-	calculate(formula, data) {
-		if (!formula) return ''
-		if (data && XEUtils.isPlainObject(data)) {
-			formula = stringUtil.format(formula, data)
-		}
-		return formulaParser.evaluate(formula)
 	}
 }

package/packages/utils/string.js

@@ -8,17 +8,17 @@ function getFormatKeys(format) {
 }
 
 // 格式化数据结构
-function format(format, data) {
+function format(format, data, addQuotes) {
 	let keys = getFormatKeys(format)
 	let formatStr = String(format)
 	keys.map((key, indexkey) => {
 		let value = XEUtils.get(data, key) || ''
 		let replaceValue = ''
 		if (value === undefined || value === null) {
-			replaceValue = '""'
+			replaceValue = addQuotes ? '""' : ''
 		} else if (typeof value === 'object' || Array.isArray(value)) {
-			replaceValue = `#JSON#${JSON.stringify(value)}#JSON#`
-		} else if (typeof value === 'string') {
+			replaceValue = addQuotes ? `#JSON#${JSON.stringify(value)}#JSON#` : JSON.stringify(value)
+		} else if (typeof value === 'string' && addQuotes) {
 			replaceValue = `"${value}"`
 		} else {
 			replaceValue = value
@@ -39,10 +39,26 @@ function randomStr(len = 32) {
 	return str
 }
 
+function normalize(val) {
+	if (val instanceof Date && !isNaN(val.getTime())) return val.getTime()
+	if (typeof val === 'string') {
+		const date = new Date(val)
+		if (!isNaN(date.getTime())) return date.getTime()
+		const num = Number(val)
+		return isNaN(num) ? val.trim() : num
+	}
+	return typeof val === 'number' ? val : String(val)
+}
+
+function compareValue(a, b) {
+	return normalize(a) < normalize(b)
+}
+
 export default {
 	randomStr,
 	getFormatKeys,
 	format,
+	compareValue,
 	replaceNutrim(str) {
 		return String(str).replace(/undefined|(^\s*)|(\s*$)/gi, '')
 	},