sh-tools 2.3.7 → 2.3.9

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "sh-tools",
-	"version": "2.3.7",
+	"version": "2.3.9",
 	"description": "基于fetch和xe-utils二次封装，支持宏公式计算",
 	"main": "packages/index.js",
 	"scripts": {

package/packages/expr/index.js

@@ -1,125 +1,137 @@
 import utilsModule from '../utils'
 
 /**
- * 常量定义：分类管理内置方法名
+ * 表达式求值器 - 支持JSON标记解析、常用数学/数组/对象运算
+ * @class ExprEvaluator
+ * @description 通过#JSON#双标记精准解析嵌套JSON，聚焦核心运算场景
  */
-const MATH_METHODS = ['abs', 'sin', 'cos', 'tan', 'log', 'exp', 'pow']
-const UTIL_METHODS = {
-	base: [
-		'isNaN',
-		'isFinite',
-		'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: [
-		'now',
-		'timestamp',
-		'toStringDate',
-		'toDateString',
-		'getWhatYear',
-		'getWhatMonth',
-		'getWhatWeek',
-		'getWhatDay',
-		'getDayOfYear',
-		'getYearDay',
-		'getYearWeek',
-		'getMonthWeek',
-		'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']
-}
+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'
+		],
+		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'],
+		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']
+	}
 
-// ========== 核心修复1：正则新增字符串字面量匹配（优先识别） ==========
-// 改动点：
-// 1. 最前面新增 ("[^"\\]*(?:\\.[^"\\]*)*"|'[^'\\]*(?:\\.[^'\\]*)*') 匹配单/双引号字符串
-// 2. 处理转义字符（如 \' / \"），兼容带转义的字符串
-const TOKEN_REG = /\s*((?:"[^"\\]*(?:\\.[^"\\]*)*"|'[^'\\]*(?:\\.[^'\\]*)*')|(if|else)|[a-zA-Z_$][a-zA-Z0-9_$]*|[\d.]+|,|==|===|!=|!==|<=|>=|<<|>>|>>>|\|\||&&|\*\*|[-+*/%^&|<>!=?:()\[\]])\s*/g
+	// TOKEN_REG匹配
+	static TOKEN_REG = /\s*(?:#JSON#([\s\S]*?)#JSON#|"(?:\\.|[^"\\])*"|'(?:\\.|[^'\\])*'|if|else|[a-zA-Z_$][a-zA-Z0-9_$]*|\d+\.?\d*|\.\d+|===|!==|==|!=|<=|>=|\|\||&&|[,.+\-*/%^&|<>!?()\[\]:])\s*/g
 
-// 运算符映射（原有逻辑不变）
-const UNARY_OP_MAP = { '+': 'unary +', '-': 'unary -', '!': '!', '~': '~' }
-const EQUALITY_OP_MAP = { '==': true, '!=': true, '===': true, '!==': true }
-const RELATIONAL_OP_MAP = { '<': true, '>': true, '<=': true, '>=': true }
-const SHIFT_OP_MAP = { '<<': true, '>>': true, '>>>': true }
-const ARITHMETIC_OP_MAP = { '+': true, '-': true, '*': true, '/': true, '%': true }
+	// 精简版OP_MAP：移除unary、shift，仅保留核心运算
+	static OP_MAP = {
+		equality: { '==': true, '!=': true, '===': true, '!==': true },
+		relational: { '<': true, '>': true, '<=': true, '>=': true },
+		arithmetic: { '+': true, '-': true, '*': true, '/': true, '%': true }
+	}
 
-/**
- * 表达式求值器（最终完整版：支持if-else+换行+字符串字面量）
- */
-class ExprEvaluator {
 	constructor() {
-		this.functions = {}
-		this.operators = {}
-		this._isInited = false
-		this._initParseFunctions()
+		this.functions = {} // 工具函数映射
+		this.operators = {} // 运算符执行函数
+		this._isInited = false // 懒加载标记
+		this._cachedUtilMethods = null // 缓存扁平化的工具方法列表
+
+		// 绑定this
+		this.parsePrimary = this.parsePrimary.bind(this)
+		this.parseFunctionArgs = this.parseFunctionArgs.bind(this)
+	}
+
+	/**
+	 * 类型归一化 - 为比较运算统一值类型（日期→数字→字符串）
+	 * @private
+	 * @param {any} value 待归一化的值
+	 * @returns {number|string} 归一化后的值（日期转时间戳，数字串转数字，其余转字符串）
+	 */
+	_normalizeCompareValue(value) {
+		// 1. 处理日期类型（日期对象/可解析的日期字符串）
+		if (value instanceof Date) {
+			return value.getTime() // 转时间戳（数字）
+		}
+		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()
+		}
+		// 2. 处理数字类型（含数字对象）
+		if (typeof value === 'number' || (value && typeof value === 'object' && value.constructor === Number)) {
+			return Number(value)
+		}
+		// 3. 其他类型（布尔值、null、undefined等）转字符串
+		return String(value)
 	}
 
 	/**
-	 * 懒加载初始化（原有逻辑不变）
+	 * 懒加载初始化 - 仅首次调用evaluate时执行
+	 * @private
 	 */
 	_lazyInit() {
 		if (this._isInited) return
 		const utils = utilsModule.__esModule ? utilsModule.default : utilsModule
 
-		const funcs = {}
-		for (const method of MATH_METHODS) funcs[method] = Math[method]
+		// 1. 初始化数学函数（仅保留核心）
+		ExprEvaluator.MATH_METHODS.forEach(method => {
+			this.functions[method] = Math[method]
+		})
 
-		// 提前扁平化方法列表（轻量化优化）
-		const ALL_UTIL_METHODS = Object.values(UTIL_METHODS).flat()
-		for (const method of ALL_UTIL_METHODS) {
+		// 2. 初始化工具函数
+		this._cachedUtilMethods = Object.values(ExprEvaluator.UTIL_METHODS).flat()
+		this._cachedUtilMethods.forEach(method => {
 			if (typeof utils[method] === 'function') {
-				// sum函数兼容包装（解决sum(1,2,3)返回0的问题）
-				if (method === 'sum') {
-					funcs[method] = (...args) => {
-						if (args.length === 1 && Array.isArray(args[0])) {
-							return utils.sum(args[0])
-						}
-						return utils.sum(args)
-					}
-				} else {
-					funcs[method] = utils[method]
-				}
+				this.functions[method] = utils[method]
 			} else if (process.env.NODE_ENV === 'development') {
-				console.warn(`[ExprEvaluator] utils方法不存在: ${method}`)
+				console.warn(`[ExprEvaluator] 工具方法不存在: ${method}`)
 			}
-		}
-		this.functions = funcs
+		})
 
-		// 初始化运算符（原有逻辑不变）
+		// 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 },
@@ -129,23 +141,17 @@ class ExprEvaluator {
 			'&': { 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: 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: (a, b) => a <= b },
-			'>=': { precedence: 7, associativity: 'left', fn: (a, b) => a >= b },
-			'<<': { precedence: 8, associativity: 'left', fn: (a, b) => a << b },
-			'>>': { precedence: 8, associativity: 'left', fn: (a, b) => a >> b },
-			'>>>': { precedence: 8, 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: 11, associativity: 'right', fn: Math.pow },
-			'unary +': { precedence: 12, associativity: 'right', prefix: true, fn: a => +a },
-			'unary -': { precedence: 12, associativity: 'right', prefix: true, fn: a => -a },
 			'!': { precedence: 12, associativity: 'right', prefix: true, fn: a => !a },
 			'~': { precedence: 12, associativity: 'right', prefix: true, fn: a => ~a }
 		}
@@ -154,332 +160,346 @@ class ExprEvaluator {
 	}
 
 	/**
-	 * 初始化解析函数（原有逻辑不变，仅扩展parsePrimary支持字符串）
+	 * 解析函数参数
+	 * @private
+	 * @param {string} closeChar 闭合字符
+	 * @returns {Array} 参数列表
 	 */
-	_initParseFunctions() {
-		let tokens, pos
-		const self = this
-
-		// 函数参数解析（不变）
-		const parseFunctionArgs = closeChar => {
-			const args = []
-			pos++ // 跳过左括号 ( 或 [
-
-			if (tokens[pos] !== closeChar) {
-				args.push(parseTernary())
-				while (tokens[pos] === ',') {
-					pos++ // 跳过逗号
-					if (tokens[pos] === closeChar) break // 处理多余逗号：sum(1,)
-					args.push(parseTernary())
-				}
+	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())
 			}
+		}
 
-			if (tokens[pos] !== closeChar) {
-				throw new Error(`函数参数未闭合：缺少 ${closeChar}（当前Token：${tokens[pos] || '空'}, 位置：${pos}）`)
-			}
-			pos++ // 跳过右括号 ) 或 ]
-			return args
+		if (this.tokens[this.pos] !== closeChar) {
+			throw new Error(`函数参数未闭合：缺少 ${closeChar}（当前Token：${this.tokens[this.pos] || '空'}, 位置：${this.pos}）`)
 		}
+		this.pos++
+		return args
+	}
 
-		// 数组字面量解析（不变）
-		const parseArrayLiteral = () => {
-			const startPos = pos
-			pos++ // 跳过左中括号 [
-			const arr = []
-
-			if (tokens[pos] !== ']') {
-				arr.push(parseTernary())
-				while (tokens[pos] === ',') {
-					pos++ // 跳过逗号
-					if (tokens[pos] === ']') break // 处理多余逗号：[1,]
-					arr.push(parseTernary())
-				}
+	/**
+	 * 解析数组字面量
+	 * @private
+	 * @returns {Array} 解析后的数组
+	 */
+	parseArrayLiteral() {
+		const startPos = this.pos
+		this.pos++
+		const arr = []
+
+		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())
 			}
+		}
 
-			if (tokens[pos] !== ']') {
-				throw new Error(`数组未闭合：在位置 ${startPos} 开始的数组缺少 ]（当前Token：${tokens[pos] || '空'}, 位置：${pos}）`)
-			}
-			pos++ // 跳过右中括号 ]
-			return arr
+		if (this.tokens[this.pos] !== ']') {
+			throw new Error(`数组未闭合：在位置 ${startPos} 开始的数组缺少 ]（当前Token：${this.tokens[this.pos] || '空'}, 位置：${this.pos}）`)
 		}
+		this.pos++
+		return arr
+	}
 
-		// ========== 核心修复2：扩展parsePrimary支持字符串字面量 ==========
-		const parsePrimary = () => {
-			if (pos >= tokens.length) throw new Error('表达式意外结束')
-			const currentToken = tokens[pos]
+	/**
+	 * 校验JSON格式
+	 * @private
+	 * @param {string} jsonStr JSON字符串
+	 * @returns {boolean} 是否有效
+	 */
+	_isValidJson(jsonStr) {
+		if (!jsonStr) return false
+		try {
+			JSON.parse(jsonStr)
+			return true
+		} catch {
+			return false
+		}
+	}
 
-			// 新增：字符串字面量解析（单/双引号）
-			if (typeof currentToken === 'string' && (currentToken.startsWith('"') || currentToken.startsWith("'"))) {
-				const strValue = currentToken.slice(1, -1) // 去掉首尾引号
-				pos++
-				return strValue // 返回纯字符串内容
+	/**
+	 * 解析基础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])
+		}
 
-			// 数组字面量
-			if (currentToken === '[') {
-				return parseArrayLiteral()
-			}
+		// 解析字符串字面量
+		if (typeof currentToken === 'string' && (currentToken.startsWith('"') || currentToken.startsWith("'"))) {
+			this.pos++
+			return currentToken.slice(1, -1)
+		}
 
-			// 括号表达式 (a + b)
-			if (currentToken === '(') {
-				pos++
-				const res = parseTernary()
-				if (tokens[pos] !== ')') {
-					throw new Error(`括号未闭合：缺少 )（当前Token：${tokens[pos] || '空'}, 位置：${pos}）`)
-				}
-				pos++
-				return res
-			}
+		// 解析数组字面量
+		if (currentToken === '[') return this.parseArrayLiteral()
 
-			// 函数调用（支持 () 和 [] 两种写法）
-			if (typeof currentToken === 'string' && /^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(currentToken)) {
-				const funcName = currentToken
-				pos++
-
-				// 圆括号调用：sum(1,2,3)
-				if (tokens[pos] === '(') {
-					const args = parseFunctionArgs(')')
-					if (!self.functions[funcName]) throw new Error(`未定义函数: ${funcName}`)
-					return self.functions[funcName](...args)
-				}
-
-				// 中括号调用：sum[1,2,3]
-				if (tokens[pos] === '[') {
-					const args = parseFunctionArgs(']')
-					if (!self.functions[funcName]) throw new Error(`未定义函数: ${funcName}`)
-					return self.functions[funcName](...args)
-				}
-
-				throw new Error(`不支持变量: ${funcName}（仅支持函数调用）`)
+		// 解析括号表达式
+		if (currentToken === '(') {
+			this.pos++
+			const res = this.parseTernary()
+			if (this.tokens[this.pos] !== ')') {
+				throw new Error(`括号未闭合：缺少 )（当前Token：${this.tokens[this.pos] || '空'}, 位置：${this.pos}）`)
 			}
+			this.pos++
+			return res
+		}
 
-			// 数字
-			if (typeof currentToken === 'number') {
-				const num = currentToken
-				pos++
-				return num
+		// 解析函数调用
+		if (typeof currentToken === 'string' && /^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(currentToken)) {
+			const funcName = currentToken
+			this.pos++
+
+			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)
 			}
 
-			throw new Error(`无效Token: ${currentToken}（位置：${pos}）`)
+			throw new Error(`不支持变量: ${funcName}（仅支持函数调用和字面量）`)
 		}
 
-		// 一元运算符解析（不变）
-		const parseUnary = () => {
-			const token = tokens[pos]
-			if (UNARY_OP_MAP[token]) {
-				const opName = UNARY_OP_MAP[token]
-				pos++
-				return self.operators[opName].fn(parsePrimary())
-			}
-			return parsePrimary()
+		// 解析数字
+		if (typeof currentToken === 'number' || /^\d+\.?\d*|\.\d+$/.test(currentToken)) {
+			this.pos++
+			return Number(currentToken)
 		}
 
-		// 幂运算解析（不变）
-		const parseExponential = () => {
-			let res = parseUnary()
-			while (tokens[pos] === '**') {
-				pos++
-				res = self.operators['**'].fn(res, parseUnary())
-			}
-			return res
-		}
+		throw new Error(`无效Token: ${currentToken}（位置：${this.pos}）`)
+	}
 
-		// 乘除取模解析（不变）
-		const parseMultiplicative = () => {
-			let res = parseExponential()
-			while (ARITHMETIC_OP_MAP[tokens[pos]] && ['*', '/', '%'].includes(tokens[pos])) {
-				const op = tokens[pos]
-				pos++
-				res = self.operators[op].fn(res, parseExponential())
-			}
-			return res
+	// ========== 精简后的解析链（仅保留核心运算） ==========
+	/**
+	 * 解析乘/除/取模运算
+	 * @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())
 		}
+		return res
+	}
 
-		// 加减解析（不变）
-		const parseAdditive = () => {
-			let res = parseMultiplicative()
-			while (ARITHMETIC_OP_MAP[tokens[pos]] && ['+', '-'].includes(tokens[pos])) {
-				const op = tokens[pos]
-				pos++
-				res = self.operators[op].fn(res, parseMultiplicative())
-			}
-			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
+	}
 
-		// 位移解析（不变）
-		const parseShift = () => {
-			let res = parseAdditive()
-			while (SHIFT_OP_MAP[tokens[pos]]) {
-				const op = tokens[pos]
-				pos++
-				res = self.operators[op].fn(res, parseAdditive())
-			}
-			return res
+	/**
+	 * 解析关系运算（<、>、<=、>=）
+	 * @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
+	}
 
-		// 关系运算符解析（不变）
-		const parseRelational = () => {
-			let res = parseShift()
-			while (RELATIONAL_OP_MAP[tokens[pos]]) {
-				const op = tokens[pos]
-				pos++
-				res = self.operators[op].fn(res, parseShift())
-			}
-			return res
+	/**
+	 * 解析相等运算（==、!=、===、!==）
+	 * @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 parseEquality = () => {
-			let res = parseRelational()
-			while (EQUALITY_OP_MAP[tokens[pos]]) {
-				const op = tokens[pos]
-				pos++
-				res = self.operators[op].fn(res, parseRelational())
-			}
-			return res
+	/**
+	 * 解析按位与运算
+	 * @private
+	 * @returns {number} 运算结果
+	 */
+	parseBitwiseAnd() {
+		let res = this.parseEquality()
+		while (this.tokens[this.pos] === '&') {
+			this.pos++
+			res = this.operators['&'].fn(res, this.parseEquality())
 		}
+		return res
+	}
 
-		// 按位与解析（不变）
-		const parseBitwiseAnd = () => {
-			let res = parseEquality()
-			while (tokens[pos] === '&') {
-				pos++
-				res = self.operators['&'].fn(res, parseEquality())
-			}
-			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
+	}
 
-		// 按位异或解析（不变）
-		const parseBitwiseXor = () => {
-			let res = parseBitwiseAnd()
-			while (tokens[pos] === '^') {
-				pos++
-				res = self.operators['^'].fn(res, parseBitwiseAnd())
-			}
-			return res
+	/**
+	 * 解析按位或运算
+	 * @private
+	 * @returns {number} 运算结果
+	 */
+	parseBitwiseOr() {
+		let res = this.parseBitwiseXor()
+		while (this.tokens[this.pos] === '|') {
+			this.pos++
+			res = this.operators['|'].fn(res, this.parseBitwiseXor())
 		}
+		return res
+	}
 
-		// 按位或解析（不变）
-		const parseBitwiseOr = () => {
-			let res = parseBitwiseXor()
-			while (tokens[pos] === '|') {
-				pos++
-				res = self.operators['|'].fn(res, parseBitwiseXor())
-			}
-			return res
+	/**
+	 * 解析逻辑与运算
+	 * @private
+	 * @returns {boolean} 运算结果
+	 */
+	parseLogicalAnd() {
+		let res = this.parseBitwiseOr()
+		while (this.tokens[this.pos] === '&&') {
+			this.pos++
+			res = this.operators['&&'].fn(res, this.parseBitwiseOr())
 		}
+		return res
+	}
 
-		// 逻辑与解析（不变）
-		const parseLogicalAnd = () => {
-			let res = parseBitwiseOr()
-			while (tokens[pos] === '&&') {
-				pos++
-				res = self.operators['&&'].fn(res, parseBitwiseOr())
-			}
-			return res
+	/**
+	 * 解析逻辑或运算
+	 * @private
+	 * @returns {boolean} 运算结果
+	 */
+	parseLogicalOr() {
+		let res = this.parseLogicalAnd()
+		while (this.tokens[this.pos] === '||') {
+			this.pos++
+			res = this.operators['||'].fn(res, this.parseLogicalAnd())
 		}
+		return res
+	}
 
-		// 逻辑或解析（不变）
-		const parseLogicalOr = () => {
-			let res = parseLogicalAnd()
-			while (tokens[pos] === '||') {
-				pos++
-				res = self.operators['||'].fn(res, parseLogicalAnd())
-			}
-			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)
 		}
+		return res
+	}
 
-		// if-else 解析（不变）
-		const parseIfElse = () => {
-			// 第一步：判断当前Token是否是if
-			if (tokens[pos] !== 'if') {
-				// 不是if，走原有三元运算符解析逻辑
-				return parseTernaryCore()
-			}
-
-			// 第二步：解析if关键字
-			pos++ // 跳过if关键字
-
-			// 第三步：解析if后面的括号条件，比如 if (2>1) 中的 (2>1)
-			if (tokens[pos] !== '(') {
-				throw new Error(`if语法错误：缺少左括号（当前Token：${tokens[pos] || '空'}, 位置：${pos}）`)
-			}
-			pos++ // 跳过左括号(
-			const condition = parseTernaryCore() // 解析条件表达式（支持所有原有运算符）
-			if (tokens[pos] !== ')') {
-				throw new Error(`if语法错误：缺少右括号（当前Token：${tokens[pos] || '空'}, 位置：${pos}）`)
-			}
-			pos++ // 跳过右括号)
-
-			// 第四步：解析if的结果（then分支），比如 if (2>1) 9 中的 9
-			const thenValue = parseTernaryCore()
-
-			// 第五步：解析else关键字
-			if (tokens[pos] !== 'else') {
-				throw new Error(`if语法错误：缺少else关键字（当前Token：${tokens[pos] || '空'}, 位置：${pos}）`)
-			}
-			pos++ // 跳过else关键字
-
-			// 第六步：解析else的结果（else分支），比如 if (2>1)9 else10 中的10
-			const elseValue = parseTernaryCore()
+	/**
+	 * 解析if/else和三元运算
+	 * @private
+	 * @returns {any} 运算结果
+	 */
+	parseIfElse() {
+		if (this.tokens[this.pos] !== 'if') return this.parseTernaryCore()
+		this.pos++
 
-			// 第七步：返回最终结果（条件为true返回thenValue，否则返回elseValue）
-			return condition ? thenValue : elseValue
+		if (this.tokens[this.pos] !== '(') {
+			throw new Error(`if语法错误：缺少左括号（当前Token：${this.tokens[this.pos] || '空'}, 位置：${this.pos}）`)
 		}
+		this.pos++
 
-		// 三元运算符核心解析（不变）
-		const parseTernaryCore = () => {
-			let res = parseLogicalOr()
-			if (tokens[pos] === '?') {
-				pos++
-				const a = parseTernaryCore()
-				if (tokens[pos] !== ':') throw new Error('三元运算符缺少冒号')
-				pos++
-				const b = parseTernaryCore()
-				res = self.operators['?:'].fn(res, a, b)
-			}
-			return res
+		const condition = this.parseTernaryCore()
+		if (this.tokens[this.pos] !== ')') {
+			throw new Error(`if语法错误：缺少右括号（当前Token：${this.tokens[this.pos] || '空'}, 位置：${this.pos}）`)
 		}
+		this.pos++
 
-		// 三元运算符入口（不变）
-		const parseTernary = () => {
-			// 先解析if-else，再解析三元运算符
-			return parseIfElse()
+		const thenValue = this.parseTernaryCore()
+		if (this.tokens[this.pos] !== 'else') {
+			throw new Error(`if语法错误：缺少else关键字（当前Token：${this.tokens[this.pos] || '空'}, 位置：${this.pos}）`)
 		}
+		this.pos++
 
-		// 解析入口（不变）
-		this._parseEntry = inputTokens => {
-			tokens = inputTokens
-			pos = 0
-			const result = parseTernary()
-			if (pos < tokens.length) {
-				throw new Error(`表达式多余内容: ${tokens.slice(pos).join('')}（位置：${pos}）`)
-			}
-			return result
-		}
+		const elseValue = this.parseTernaryCore()
+		return condition ? thenValue : elseValue
+	}
+
+	/**
+	 * 入口解析方法
+	 * @private
+	 * @returns {any} 运算结果
+	 */
+	parseTernary() {
+		return this.parseIfElse()
 	}
 
 	/**
-	 * 分词器（扩展支持字符串字面量，原有逻辑不变）
+	 * 分词处理
+	 * @private
+	 * @param {string} expr 表达式
+	 * @returns {Array} 分词结果
 	 */
 	_tokenize(expr) {
 		const tokens = []
-		TOKEN_REG.lastIndex = 0
+		const reg = new RegExp(ExprEvaluator.TOKEN_REG.source, 'g')
 		let match
-		const utils = utilsModule.__esModule ? utilsModule.default : utilsModule
 
-		while ((match = TOKEN_REG.exec(expr)) !== null) {
-			const token = match[1]
-			// 1. 字符串字面量：直接保留（后续在parsePrimary中去掉引号）
-			if (token.startsWith('"') || token.startsWith("'")) {
+		while ((match = reg.exec(expr)) !== null) {
+			const token = match[0].trim()
+			if (!token) continue
+
+			if (token.includes('#JSON#')) {
 				tokens.push(token)
-			}
-			// 2. 数字转换（兼容整数/小数）
-			else if (/^\d+(\.\d+)?$/.test(token)) {
-				tokens.push(utils.toNumber(token))
-			}
-			// 3. 其他Token（关键字/运算符/标识符）：原样保留
-			else {
+			} else if (token.startsWith('"') || token.startsWith("'")) {
+				tokens.push(token)
+			} else if (/^\d+\.?\d*|\.\d+$/.test(token)) {
+				tokens.push(Number(token))
+			} else {
 				tokens.push(token)
 			}
 		}
@@ -489,22 +509,28 @@ class ExprEvaluator {
 	}
 
 	/**
-	 * 对外核心方法（兼容换行符，原有逻辑不变）
+	 * 对外求值方法
+	 * @public
+	 * @param {string} expr 表达式
+	 * @returns {any} 结果
 	 */
 	evaluate(expr) {
 		this._lazyInit()
 
 		if (typeof expr !== 'string') throw new Error('表达式必须是字符串')
+		const normalizedExpr = expr.replace(/[\n\r]/g, ' ').trim()
+		if (!normalizedExpr) throw new Error('表达式不能为空')
 
-		// 替换所有换行符（\n/\r/\r\n）为空格，兼容换行
-		const normalizedExpr = expr.replace(/[\n\r]/g, ' ')
-		const trimmed = normalizedExpr.trim()
+		try {
+			this.tokens = this._tokenize(normalizedExpr)
+			this.pos = 0
+			const result = this.parseTernary()
 
-		if (!trimmed) throw new Error('表达式不能为空')
+			if (this.pos < this.tokens.length) {
+				throw new Error(`表达式多余内容: ${this.tokens.slice(this.pos).join('')}（位置：${this.pos}）`)
+			}
 
-		try {
-			const tokens = this._tokenize(trimmed)
-			return this._parseEntry(tokens)
+			return result
 		} catch (error) {
 			throw new Error(`表达式计算失败: ${error.message}（原表达式：${expr}）`)
 		}

package/packages/index.js

@@ -2,4 +2,6 @@ import http from './api'
 import utils from './utils'
 import expr from './expr'
 
+export { http, utils, expr }
+
 export default { http, utils, expr }

package/packages/utils/index.js

@@ -6,6 +6,7 @@ import array from './array'
 import number from './number'
 import string from './string'
 import boolean from './boolean'
+import time from './time'
 import color from './color'
 import dom from './dom'
 import other from './other'
@@ -17,6 +18,7 @@ XEUtils.mixin({
 	...number,
 	...string,
 	...boolean,
+	...time,
 	...color,
 	...dom,
 	...other,

package/packages/utils/number.js

@@ -15,7 +15,7 @@ export default {
 	calculate(formula, data) {
 		if (!formula) return ''
 		if (data && XEUtils.isPlainObject(data)) {
-			formula = stringUtil.format(formula, data, true)
+			formula = stringUtil.format(formula, data)
 		}
 		return formulaParser.evaluate(formula)
 	}

package/packages/utils/other.js

@@ -11,27 +11,6 @@ const endStrs = ['Id', '_id']
 const dateReplaceMap = { YYYY: 'yyyy', DD: 'dd', hh: 'HH' }
 
 export default {
-	toDateDiffText(date) {
-		let currDate = 1544407800000 // '2018-12-10 10:10:00'
-		let dateDiff = XEUtils.getDateDiff(date, currDate)
-		if (dateDiff.done) {
-			if (dateDiff.time < 10000) {
-				return '刚刚'
-			} else if (dateDiff.time < 60000) {
-				return `${dateDiff.ss}秒之前`
-			} else if (dateDiff.time < 360000) {
-				return `${dateDiff.mm}分钟之前`
-			} else if (dateDiff.time < 86400000) {
-				return `${dateDiff.HH}小时之前`
-			} else if (dateDiff.time < 2592000000) {
-				return `${dateDiff.dd}天之前`
-			} else if (dateDiff.time < 31536000000) {
-				return `${dateDiff.MM}个月之前`
-			}
-			return `${dateDiff.yyyy}年之前`
-		}
-		return '错误类型'
-	},
 	ioToFile(io, fileName = 'download', type = 'blob') {
 		return new Promise((resolve, reject) => {
 			try {

package/packages/utils/string.js

@@ -4,19 +4,26 @@ import XEUtils from 'xe-utils'
 function getFormatKeys(format) {
 	let regR = new RegExp('({[a-zA-Z0-9_.]*})', 'ig')
 	let formatStr = String(format)
-	return (formatStr.match(regR) || []).map((key, keyIndex) => {
-		return key.replace(/{|}/gi, '')
-	})
+	return (formatStr.match(regR) || []).map((key, keyIndex) => key.replace(/{|}/gi, ''))
 }
 
 // 格式化数据结构
-function format(format, data, toNumber) {
+function format(format, data) {
 	let keys = getFormatKeys(format)
 	let formatStr = String(format)
 	keys.map((key, indexkey) => {
 		let value = XEUtils.get(data, key) || ''
-		if (toNumber) value = XEUtils.toNumber(value)
-		formatStr = formatStr.replace(new RegExp('{' + key + '}', 'ig'), value)
+		let replaceValue = ''
+		if (value === undefined || value === null) {
+			replaceValue = '""'
+		} else if (typeof value === 'object' || Array.isArray(value)) {
+			replaceValue = `#JSON#${JSON.stringify(value)}#JSON#`
+		} else if (typeof value === 'string') {
+			replaceValue = `"${value}"`
+		} else {
+			replaceValue = value
+		}
+		formatStr = formatStr.replace(new RegExp('{' + key + '}', 'ig'), replaceValue)
 	})
 	return formatStr
 }

package/packages/utils/time.js

@@ -1 +1,85 @@
-export default {}
+import XEUtils from 'xe-utils'
+
+// 常量定义：各单位对应的毫秒数
+const TIME_UNIT = {
+	second: 1000,
+	minute: 1000 * 60,
+	hour: 1000 * 60 * 60,
+	day: 1000 * 60 * 60 * 24
+}
+
+const getDataDiff = (date1, date2) => {
+	let datePre = ''
+	let dateDiff = XEUtils.getDateDiff(date1, date2)
+	if (!dateDiff.done) {
+		dateDiff = XEUtils.getDateDiff(date2, date1)
+		datePre = '-'
+	}
+	return { datePre, dateDiff }
+}
+
+export default {
+	toDateDiffText(date) {
+		let currDate = 1544407800000 // '2018-12-10 10:10:00'
+		let dateDiff = XEUtils.getDateDiff(date, currDate)
+		if (dateDiff.done) {
+			if (dateDiff.time < 10000) {
+				return '刚刚'
+			} else if (dateDiff.time < 60000) {
+				return `${dateDiff.ss}秒之前`
+			} else if (dateDiff.time < 360000) {
+				return `${dateDiff.mm}分钟之前`
+			} else if (dateDiff.time < 86400000) {
+				return `${dateDiff.HH}小时之前`
+			} else if (dateDiff.time < 2592000000) {
+				return `${dateDiff.dd}天之前`
+			} else if (dateDiff.time < 31536000000) {
+				return `${dateDiff.MM}个月之前`
+			}
+			return `${dateDiff.yyyy}年之前`
+		}
+		return '错误类型'
+	},
+	getYearDiff(date1, date2, isSupply) {
+		// isSupply: 为是否补充，即不足一年按整年算
+		let { datePre, dateDiff } = getDataDiff(date1, date2)
+		let dataValue = dateDiff.yyyy
+		if (isSupply && (dateDiff.MM || dateDiff.dd || dateDiff.HH || dateDiff.mm || dateDiff.ss)) {
+			dataValue += 1
+		}
+		return Number(`${datePre}${dataValue}`)
+	},
+	getMonthDiff(date1, date2, isSupply) {
+		// isSupply: 为是否补充，即不足一月按整月算
+		let { datePre, dateDiff } = getDataDiff(date1, date2)
+		let dataValue = XEUtils.multiply(dateDiff.yyyy, 12) + dateDiff.MM
+		if (isSupply && (dateDiff.dd || dateDiff.HH || dateDiff.mm || dateDiff.ss)) {
+			dataValue += 1
+		}
+		return Number(`${datePre}${dataValue}`)
+	},
+	getDayDiff(date1, date2, isSupply) {
+		// isSupply: 为是否补充，即不足一天按整天算
+		let { datePre, dateDiff } = getDataDiff(date1, date2)
+		let dataValue = XEUtils[isSupply ? 'ceil' : 'floor'](XEUtils.divide(dateDiff.time, TIME_UNIT.day))
+		return Number(`${datePre}${dataValue}`)
+	},
+	getHourDiff(date1, date2, isSupply) {
+		// isSupply: 为是否补充，即不足一小时按整小时算
+		let { datePre, dateDiff } = getDataDiff(date1, date2)
+		let dataValue = XEUtils[isSupply ? 'ceil' : 'floor'](XEUtils.divide(dateDiff.time, TIME_UNIT.hour))
+		return Number(`${datePre}${dataValue}`)
+	},
+	getMinuteDiff(date1, date2, isSupply) {
+		// isSupply: 为是否补充，即不足一分钟按整分钟算
+		let { datePre, dateDiff } = getDataDiff(date1, date2)
+		let dataValue = XEUtils[isSupply ? 'ceil' : 'floor'](XEUtils.divide(dateDiff.time, TIME_UNIT.minute))
+		return Number(`${datePre}${dataValue}`)
+	},
+	getSecondDiff(date1, date2, isSupply) {
+		// isSupply: 为是否补充，即不足一分钟按整分钟算
+		let { datePre, dateDiff } = getDataDiff(date1, date2)
+		let dataValue = XEUtils[isSupply ? 'ceil' : 'floor'](XEUtils.divide(dateDiff.time, TIME_UNIT.second))
+		return Number(`${datePre}${dataValue}`)
+	}
+}