AIWROK安卓苹果平台设计的实用工具库 - B2B网络软件

//🍎交流QQ群711841924群一，苹果内测群，528816639
/**
* =============================================================================
* AIWROK 核心工具库完整示例
* =============================================================================
* 基于 JavaScript ES5 标准，专为 AIWROK 平台设计的实用工具库
* 包含：对象操作、数组处理、字符串工具、数学计算、数字处理、时间管理
*
* 兼容性：Rhino 引擎 (ES5)
* 平台：AIWROK 安卓自动化软件
* 版本：2.0.0
* =============================================================================
*/
// =============================================================================
// 第一部分：对象操作工具类 (ObjectUtils)
// =============================================================================
/**
* 对象操作工具类
* 提供对象创建、合并、克隆、属性操作等高级功能
*/
var ObjectUtils = {
/**
* 深度合并多个对象
* @param {Object} target - 目标对象
* @param {...Object} sources - 源对象列表
* @returns {Object} 合并后的对象
*/
deepMerge: function(target) {
var sources = Array.prototype.slice.call(arguments, 1);
for (var i = 0; i < sources.length; i++) {
var source = sources[i];
if (source && typeof source === 'object') {
for (var key in source) {
if (source.hasOwnProperty(key)) {
if (typeof source[key] === 'object' && source[key] !== null && !Array.isArray(source[key])) {
target[key] = this.deepMerge(target[key] || {}, source[key]);
} else {
target[key] = source[key];
}
}
}
}
}
return target;
},
/**
* 创建对象的深度克隆
* @param {Object} obj - 要克隆的对象
* @returns {Object} 克隆后的新对象
*/
deepClone: function(obj) {
if (obj === null || typeof obj !== 'object') {
return obj;
}
if (Array.isArray(obj)) {
var arrCopy = [];
for (var i = 0; i < obj.length; i++) {
arrCopy[i] = this.deepClone(obj[i]);
}
return arrCopy;
}
var objCopy = {};
for (var key in obj) {
if (obj.hasOwnProperty(key)) {
objCopy[key] = this.deepClone(obj[key]);
}
}
return objCopy;
},
/**
* 安全获取嵌套对象属性
* @param {Object} obj - 目标对象
* @param {string} path - 属性路径，如 "a.b.c"
* @param {*} defaultValue - 默认值
* @returns {*} 属性值或默认值
*/
getSafe: function(obj, path, defaultValue) {
if (!obj || !path) return defaultValue;
var keys = path.split('.');
var current = obj;
for (var i = 0; i < keys.length; i++) {
if (current === null || current === undefined || !current.hasOwnProperty(keys[i])) {
return defaultValue;
}
current = current[keys[i]];
}
return current !== undefined ? current : defaultValue;
},
/**
* 安全设置嵌套对象属性
* @param {Object} obj - 目标对象
* @param {string} path - 属性路径
* @param {*} value - 要设置的值
*/
setSafe: function(obj, path, value) {
if (!obj || !path) return;
var keys = path.split('.');
var current = obj;
for (var i = 0; i < keys.length - 1; i++) {
if (!current[keys[i]] || typeof current[keys[i]] !== 'object') {
current[keys[i]] = {};
}
current = current[keys[i]];
}
current[keys[keys.length - 1]] = value;
},
/**
* 过滤对象属性
* @param {Object} obj - 源对象
* @param {Array} keys - 要保留的键名数组
* @returns {Object} 过滤后的对象
*/
pick: function(obj, keys) {
var result = {};
for (var i = 0; i < keys.length; i++) {
var key = keys[i];
if (obj.hasOwnProperty(key)) {
result[key] = obj[key];
}
}
return result;
},
/**
* 排除对象属性
* @param {Object} obj - 源对象
* @param {Array} keys - 要排除的键名数组
* @returns {Object} 处理后的对象
*/
omit: function(obj, keys) {
var result = {};
var excludeMap = {};
for (var i = 0; i < keys.length; i++) {
excludeMap[keys[i]] = true;
}
for (var key in obj) {
if (obj.hasOwnProperty(key) && !excludeMap[key]) {
result[key] = obj[key];
}
}
return result;
},
/**
* 检查对象是否为空
* @param {Object} obj - 要检查的对象
* @returns {boolean} 是否为空
*/
isEmpty: function(obj) {
if (!obj) return true;
for (var key in obj) {
if (obj.hasOwnProperty(key)) return false;
}
return true;
},
/**
* 将对象转换为查询字符串
* @param {Object} obj - 要转换的对象
* @returns {string} 查询字符串
*/
toQueryString: function(obj) {
var pairs = [];
for (var key in obj) {
if (obj.hasOwnProperty(key)) {
pairs.push(encodeURIComponent(key) + '=' + encodeURIComponent(obj[key]));
}
}
return pairs.join('&');
},
/**
* 将查询字符串转换为对象
* @param {string} queryString - 查询字符串
* @returns {Object} 转换后的对象
*/
fromQueryString: function(queryString) {
var result = {};
if (!queryString) return result;
var pairs = queryString.split('&');
for (var i = 0; i < pairs.length; i++) {
var pair = pairs[i].split('=');
if (pair.length === 2) {
result[decodeURIComponent(pair[0])] = decodeURIComponent(pair[1]);
}
}
return result;
}
};
// =============================================================================
// 第二部分：数组操作工具类 (ArrayUtils)
// =============================================================================
/**
* 数组操作工具类
* 提供数组遍历、过滤、排序、分组等高级功能
*/
var ArrayUtils = {
/**
* 数组去重
* @param {Array} arr - 源数组
* @returns {Array} 去重后的数组
*/
unique: function(arr) {
var result = [];
var seen = {};
for (var i = 0; i < arr.length; i++) {
var item = arr[i];
var key = typeof item + JSON.stringify(item);
if (!seen[key]) {
seen[key] = true;
result.push(item);
}
}
return result;
},
/**
* 根据条件过滤数组
* @param {Array} arr - 源数组
* @param {Function} predicate - 过滤条件函数
* @returns {Array} 过滤后的数组
*/
filter: function(arr, predicate) {
var result = [];
for (var i = 0; i < arr.length; i++) {
if (predicate(arr[i], i, arr)) {
result.push(arr[i]);
}
}
return result;
},
/**
* 数组映射转换
* @param {Array} arr - 源数组
* @param {Function} mapper - 映射函数
* @returns {Array} 转换后的数组
*/
map: function(arr, mapper) {
var result = [];
for (var i = 0; i < arr.length; i++) {
result.push(mapper(arr[i], i, arr));
}
return result;
},
/**
* 数组归约计算
* @param {Array} arr - 源数组
* @param {Function} reducer - 归约函数
* @param {*} initialValue - 初始值
* @returns {*} 归约结果
*/
reduce: function(arr, reducer, initialValue) {
var accumulator = initialValue;
var startIndex = 0;
if (arguments.length < 3) {
accumulator = arr[0];
startIndex = 1;
}
for (var i = startIndex; i < arr.length; i++) {
accumulator = reducer(accumulator, arr[i], i, arr);
}
return accumulator;
},
/**
* 查找数组元素
* @param {Array} arr - 源数组
* @param {Function} predicate - 查找条件
* @returns {*} 找到的元素或 undefined
*/
find: function(arr, predicate) {
for (var i = 0; i < arr.length; i++) {
if (predicate(arr[i], i, arr)) {
return arr[i];
}
}
return undefined;
},
/**
* 检查数组是否包含某元素
* @param {Array} arr - 源数组
* @param {*} item - 要查找的元素
* @returns {boolean} 是否包含
*/
includes: function(arr, item) {
for (var i = 0; i < arr.length; i++) {
if (arr[i] === item) {
return true;
}
}
return false;
},
/**
* 数组扁平化
* @param {Array} arr - 源数组
* @param {number} depth - 扁平化深度，默认为1
* @returns {Array} 扁平化后的数组
*/
flatten: function(arr, depth) {
depth = depth || 1;
var result = [];
for (var i = 0; i < arr.length; i++) {
if (Array.isArray(arr[i]) && depth > 0) {
result = result.concat(this.flatten(arr[i], depth - 1));
} else {
result.push(arr[i]);
}
}
return result;
},
/**
* 数组分块
* @param {Array} arr - 源数组
* @param {number} size - 每块大小
* @returns {Array} 分块后的数组
*/
chunk: function(arr, size) {
var result = [];
for (var i = 0; i < arr.length; i += size) {
var chunk = [];
for (var j = i; j < i + size && j < arr.length; j++) {
chunk.push(arr[j]);
}
result.push(chunk);
}
return result;
},
/**
* 数组排序（支持多字段排序）
* @param {Array} arr - 源数组
* @param {string|Array} fields - 排序字段
* @param {string|Array} orders - 排序方式 ('asc' 或 'desc')
* @returns {Array} 排序后的数组
*/
orderBy: function(arr, fields, orders) {
if (!Array.isArray(fields)) {
fields = [fields];
}
if (!Array.isArray(orders)) {
orders = [orders || 'asc'];
}
return arr.slice().sort(function(a, b) {
for (var i = 0; i < fields.length; i++) {
var field = fields[i];
var order = orders[i] || 'asc';
var aVal = a[field];
var bVal = b[field];
if (aVal < bVal) return order === 'asc' ? -1 : 1;
if (aVal > bVal) return order === 'asc' ? 1 : -1;
}
return 0;
});
},
/**
* 数组分组
* @param {Array} arr - 源数组
* @param {Function|string} grouper - 分组依据（函数或属性名）
* @returns {Object} 分组后的对象
*/
groupBy: function(arr, grouper) {
var result = {};
var isFunction = typeof grouper === 'function';
for (var i = 0; i < arr.length; i++) {
var key = isFunction ? grouper(arr[i], i, arr) : arr[i][grouper];
if (!result[key]) {
result[key] = [];
}
result[key].push(arr[i]);
}
return result;
},
/**
* 从数组中随机取一个元素
* @param {Array} arr - 源数组
* @returns {*} 随机元素
*/
sample: function(arr) {
if (arr.length === 0) return undefined;
return arr[Math.floor(Math.random() * arr.length)];
},
/**
* 打乱数组顺序（Fisher-Yates算法）
* @param {Array} arr - 源数组
* @returns {Array} 打乱后的数组
*/
shuffle: function(arr) {
var result = arr.slice();
for (var i = result.length - 1; i > 0; i--) {
var j = Math.floor(Math.random() * (i + 1));
var temp = result[i];
result[i] = result[j];
result[j] = temp;
}
return result;
}
};
// =============================================================================
// 第三部分：字符串操作工具类 (StringUtils)
// =============================================================================
/**
* 字符串操作工具类
* 提供字符串格式化、验证、转换等高级功能
*/
var StringUtils = {
/**
* 检查字符串是否为空或空白
* @param {string} str - 要检查的字符串
* @returns {boolean} 是否为空
*/
isEmpty: function(str) {
return !str || str.trim().length === 0;
},
/**
* 字符串反转
* @param {string} str - 源字符串
* @returns {string} 反转后的字符串
*/
reverse: function(str) {
return str.split('').reverse().join('');
},
/**
* 截取字符串（支持负数索引）
* @param {string} str - 源字符串
* @param {number} start - 开始位置
* @param {number} end - 结束位置
* @returns {string} 截取后的字符串
*/
slice: function(str, start, end) {
var len = str.length;
start = start < 0 ? Math.max(0, len + start) : Math.min(start, len);
end = end === undefined ? len : (end < 0 ? Math.max(0, len + end) : Math.min(end, len));
var result = '';
for (var i = start; i < end; i++) {
result += str[i];
}
return result;
},
/**
* 填充字符串到指定长度
* @param {string} str - 源字符串
* @param {number} length - 目标长度
* @param {string} chars - 填充字符
* @param {boolean} left - 是否左填充
* @returns {string} 填充后的字符串
*/
pad: function(str, length, chars, left) {
chars = chars || ' ';
if (str.length >= length) return str;
var padLength = length - str.length;
var padStr = '';
while (padStr.length < padLength) {
padStr += chars;
}
padStr = this.slice(padStr, 0, padLength);
return left ? padStr + str : str + padStr;
},
/**
* 左填充字符串
* @param {string} str - 源字符串
* @param {number} length - 目标长度
* @param {string} chars - 填充字符
* @returns {string} 填充后的字符串
*/
padStart: function(str, length, chars) {
return this.pad(str, length, chars, true);
},
/**
* 右填充字符串
* @param {string} str - 源字符串
* @param {number} length - 目标长度
* @param {string} chars - 填充字符
* @returns {string} 填充后的字符串
*/
padEnd: function(str, length, chars) {
return this.pad(str, length, chars, false);
},
/**
* 重复字符串
* @param {string} str - 源字符串
* @param {number} count - 重复次数
* @returns {string} 重复后的字符串
*/
repeat: function(str, count) {
if (count < 0) return '';
var result = '';
for (var i = 0; i < count; i++) {
result += str;
}
return result;
},
/**
* 截断字符串并添加省略号
* @param {string} str - 源字符串
* @param {number} length - 最大长度
* @param {string} omission - 省略符号
* @returns {string} 截断后的字符串
*/
truncate: function(str, length, omission) {
omission = omission || '...';
if (str.length <= length) return str;
return this.slice(str, 0, length - omission.length) + omission;
},
/**
* 驼峰命名转下划线命名
* @param {string} str - 驼峰命名字符串
* @returns {string} 下划线命名字符串
*/
camelToSnake: function(str) {
return str.replace(/([A-Z])/g, '_$1').toLowerCase().replace(/^_/, '');
},
/**
* 下划线命名转驼峰命名
* @param {string} str - 下划线命名字符串
* @returns {string} 驼峰命名字符串
*/
snakeToCamel: function(str) {
return str.replace(/_([a-z])/g, function(match, letter) {
return letter.toUpperCase();
});
},
/**
* 首字母大写
* @param {string} str - 源字符串
* @returns {string} 处理后的字符串
*/
capitalize: function(str) {
if (this.isEmpty(str)) return str;
return str[0].toUpperCase() + this.slice(str, 1).toLowerCase();
},
/**
* 检查字符串是否以指定前缀开头
* @param {string} str - 源字符串
* @param {string} prefix - 前缀
* @returns {boolean} 是否以该前缀开头
*/
startsWith: function(str, prefix) {
if (prefix.length > str.length) return false;
return this.slice(str, 0, prefix.length) === prefix;
},
/**
* 检查字符串是否以指定后缀结尾
* @param {string} str - 源字符串
* @param {string} suffix - 后缀
* @returns {boolean} 是否以该后缀结尾
*/
endsWith: function(str, suffix) {
if (suffix.length > str.length) return false;
return this.slice(str, str.length - suffix.length) === suffix;
},
/**
* 移除字符串中的空白字符
* @param {string} str - 源字符串
* @returns {string} 处理后的字符串
*/
removeWhitespace: function(str) {
var result = '';
for (var i = 0; i < str.length; i++) {
if (str[i] !== ' ' && str[i] !== '\t' && str[i] !== '\n' && str[i] !== '\r') {
result += str[i];
}
}
return result;
},
/**
* 统计字符出现次数
* @param {string} str - 源字符串
* @param {string} char - 要统计的字符
* @returns {number} 出现次数
*/
countChar: function(str, char) {
var count = 0;
for (var i = 0; i < str.length; i++) {
if (str[i] === char) count++;
}
return count;
},
/**
* 生成随机字符串
* @param {number} length - 字符串长度
* @param {string} chars - 字符集
* @returns {string} 随机字符串
*/
random: function(length, chars) {
chars = chars || 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
var result = '';
for (var i = 0; i < length; i++) {
result += chars.charAt(Math.floor(Math.random() * chars.length));
}
return result;
}
};
// =============================================================================
// 第四部分：数学计算工具类 (MathUtils)
// =============================================================================
/**
* 数学计算工具类
* 提供数值计算、随机数生成、几何计算等高级功能
*/
var MathUtils = {
/**
* 角度转弧度
* @param {number} degrees - 角度值
* @returns {number} 弧度值
*/
toRadians: function(degrees) {
return degrees * (Math.PI / 180);
},
/**
* 弧度转角度
* @param {number} radians - 弧度值
* @returns {number} 角度值
*/
toDegrees: function(radians) {
return radians * (180 / Math.PI);
},
/**
* 限制数值在指定范围内
* @param {number} value - 要限制的数值
* @param {number} min - 最小值
* @param {number} max - 最大值
* @returns {number} 限制后的数值
*/
clamp: function(value, min, max) {
return Math.min(Math.max(value, min), max);
},
/**
* 线性插值
* @param {number} start - 起始值
* @param {number} end - 结束值
* @param {number} t - 插值系数 (0-1)
* @returns {number} 插值结果
*/
lerp: function(start, end, t) {
return start + (end - start) * t;
},
/**
* 两点间距离
* @param {number} x1 - 第一点X坐标
* @param {number} y1 - 第一点Y坐标
* @param {number} x2 - 第二点X坐标
* @param {number} y2 - 第二点Y坐标
* @returns {number} 距离
*/
distance: function(x1, y1, x2, y2) {
var dx = x2 - x1;
var dy = y2 - y1;
return Math.sqrt(dx * dx + dy * dy);
},
/**
* 计算两点间角度
* @param {number} x1 - 第一点X坐标
* @param {number} y1 - 第一点Y坐标
* @param {number} x2 - 第二点X坐标
* @param {number} y2 - 第二点Y坐标
* @returns {number} 角度（度）
*/
angle: function(x1, y1, x2, y2) {
return this.toDegrees(Math.atan2(y2 - y1, x2 - x1));
},
/**
* 生成指定范围内的随机整数
* @param {number} min - 最小值（包含）
* @param {number} max - 最大值（包含）
* @returns {number} 随机整数
*/
randomInt: function(min, max) {
return Math.floor(Math.random() * (max - min + 1)) + min;
},
/**
* 生成指定范围内的随机浮点数
* @param {number} min - 最小值
* @param {number} max - 最大值
* @returns {number} 随机浮点数
*/
randomFloat: function(min, max) {
return Math.random() * (max - min) + min;
},
/**
* 判断点是否在矩形内
* @param {number} px - 点X坐标
* @param {number} py - 点Y坐标
* @param {number} rx - 矩形左上角X坐标
* @param {number} ry - 矩形左上角Y坐标
* @param {number} rw - 矩形宽度
* @param {number} rh - 矩形高度
* @returns {boolean} 是否在矩形内
*/
pointInRect: function(px, py, rx, ry, rw, rh) {
return px >= rx && px <= rx + rw && py >= ry && py <= ry + rh;
},
/**
* 判断点是否在圆内
* @param {number} px - 点X坐标
* @param {number} py - 点Y坐标
* @param {number} cx - 圆心X坐标
* @param {number} cy - 圆心Y坐标
* @param {number} radius - 圆半径
* @returns {boolean} 是否在圆内
*/
pointInCircle: function(px, py, cx, cy, radius) {
return this.distance(px, py, cx, cy) <= radius;
},
/**
* 计算平均值
* @param {...number} numbers - 数值列表
* @returns {number} 平均值
*/
average: function() {
var sum = 0;
for (var i = 0; i < arguments.length; i++) {
sum += arguments[i];
}
return sum / arguments.length;
},
/**
* 计算标准差
* @param {Array} numbers - 数值数组
* @returns {number} 标准差
*/
standardDeviation: function(numbers) {
var avg = this.average.apply(this, numbers);
var sumSquaredDiff = 0;
for (var i = 0; i < numbers.length; i++) {
var diff = numbers[i] - avg;
sumSquaredDiff += diff * diff;
}
return Math.sqrt(sumSquaredDiff / numbers.length);
},
/**
* 判断两个矩形是否相交
* @param {Object} rect1 - 第一个矩形 {x, y, width, height}
* @param {Object} rect2 - 第二个矩形 {x, y, width, height}
* @returns {boolean} 是否相交
*/
rectIntersect: function(rect1, rect2) {
return !(rect2.x > rect1.x + rect1.width ||
rect2.x + rect2.width < rect1.x ||
rect2.y > rect1.y + rect1.height ||
rect2.y + rect2.height < rect1.y);
},
/**
* 计算阶乘
* @param {number} n - 非负整数
* @returns {number} 阶乘结果
*/
factorial: function(n) {
if (n < 0) return NaN;
if (n === 0 || n === 1) return 1;
var result = 1;
for (var i = 2; i <= n; i++) {
result *= i;
}
return result;
},
/**
* 计算组合数 C(n, k)
* @param {number} n - 总数
* @param {number} k - 选取数
* @returns {number} 组合数
*/
combination: function(n, k) {
if (k > n) return 0;
if (k === 0 || k === n) return 1;
return this.factorial(n) / (this.factorial(k) * this.factorial(n - k));
}
};
// =============================================================================
// 第五部分：数字处理工具类 (NumberUtils)
// =============================================================================
/**
* 数字处理工具类
* 提供数字格式化、转换、验证等高级功能
*/
var NumberUtils = {
/**
* 将数字格式化为千分位字符串
* @param {number} num - 要格式化的数字
* @param {number} decimals - 小数位数
* @returns {string} 格式化后的字符串
*/
formatThousands: function(num, decimals) {
decimals = decimals !== undefined ? decimals : 2;
var fixed = num.toFixed(decimals);
var parts = fixed.split('.');
var integerPart = parts[0];
var decimalPart = parts[1] || '';
var result = '';
var count = 0;
for (var i = integerPart.length - 1; i >= 0; i--) {
result = integerPart[i] + result;
count++;
if (count % 3 === 0 && i > 0 && integerPart[i - 1] !== '-') {
result = ',' + result;
}
}
return decimalPart ? result + '.' + decimalPart : result;
},
/**
* 将字节数转换为可读格式
* @param {number} bytes - 字节数
* @param {number} decimals - 小数位数
* @returns {string} 可读格式字符串
*/
formatBytes: function(bytes, decimals) {
decimals = decimals !== undefined ? decimals : 2;
if (bytes === 0) return '0 Bytes';
var k = 1024;
var sizes = ['Bytes', 'KB', 'MB', 'GB', 'TB'];
var i = Math.floor(Math.log(bytes) / Math.log(k));
return parseFloat((bytes / Math.pow(k, i)).toFixed(decimals)) + ' ' + sizes[i];
},
/**
* 将毫秒转换为可读时间
* @param {number} ms - 毫秒数
* @returns {string} 可读时间字符串
*/
formatDuration: function(ms) {
if (ms < 1000) return ms + 'ms';
var seconds = Math.floor(ms / 1000);
if (seconds < 60) return seconds + 's';
var minutes = Math.floor(seconds / 60);
if (minutes < 60) return minutes + 'm ' + (seconds % 60) + 's';
var hours = Math.floor(minutes / 60);
return hours + 'h ' + (minutes % 60) + 'm';
},
/**
* 检查是否为整数
* @param {*} value - 要检查的值
* @returns {boolean} 是否为整数
*/
isInteger: function(value) {
return typeof value === 'number' && isFinite(value) && Math.floor(value) === value;
},
/**
* 检查是否为数字
* @param {*} value - 要检查的值
* @returns {boolean} 是否为数字
*/
isNumber: function(value) {
return typeof value === 'number' && isFinite(value);
},
/**
* 将字符串转换为数字
* @param {string} str - 要转换的字符串
* @param {*} defaultValue - 转换失败时的默认值
* @returns {number} 转换后的数字
*/
toNumber: function(str, defaultValue) {
var num = parseFloat(str);
return isNaN(num) ? defaultValue : num;
},
/**
* 将数字转换为中文大写金额
* @param {number} num - 要转换的数字
* @returns {string} 中文大写金额
*/
toChineseMoney: function(num) {
var units = ['', '十', '百', '千'];
var bigUnits = ['', '万', '亿'];
var digits = ['零', '一', '二', '三', '四', '五', '六', '七', '八', '九'];
if (num === 0) return '零';
if (num < 0) return '负' + this.toChineseMoney(-num);
var strNum = Math.floor(num).toString();
var result = '';
var zeroCount = 0;
var bigUnitIndex = 0;
for (var i = strNum.length - 1; i >= 0; i -= 4) {
var part = '';
var partZero = true;
for (var j = 0; j < 4 && i - j >= 0; j++) {
var digit = parseInt(strNum[i - j]);
if (digit === 0) {
zeroCount++;
} else {
if (zeroCount > 0) {
part = digits[0] + part;
zeroCount = 0;
}
part = digits[digit] + units[j] + part;
partZero = false;
}
}
if (!partZero) {
result = part + bigUnits[bigUnitIndex] + result;
}
bigUnitIndex++;
}
return result.replace(/零+/g, '零').replace(/零$/, '');
},
/**
* 将数字转换为罗马数字
* @param {number} num - 要转换的数字 (1-3999)
* @returns {string} 罗马数字
*/
toRoman: function(num) {
if (num < 1 || num > 3999) return '';
var values = [1000, 900, 500, 400, 100, 90, 50, 40, 10, 9, 5, 4, 1];
var symbols = ['M', 'CM', 'D', 'CD', 'C', 'XC', 'L', 'XL', 'X', 'IX', 'V', 'IV', 'I'];
var result = '';
for (var i = 0; i < values.length; i++) {
while (num >= values[i]) {
result += symbols[i];
num -= values[i];
}
}
return result;
},
/**
* 将罗马数字转换为数字
* @param {string} roman - 罗马数字
* @returns {number} 转换后的数字
*/
fromRoman: function(roman) {
var values = {I: 1, V: 5, X: 10, L: 50, C: 100, D: 500, M: 1000};
var result = 0;
for (var i = 0; i < roman.length; i++) {
var current = values[roman[i]];
var next = values[roman[i + 1]];
if (next && current < next) {
result -= current;
} else {
result += current;
}
}
return result;
},
/**
* 生成指定范围内的随机数数组
* @param {number} count - 数组长度
* @param {number} min - 最小值
* @param {number} max - 最大值
* @returns {Array} 随机数数组
*/
randomArray: function(count, min, max) {
var result = [];
for (var i = 0; i < count; i++) {
result.push(MathUtils.randomInt(min, max));
}
return result;
}
};
// =============================================================================
// 第六部分：时间管理工具类 (TimeUtils)
// =============================================================================
/**
* 时间管理工具类
* 提供日期时间格式化、计算、转换等高级功能
*/
var TimeUtils = {
/**
* 格式化日期时间
* @param {Date} date - 日期对象
* @param {string} format - 格式字符串 (yyyy-MM-dd HH:mm:ss)
* @returns {string} 格式化后的字符串
*/
format: function(date, format) {
format = format || 'yyyy-MM-dd HH:mm:ss';
var year = date.getFullYear();
var month = date.getMonth() + 1;
var day = date.getDate();
var hours = date.getHours();
var minutes = date.getMinutes();
var seconds = date.getSeconds();
var milliseconds = date.getMilliseconds();
return format
.replace(/yyyy/g, year)
.replace(/MM/g, StringUtils.padStart(month.toString(), 2, '0'))
.replace(/dd/g, StringUtils.padStart(day.toString(), 2, '0'))
.replace(/HH/g, StringUtils.padStart(hours.toString(), 2, '0'))
.replace(/mm/g, StringUtils.padStart(minutes.toString(), 2, '0'))
.replace(/ss/g, StringUtils.padStart(seconds.toString(), 2, '0'))
.replace(/SSS/g, StringUtils.padStart(milliseconds.toString(), 3, '0'));
},
/**
* 获取当前时间字符串
* @param {string} format - 格式字符串
* @returns {string} 当前时间字符串
*/
now: function(format) {
return this.format(new Date(), format);
},
/**
* 获取今天的开始时间
* @returns {Date} 今天的开始时间
*/
startOfDay: function() {
var date = new Date();
date.setHours(0, 0, 0, 0);
return date;
},
/**
* 获取今天的结束时间
* @returns {Date} 今天的结束时间
*/
endOfDay: function() {
var date = new Date();
date.setHours(23, 59, 59, 999);
return date;
},
/**
* 添加时间
* @param {Date} date - 原日期
* @param {number} amount - 数量
* @param {string} unit - 单位 (year, month, day, hour, minute, second)
* @returns {Date} 新的日期
*/
add: function(date, amount, unit) {
var result = new Date(date);
switch (unit) {
case 'year':
result.setFullYear(result.getFullYear() + amount);
break;
case 'month':
result.setMonth(result.getMonth() + amount);
break;
case 'day':
result.setDate(result.getDate() + amount);
break;
case 'hour':
result.setHours(result.getHours() + amount);
break;
case 'minute':
result.setMinutes(result.getMinutes() + amount);
break;
case 'second':
result.setSeconds(result.getSeconds() + amount);
break;
}
return result;
},
/**
* 计算两个日期之间的差值
* @param {Date} date1 - 第一个日期
* @param {Date} date2 - 第二个日期
* @param {string} unit - 返回单位 (ms, s, m, h, d)
* @returns {number} 差值
*/
diff: function(date1, date2, unit) {
var diffMs = date2 - date1;
switch (unit) {
case 'ms': return diffMs;
case 's': return Math.floor(diffMs / 1000);
case 'm': return Math.floor(diffMs / (1000 * 60));
case 'h': return Math.floor(diffMs / (1000 * 60 * 60));
case 'd': return Math.floor(diffMs / (1000 * 60 * 60 * 24));
default: return diffMs;
}
},
/**
* 判断是否为闰年
* @param {number} year - 年份
* @returns {boolean} 是否为闰年
*/
isLeapYear: function(year) {
return (year % 4 === 0 && year % 100 !== 0) || (year % 400 === 0);
},
/**
* 获取月份天数
* @param {number} year - 年份
* @param {number} month - 月份 (1-12)
* @returns {number} 天数
*/
daysInMonth: function(year, month) {
var days = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];
if (month === 2 && this.isLeapYear(year)) {
return 29;
}
return days[month - 1];
},
/**
* 获取日期是星期几
* @param {Date} date - 日期
* @returns {string} 星期几
*/
dayOfWeek: function(date) {
var days = ['星期日', '星期一', '星期二', '星期三', '星期四', '星期五', '星期六'];
return days[date.getDay()];
},
/**
* 获取日期是一年中的第几天
* @param {Date} date - 日期
* @returns {number} 第几天
*/
dayOfYear: function(date) {
var start = new Date(date.getFullYear(), 0, 0);
var diff = date - start;
return Math.floor(diff / (1000 * 60 * 60 * 24));
},
/**
* 获取日期所在周的起始日期
* @param {Date} date - 日期
* @returns {Date} 周起始日期（周一）
*/
startOfWeek: function(date) {
var result = new Date(date);
var day = result.getDay();
var diff = result.getDate() - day + (day === 0 ? -6 : 1);
result.setDate(diff);
result.setHours(0, 0, 0, 0);
return result;
},
/**
* 倒计时格式化
* @param {number} seconds - 剩余秒数
* @returns {string} 格式化后的倒计时
*/
countdown: function(seconds) {
var hours = Math.floor(seconds / 3600);
var minutes = Math.floor((seconds % 3600) / 60);
var secs = seconds % 60;
return StringUtils.padStart(hours.toString(), 2, '0') + ':' +
StringUtils.padStart(minutes.toString(), 2, '0') + ':' +
StringUtils.padStart(secs.toString(), 2, '0');
},
/**
* 获取相对时间描述
* @param {Date} date - 日期
* @returns {string} 相对时间描述
*/
fromNow: function(date) {
var now = new Date();
var diff = Math.floor((now - date) / 1000);
if (diff < 60) return '刚刚';
if (diff < 3600) return Math.floor(diff / 60) + '分钟前';
if (diff < 86400) return Math.floor(diff / 3600) + '小时前';
if (diff < 604800) return Math.floor(diff / 86400) + '天前';
return this.format(date, 'yyyy-MM-dd');
},
/**
* 解析日期字符串
* @param {string} str - 日期字符串
* @returns {Date} 日期对象
*/
parse: function(str) {
return new Date(str);
},
/**
* 获取时间戳
* @param {Date} date - 日期对象，默认为当前时间
* @returns {number} 时间戳
*/
timestamp: function(date) {
return (date || new Date()).getTime();
},
/**
* 休眠指定毫秒数（阻塞式）
* @param {number} ms - 毫秒数
*/
sleep: function(ms) {
var start = new Date().getTime();
while (new Date().getTime() - start < ms) {
// 阻塞等待
}
},
/**
* 生成时间范围数组
* @param {Date} start - 开始日期
* @param {Date} end - 结束日期
* @param {string} unit - 步进单位 (day, week, month)
* @returns {Array} 日期数组
*/
range: function(start, end, unit) {
var result = [];
var current = new Date(start);
var endDate = new Date(end);
while (current <= endDate) {
result.push(new Date(current));
switch (unit) {
case 'day':
current.setDate(current.getDate() + 1);
break;
case 'week':
current.setDate(current.getDate() + 7);
break;
case 'month':
current.setMonth(current.getMonth() + 1);
break;
}
}
return result;
}
};
// =============================================================================
// 第七部分：综合演示函数
// =============================================================================
/**
* 延迟函数 - 毫秒
*/
function delay(ms) {
var start = new Date().getTime();
while (new Date().getTime() - start < ms) {}
}
/**
* 运行所有工具类的演示
*/
function runAllDemos() {
printl('');
printl('╔══════════════════════════════════════════════════════════════════╗');
printl('║ AIWROK 核心工具库完整示例 v2.0 ║');
printl('╚══════════════════════════════════════════════════════════════════╝');
printl('');
delay(800);
demoObjectUtils();
delay(500);
demoArrayUtils();
delay(500);
demoStringUtils();
delay(500);
demoMathUtils();
delay(500);
demoNumberUtils();
delay(500);
demoTimeUtils();
printl('');
printl('╔══════════════════════════════════════════════════════════════════╗');
printl('║ ✓ 所有演示已完成！ ║');
printl('╚══════════════════════════════════════════════════════════════════╝');
printl('');
}
/**
* 对象操作工具类演示
*/
function demoObjectUtils() {
printl('┌──────────────────────────────────────────────────────────────────┐');
printl('│ ObjectUtils - 对象操作工具类 │');
printl('└──────────────────────────────────────────────────────────────────┘');
printl('');
delay(400);
printl('▶ 1. 深度合并 - 合并多个对象（包含嵌套对象）');
delay(300);
var obj1 = { a: 1, b: { c: 2 } };
var obj2 = { b: { d: 3 }, e: 4 };
var merged = ObjectUtils.deepMerge({}, obj1, obj2);
printl(' 源对象1: ' + JSON.stringify(obj1));
delay(200);
printl(' 源对象2: ' + JSON.stringify(obj2));
delay(200);
printl(' 合并结果: ' + JSON.stringify(merged));
delay(500);
printl('▶ 2. 深度克隆 - 完整复制对象（包含嵌套对象）');
delay(300);
var original = { x: 1, y: { z: 2 } };
var cloned = ObjectUtils.deepClone(original);
printl(' 原对象: ' + JSON.stringify(original));
delay(200);
printl(' 克隆: ' + JSON.stringify(cloned));
delay(500);
printl('▶ 3. 安全获取 - 获取嵌套属性，避免报错');
delay(300);
var data = { user: { profile: { name: '张三' } } };
var name = ObjectUtils.getSafe(data, 'user.profile.name', '未知');
printl(' 数据: { user: { profile: { name: "张三" } } }');
delay(200);
printl(' 读取 user.profile.name: ' + name);
delay(200);
var noExist = ObjectUtils.getSafe(data, 'user.profile.age', '默认值');
printl(' 读取 user.profile.age（不存在）: ' + noExist);
delay(500);
printl('▶ 4. 对象转查询字符串');
delay(300);
var params = { name: '张三', age: 25 };
var query = ObjectUtils.toQueryString(params);
printl(' 对象: ' + JSON.stringify(params));
delay(200);
printl(' 查询字符串: ' + query);
delay(500);
printl('▶ 5. 查询字符串转对象');
delay(300);
var parsed = ObjectUtils.fromQueryString(query);
printl(' 解析结果: ' + JSON.stringify(parsed));
delay(500);
printl('');
}
/**
* 数组操作工具类演示
*/
function demoArrayUtils() {
printl('┌──────────────────────────────────────────────────────────────────┐');
printl('│ ArrayUtils - 数组操作工具类 │');
printl('└──────────────────────────────────────────────────────────────────┘');
printl('');
delay(400);
printl('▶ 1. 数组去重 - 移除重复元素');
delay(300);
var arr1 = [1, 2, 2, 3, 3, 3, 4, 4, 5];
printl(' 原始数组: ' + JSON.stringify(arr1));
delay(200);
var unique = ArrayUtils.unique(arr1);
printl(' 去重结果: ' + JSON.stringify(unique));
delay(500);
printl('▶ 2. 数组过滤 - 按条件筛选');
delay(300);
var arr2 = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
printl(' 原始数组: ' + JSON.stringify(arr2));
delay(200);
var filtered = ArrayUtils.filter(arr2, function(x) { return x > 5; });
printl(' 过滤条件: x > 5');
printl(' 过滤结果: ' + JSON.stringify(filtered));
delay(500);
printl('▶ 3. 数组映射 - 转换每个元素');
delay(300);
printl(' 原始数组: ' + JSON.stringify(arr2));
delay(200);
var mapped = ArrayUtils.map(arr2, function(x) { return x * 2; });
printl(' 映射规则: x * 2');
printl(' 映射结果: ' + JSON.stringify(mapped));
delay(500);
printl('▶ 4. 数组分块 - 将数组分成多个小块');
delay(300);
var arr3 = [1, 2, 3, 4, 5, 6];
printl(' 原始数组: ' + JSON.stringify(arr3));
delay(200);
var chunked = ArrayUtils.chunk(arr3, 2);
printl(' 分块大小: 2');
printl(' 分块结果: ' + JSON.stringify(chunked));
delay(500);
printl('▶ 5. 数组随机取样 - 随机抽取元素');
delay(300);
var arr4 = ['苹果', '香蕉', '橙子', '葡萄', '西瓜'];
printl(' 水果列表: ' + JSON.stringify(arr4));
delay(200);
var sample = ArrayUtils.sample(arr4);
printl(' 随机抽取: ' + sample + ' 🎉');
delay(500);
printl('');
}
/**
* 字符串操作工具类演示
*/
function demoStringUtils() {
printl('┌──────────────────────────────────────────────────────────────────┐');
printl('│ StringUtils - 字符串操作工具类 │');
printl('└──────────────────────────────────────────────────────────────────┘');
printl('');
delay(400);
printl('▶ 1. 字符串填充 - 补齐位数');
delay(300);
var padded = StringUtils.padStart('42', 5, '0');
printl(' 原字符串: "42"');
printl(' 目标长度: 5, 填充字符: "0"');
printl(' 填充结果: "' + padded + '"');
delay(500);
printl('▶ 2. 字符串截断 - 限制长度');
delay(300);
var longText = '这是一段非常长的字符串，需要截断显示';
printl(' 原文: ' + longText);
delay(200);
var truncated = StringUtils.truncate(longText, 15);
printl(' 截断长度: 15');
printl(' 截断结果: ' + truncated);
delay(500);
printl('▶ 3. 驼峰转下划线 - 命名风格转换');
delay(300);
var camel = 'userNameAndPassword';
printl(' 驼峰命名: ' + camel);
delay(200);
var snake = StringUtils.camelToSnake(camel);
printl(' 下划线: ' + snake);
delay(500);
printl('▶ 4. 首字母大写');
delay(300);
var text = 'hello world';
printl(' 原文: ' + text);
delay(200);
var capitalized = StringUtils.capitalize(text);
printl(' 首字母大写: ' + capitalized);
delay(500);
printl('▶ 5. 生成随机字符串');
delay(300);
var random = StringUtils.random(12);
printl(' 随机字符串(12位): ' + random);
delay(500);
printl('');
}
/**
* 数学计算工具类演示
*/
function demoMathUtils() {
printl('┌──────────────────────────────────────────────────────────────────┐');
printl('│ MathUtils - 数学计算工具类 │');
printl('└──────────────────────────────────────────────────────────────────┘');
printl('');
delay(400);
printl('▶ 1. 角度与弧度转换');
delay(300);
var degrees = 180;
printl(' 角度: ' + degrees + '°');
delay(200);
var radians = MathUtils.toRadians(degrees);
printl(' 弧度: ' + radians.toFixed(4));
delay(500);
printl('▶ 2. 数值范围限制');
delay(300);
var testValue = 150;
printl(' 测试值: ' + testValue);
delay(200);
var clamped = MathUtils.clamp(testValue, 0, 100);
printl(' 限制范围: 0-100');
printl(' 限制结果: ' + clamped);
delay(500);
printl('▶ 3. 两点距离计算');
delay(300);
var x1 = 0, y1 = 0, x2 = 3, y2 = 4;
printl(' 点A: (' + x1 + ', ' + y1 + ')');
printl(' 点B: (' + x2 + ', ' + y2 + ')');
delay(200);
var distance = MathUtils.distance(x1, y1, x2, y2);
printl(' 距离: ' + distance);
delay(500);
printl('▶ 4. 随机整数生成');
delay(300);
var min = 1, max = 100;
printl(' 范围: ' + min + ' - ' + max);
delay(200);
var randomInt = MathUtils.randomInt(min, max);
printl(' 随机整数: ' + randomInt);
delay(500);
printl('▶ 5. 计算平均值');
delay(300);
var nums = [10, 20, 30, 40, 50];
printl(' 数字列表: ' + JSON.stringify(nums));
delay(200);
var avg = MathUtils.average.apply(null, nums);
printl(' 平均值: ' + avg);
delay(500);
printl('');
}
/**
* 数字处理工具类演示
*/
function demoNumberUtils() {
printl('┌──────────────────────────────────────────────────────────────────┐');
printl('│ NumberUtils - 数字处理工具类 │');
printl('└──────────────────────────────────────────────────────────────────┘');
printl('');
delay(400);
printl('▶ 1. 千分位格式化 - 金额显示');
delay(300);
var amount = 1234567.89;
printl(' 原始金额: ' + amount);
delay(200);
var formatted = NumberUtils.formatThousands(amount);
printl(' 格式化后: ¥' + formatted);
delay(500);
printl('▶ 2. 字节大小格式化 - 文件大小');
delay(300);
var fileSize = 1536000;
printl(' 原始字节: ' + fileSize + ' bytes');
delay(200);
var bytes = NumberUtils.formatBytes(fileSize);
printl(' 格式化后: ' + bytes);
delay(500);
printl('▶ 3. 时长格式化 - 显示友好的时间');
delay(300);
var ms = 3661000;
printl(' 原始毫秒: ' + ms);
delay(200);
var duration = NumberUtils.formatDuration(ms);
printl(' 格式化后: ' + duration);
delay(500);
printl('▶ 4. 数字转中文大写 - 金额显示');
delay(300);
var money = 12345;
printl(' 原始数字: ' + money);
delay(200);
var chinese = NumberUtils.toChineseMoney(money);
printl(' 中文大写: ' + chinese);
delay(500);
printl('▶ 5. 数字转罗马数字');
delay(300);
var year = 2024;
printl(' 原始数字: ' + year);
delay(200);
var roman = NumberUtils.toRoman(year);
printl(' 罗马数字: ' + roman);
delay(500);
printl('');
}
/**
* 时间管理工具类演示
*/
function demoTimeUtils() {
printl('┌──────────────────────────────────────────────────────────────────┐');
printl('│ TimeUtils - 时间管理工具类 │');
printl('└──────────────────────────────────────────────────────────────────┘');
printl('');
delay(400);
printl('▶ 1. 时间格式化 - 自定义格式显示');
delay(300);
var now = new Date();
printl(' 当前时间: ' + TimeUtils.format(now, 'yyyy-MM-dd HH:mm:ss'));
delay(200);
printl(' 简洁格式: ' + TimeUtils.format(now, 'MM/dd HH:mm'));
delay(500);
printl('▶ 2. 获取星期几');
delay(300);
printl(' 今天: ' + TimeUtils.dayOfWeek(now));
delay(500);
printl('▶ 3. 今年第几天');
delay(300);
printl(' 今天是今年第 ' + TimeUtils.dayOfYear(now) + ' 天');
delay(500);
printl('▶ 4. 倒计时显示');
delay(300);
var countdownSeconds = 3665;
printl(' 原始秒数: ' + countdownSeconds);
delay(200);
var countdown = TimeUtils.countdown(countdownSeconds);
printl(' 倒计时: ' + countdown);
delay(500);
printl('▶ 5. 日期加减计算');
delay(300);
printl(' 今天是: ' + TimeUtils.format(now, 'yyyy-MM-dd'));
delay(200);
var future = TimeUtils.add(now, 7, 'day');
printl(' 7天后: ' + TimeUtils.format(future, 'yyyy-MM-dd'));
delay(200);
var past = TimeUtils.add(now, -3, 'day');
printl(' 3天前: ' + TimeUtils.format(past, 'yyyy-MM-dd'));
delay(500);
printl('');
}
// 主函数入口（由 start.js 调用）
function runMainDemo() {
runAllDemos();
}
// 注意：不在此处自动运行，由 start.js 控制调用时机
// 如需直接运行此脚本，取消下面一行的注释
runMainDemo();

复制代码