设为首页收藏本站
开启辅助访问

信息发布软件,b2b软件,广告发布软件

 找回密码
 立即注册
搜索
返回列表 发新帖
查看: 3|回复: 0
打印 上一主题 下一主题

[宣传软件网站动态] AIWROK安卓苹果平台设计的实用工具库

[复制链接]
群发软件

1884

主题

1894

帖子

1万

积分

积分
11024
跳转到指定楼层
宣传软件楼主
发表于 5 小时前 | 只看该作者 |只看大图 回帖奖励 |倒序浏览 |阅读模式

资讯缩略图：

资讯发布日期：2026-03-17

资讯发布简介：AIWROK安卓苹果平台设计的实用工具库

资讯关键词：AIWROK安卓苹果平台设计的实用工具库

资讯所属分类：IT资讯 

联系：

① 本信息收集于网络，如有不对的地方欢迎联系我纠正！
② 本信息免费收录，不存在价格的问题！
③ 如果您的网站也想这样出现在这里，请您加好友情链接，我当天会审核通过！

④友情链接关键字：软件网站分类目录 网址：http://www.postbbs.com/

资讯详细描述
AIWROK安卓苹果平台设计的实用工具库
AIWROK安卓苹果平台设计的实用工具库 b2b软件

  1. //🍎交流QQ群711841924群一，苹果内测群，528816639

  3. /**
  4. * =============================================================================
  5. * AIWROK 核心工具库完整示例
  6. * =============================================================================
  7. * 基于 JavaScript ES5 标准，专为 AIWROK 平台设计的实用工具库
  8. * 包含：对象操作、数组处理、字符串工具、数学计算、数字处理、时间管理
  9. *
  10. * 兼容性：Rhino 引擎 (ES5)
  11. * 平台：AIWROK 安卓自动化软件
  12. * 版本：2.0.0
  13. * =============================================================================
  14. */

  16. // =============================================================================
  17. // 第一部分：对象操作工具类 (ObjectUtils)
  18. // =============================================================================

  20. /**
  21. * 对象操作工具类
  22. * 提供对象创建、合并、克隆、属性操作等高级功能
  23. */
  24. var ObjectUtils = {
  25.    
  26.     /**
  27.      * 深度合并多个对象
  28.      * @param {Object} target - 目标对象
  29.      * @param {...Object} sources - 源对象列表
  30.      * @returns {Object} 合并后的对象
  31.      */
  32.     deepMerge: function(target) {
  33.         var sources = Array.prototype.slice.call(arguments, 1);
  34.         for (var i = 0; i < sources.length; i++) {
  35.             var source = sources[i];
  36.             if (source && typeof source === 'object') {
  37.                 for (var key in source) {
  38.                     if (source.hasOwnProperty(key)) {
  39.                         if (typeof source[key] === 'object' && source[key] !== null && !Array.isArray(source[key])) {
  40.                             target[key] = this.deepMerge(target[key] || {}, source[key]);
  41.                         } else {
  42.                             target[key] = source[key];
  43.                         }
  44.                     }
  45.                 }
  46.             }
  47.         }
  48.         return target;
  49.     },
  50.    
  51.     /**
  52.      * 创建对象的深度克隆
  53.      * @param {Object} obj - 要克隆的对象
  54.      * @returns {Object} 克隆后的新对象
  55.      */
  56.     deepClone: function(obj) {
  57.         if (obj === null || typeof obj !== 'object') {
  58.             return obj;
  59.         }
  60.         if (Array.isArray(obj)) {
  61.             var arrCopy = [];
  62.             for (var i = 0; i < obj.length; i++) {
  63.                 arrCopy[i] = this.deepClone(obj[i]);
  64.             }
  65.             return arrCopy;
  66.         }
  67.         var objCopy = {};
  68.         for (var key in obj) {
  69.             if (obj.hasOwnProperty(key)) {
  70.                 objCopy[key] = this.deepClone(obj[key]);
  71.             }
  72.         }
  73.         return objCopy;
  74.     },
  75.    
  76.     /**
  77.      * 安全获取嵌套对象属性
  78.      * @param {Object} obj - 目标对象
  79.      * @param {string} path - 属性路径，如 "a.b.c"
  80.      * @param {*} defaultValue - 默认值
  81.      * @returns {*} 属性值或默认值
  82.      */
  83.     getSafe: function(obj, path, defaultValue) {
  84.         if (!obj || !path) return defaultValue;
  85.         var keys = path.split('.');
  86.         var current = obj;
  87.         for (var i = 0; i < keys.length; i++) {
  88.             if (current === null || current === undefined || !current.hasOwnProperty(keys[i])) {
  89.                 return defaultValue;
  90.             }
  91.             current = current[keys[i]];
  92.         }
  93.         return current !== undefined ? current : defaultValue;
  94.     },
  95.    
  96.     /**
  97.      * 安全设置嵌套对象属性
  98.      * @param {Object} obj - 目标对象
  99.      * @param {string} path - 属性路径
  100.      * @param {*} value - 要设置的值
  101.      */
  102.     setSafe: function(obj, path, value) {
  103.         if (!obj || !path) return;
  104.         var keys = path.split('.');
  105.         var current = obj;
  106.         for (var i = 0; i < keys.length - 1; i++) {
  107.             if (!current[keys[i]] || typeof current[keys[i]] !== 'object') {
  108.                 current[keys[i]] = {};
  109.             }
  110.             current = current[keys[i]];
  111.         }
  112.         current[keys[keys.length - 1]] = value;
  113.     },
  114.    
  115.     /**
  116.      * 过滤对象属性
  117.      * @param {Object} obj - 源对象
  118.      * @param {Array} keys - 要保留的键名数组
  119.      * @returns {Object} 过滤后的对象
  120.      */
  121.     pick: function(obj, keys) {
  122.         var result = {};
  123.         for (var i = 0; i < keys.length; i++) {
  124.             var key = keys[i];
  125.             if (obj.hasOwnProperty(key)) {
  126.                 result[key] = obj[key];
  127.             }
  128.         }
  129.         return result;
  130.     },
  131.    
  132.     /**
  133.      * 排除对象属性
  134.      * @param {Object} obj - 源对象
  135.      * @param {Array} keys - 要排除的键名数组
  136.      * @returns {Object} 处理后的对象
  137.      */
  138.     omit: function(obj, keys) {
  139.         var result = {};
  140.         var excludeMap = {};
  141.         for (var i = 0; i < keys.length; i++) {
  142.             excludeMap[keys[i]] = true;
  143.         }
  144.         for (var key in obj) {
  145.             if (obj.hasOwnProperty(key) && !excludeMap[key]) {
  146.                 result[key] = obj[key];
  147.             }
  148.         }
  149.         return result;
  150.     },
  151.    
  152.     /**
  153.      * 检查对象是否为空
  154.      * @param {Object} obj - 要检查的对象
  155.      * @returns {boolean} 是否为空
  156.      */
  157.     isEmpty: function(obj) {
  158.         if (!obj) return true;
  159.         for (var key in obj) {
  160.             if (obj.hasOwnProperty(key)) return false;
  161.         }
  162.         return true;
  163.     },
  164.    
  165.     /**
  166.      * 将对象转换为查询字符串
  167.      * @param {Object} obj - 要转换的对象
  168.      * @returns {string} 查询字符串
  169.      */
  170.     toQueryString: function(obj) {
  171.         var pairs = [];
  172.         for (var key in obj) {
  173.             if (obj.hasOwnProperty(key)) {
  174.                 pairs.push(encodeURIComponent(key) + '=' + encodeURIComponent(obj[key]));
  175.             }
  176.         }
  177.         return pairs.join('&');
  178.     },
  179.    
  180.     /**
  181.      * 将查询字符串转换为对象
  182.      * @param {string} queryString - 查询字符串
  183.      * @returns {Object} 转换后的对象
  184.      */
  185.     fromQueryString: function(queryString) {
  186.         var result = {};
  187.         if (!queryString) return result;
  188.         var pairs = queryString.split('&');
  189.         for (var i = 0; i < pairs.length; i++) {
  190.             var pair = pairs[i].split('=');
  191.             if (pair.length === 2) {
  192.                 result[decodeURIComponent(pair[0])] = decodeURIComponent(pair[1]);
  193.             }
  194.         }
  195.         return result;
  196.     }
  197. };

  199. // =============================================================================
  200. // 第二部分：数组操作工具类 (ArrayUtils)
  201. // =============================================================================

  203. /**
  204. * 数组操作工具类
  205. * 提供数组遍历、过滤、排序、分组等高级功能
  206. */
  207. var ArrayUtils = {
  208.    
  209.     /**
  210.      * 数组去重
  211.      * @param {Array} arr - 源数组
  212.      * @returns {Array} 去重后的数组
  213.      */
  214.     unique: function(arr) {
  215.         var result = [];
  216.         var seen = {};
  217.         for (var i = 0; i < arr.length; i++) {
  218.             var item = arr[i];
  219.             var key = typeof item + JSON.stringify(item);
  220.             if (!seen[key]) {
  221.                 seen[key] = true;
  222.                 result.push(item);
  223.             }
  224.         }
  225.         return result;
  226.     },
  227.    
  228.     /**
  229.      * 根据条件过滤数组
  230.      * @param {Array} arr - 源数组
  231.      * @param {Function} predicate - 过滤条件函数
  232.      * @returns {Array} 过滤后的数组
  233.      */
  234.     filter: function(arr, predicate) {
  235.         var result = [];
  236.         for (var i = 0; i < arr.length; i++) {
  237.             if (predicate(arr[i], i, arr)) {
  238.                 result.push(arr[i]);
  239.             }
  240.         }
  241.         return result;
  242.     },
  243.    
  244.     /**
  245.      * 数组映射转换
  246.      * @param {Array} arr - 源数组
  247.      * @param {Function} mapper - 映射函数
  248.      * @returns {Array} 转换后的数组
  249.      */
  250.     map: function(arr, mapper) {
  251.         var result = [];
  252.         for (var i = 0; i < arr.length; i++) {
  253.             result.push(mapper(arr[i], i, arr));
  254.         }
  255.         return result;
  256.     },
  257.    
  258.     /**
  259.      * 数组归约计算
  260.      * @param {Array} arr - 源数组
  261.      * @param {Function} reducer - 归约函数
  262.      * @param {*} initialValue - 初始值
  263.      * @returns {*} 归约结果
  264.      */
  265.     reduce: function(arr, reducer, initialValue) {
  266.         var accumulator = initialValue;
  267.         var startIndex = 0;
  268.         if (arguments.length < 3) {
  269.             accumulator = arr[0];
  270.             startIndex = 1;
  271.         }
  272.         for (var i = startIndex; i < arr.length; i++) {
  273.             accumulator = reducer(accumulator, arr[i], i, arr);
  274.         }
  275.         return accumulator;
  276.     },
  277.    
  278.     /**
  279.      * 查找数组元素
  280.      * @param {Array} arr - 源数组
  281.      * @param {Function} predicate - 查找条件
  282.      * @returns {*} 找到的元素或 undefined
  283.      */
  284.     find: function(arr, predicate) {
  285.         for (var i = 0; i < arr.length; i++) {
  286.             if (predicate(arr[i], i, arr)) {
  287.                 return arr[i];
  288.             }
  289.         }
  290.         return undefined;
  291.     },
  292.    
  293.     /**
  294.      * 检查数组是否包含某元素
  295.      * @param {Array} arr - 源数组
  296.      * @param {*} item - 要查找的元素
  297.      * @returns {boolean} 是否包含
  298.      */
  299.     includes: function(arr, item) {
  300.         for (var i = 0; i < arr.length; i++) {
  301.             if (arr[i] === item) {
  302.                 return true;
  303.             }
  304.         }
  305.         return false;
  306.     },
  307.    
  308.     /**
  309.      * 数组扁平化
  310.      * @param {Array} arr - 源数组
  311.      * @param {number} depth - 扁平化深度，默认为1
  312.      * @returns {Array} 扁平化后的数组
  313.      */
  314.     flatten: function(arr, depth) {
  315.         depth = depth || 1;
  316.         var result = [];
  317.         for (var i = 0; i < arr.length; i++) {
  318.             if (Array.isArray(arr[i]) && depth > 0) {
  319.                 result = result.concat(this.flatten(arr[i], depth - 1));
  320.             } else {
  321.                 result.push(arr[i]);
  322.             }
  323.         }
  324.         return result;
  325.     },
  326.    
  327.     /**
  328.      * 数组分块
  329.      * @param {Array} arr - 源数组
  330.      * @param {number} size - 每块大小
  331.      * @returns {Array} 分块后的数组
  332.      */
  333.     chunk: function(arr, size) {
  334.         var result = [];
  335.         for (var i = 0; i < arr.length; i += size) {
  336.             var chunk = [];
  337.             for (var j = i; j < i + size && j < arr.length; j++) {
  338.                 chunk.push(arr[j]);
  339.             }
  340.             result.push(chunk);
  341.         }
  342.         return result;
  343.     },
  344.    
  345.     /**
  346.      * 数组排序（支持多字段排序）
  347.      * @param {Array} arr - 源数组
  348.      * @param {string|Array} fields - 排序字段
  349.      * @param {string|Array} orders - 排序方式 ('asc' 或 'desc')
  350.      * @returns {Array} 排序后的数组
  351.      */
  352.     orderBy: function(arr, fields, orders) {
  353.         if (!Array.isArray(fields)) {
  354.             fields = [fields];
  355.         }
  356.         if (!Array.isArray(orders)) {
  357.             orders = [orders || 'asc'];
  358.         }
  359.         return arr.slice().sort(function(a, b) {
  360.             for (var i = 0; i < fields.length; i++) {
  361.                 var field = fields[i];
  362.                 var order = orders[i] || 'asc';
  363.                 var aVal = a[field];
  364.                 var bVal = b[field];
  365.                 if (aVal < bVal) return order === 'asc' ? -1 : 1;
  366.                 if (aVal > bVal) return order === 'asc' ? 1 : -1;
  367.             }
  368.             return 0;
  369.         });
  370.     },
  371.    
  372.     /**
  373.      * 数组分组
  374.      * @param {Array} arr - 源数组
  375.      * @param {Function|string} grouper - 分组依据（函数或属性名）
  376.      * @returns {Object} 分组后的对象
  377.      */
  378.     groupBy: function(arr, grouper) {
  379.         var result = {};
  380.         var isFunction = typeof grouper === 'function';
  381.         for (var i = 0; i < arr.length; i++) {
  382.             var key = isFunction ? grouper(arr[i], i, arr) : arr[i][grouper];
  383.             if (!result[key]) {
  384.                 result[key] = [];
  385.             }
  386.             result[key].push(arr[i]);
  387.         }
  388.         return result;
  389.     },
  390.    
  391.     /**
  392.      * 从数组中随机取一个元素
  393.      * @param {Array} arr - 源数组
  394.      * @returns {*} 随机元素
  395.      */
  396.     sample: function(arr) {
  397.         if (arr.length === 0) return undefined;
  398.         return arr[Math.floor(Math.random() * arr.length)];
  399.     },
  400.    
  401.     /**
  402.      * 打乱数组顺序（Fisher-Yates算法）
  403.      * @param {Array} arr - 源数组
  404.      * @returns {Array} 打乱后的数组
  405.      */
  406.     shuffle: function(arr) {
  407.         var result = arr.slice();
  408.         for (var i = result.length - 1; i > 0; i--) {
  409.             var j = Math.floor(Math.random() * (i + 1));
  410.             var temp = result[i];
  411.             result[i] = result[j];
  412.             result[j] = temp;
  413.         }
  414.         return result;
  415.     }
  416. };

  418. // =============================================================================
  419. // 第三部分：字符串操作工具类 (StringUtils)
  420. // =============================================================================

  422. /**
  423. * 字符串操作工具类
  424. * 提供字符串格式化、验证、转换等高级功能
  425. */
  426. var StringUtils = {
  427.    
  428.     /**
  429.      * 检查字符串是否为空或空白
  430.      * @param {string} str - 要检查的字符串
  431.      * @returns {boolean} 是否为空
  432.      */
  433.     isEmpty: function(str) {
  434.         return !str || str.trim().length === 0;
  435.     },
  436.    
  437.     /**
  438.      * 字符串反转
  439.      * @param {string} str - 源字符串
  440.      * @returns {string} 反转后的字符串
  441.      */
  442.     reverse: function(str) {
  443.         return str.split('').reverse().join('');
  444.     },
  445.    
  446.     /**
  447.      * 截取字符串（支持负数索引）
  448.      * @param {string} str - 源字符串
  449.      * @param {number} start - 开始位置
  450.      * @param {number} end - 结束位置
  451.      * @returns {string} 截取后的字符串
  452.      */
  453.     slice: function(str, start, end) {
  454.         var len = str.length;
  455.         start = start < 0 ? Math.max(0, len + start) : Math.min(start, len);
  456.         end = end === undefined ? len : (end < 0 ? Math.max(0, len + end) : Math.min(end, len));
  457.         var result = '';
  458.         for (var i = start; i < end; i++) {
  459.             result += str[i];
  460.         }
  461.         return result;
  462.     },
  463.    
  464.     /**
  465.      * 填充字符串到指定长度
  466.      * @param {string} str - 源字符串
  467.      * @param {number} length - 目标长度
  468.      * @param {string} chars - 填充字符
  469.      * @param {boolean} left - 是否左填充
  470.      * @returns {string} 填充后的字符串
  471.      */
  472.     pad: function(str, length, chars, left) {
  473.         chars = chars || ' ';
  474.         if (str.length >= length) return str;
  475.         var padLength = length - str.length;
  476.         var padStr = '';
  477.         while (padStr.length < padLength) {
  478.             padStr += chars;
  479.         }
  480.         padStr = this.slice(padStr, 0, padLength);
  481.         return left ? padStr + str : str + padStr;
  482.     },
  483.    
  484.     /**
  485.      * 左填充字符串
  486.      * @param {string} str - 源字符串
  487.      * @param {number} length - 目标长度
  488.      * @param {string} chars - 填充字符
  489.      * @returns {string} 填充后的字符串
  490.      */
  491.     padStart: function(str, length, chars) {
  492.         return this.pad(str, length, chars, true);
  493.     },
  494.    
  495.     /**
  496.      * 右填充字符串
  497.      * @param {string} str - 源字符串
  498.      * @param {number} length - 目标长度
  499.      * @param {string} chars - 填充字符
  500.      * @returns {string} 填充后的字符串
  501.      */
  502.     padEnd: function(str, length, chars) {
  503.         return this.pad(str, length, chars, false);
  504.     },
  505.    
  506.     /**
  507.      * 重复字符串
  508.      * @param {string} str - 源字符串
  509.      * @param {number} count - 重复次数
  510.      * @returns {string} 重复后的字符串
  511.      */
  512.     repeat: function(str, count) {
  513.         if (count < 0) return '';
  514.         var result = '';
  515.         for (var i = 0; i < count; i++) {
  516.             result += str;
  517.         }
  518.         return result;
  519.     },
  520.    
  521.     /**
  522.      * 截断字符串并添加省略号
  523.      * @param {string} str - 源字符串
  524.      * @param {number} length - 最大长度
  525.      * @param {string} omission - 省略符号
  526.      * @returns {string} 截断后的字符串
  527.      */
  528.     truncate: function(str, length, omission) {
  529.         omission = omission || '...';
  530.         if (str.length <= length) return str;
  531.         return this.slice(str, 0, length - omission.length) + omission;
  532.     },
  533.    
  534.     /**
  535.      * 驼峰命名转下划线命名
  536.      * @param {string} str - 驼峰命名字符串
  537.      * @returns {string} 下划线命名字符串
  538.      */
  539.     camelToSnake: function(str) {
  540.         return str.replace(/([A-Z])/g, '_$1').toLowerCase().replace(/^_/, '');
  541.     },
  542.    
  543.     /**
  544.      * 下划线命名转驼峰命名
  545.      * @param {string} str - 下划线命名字符串
  546.      * @returns {string} 驼峰命名字符串
  547.      */
  548.     snakeToCamel: function(str) {
  549.         return str.replace(/_([a-z])/g, function(match, letter) {
  550.             return letter.toUpperCase();
  551.         });
  552.     },
  553.    
  554.     /**
  555.      * 首字母大写
  556.      * @param {string} str - 源字符串
  557.      * @returns {string} 处理后的字符串
  558.      */
  559.     capitalize: function(str) {
  560.         if (this.isEmpty(str)) return str;
  561.         return str[0].toUpperCase() + this.slice(str, 1).toLowerCase();
  562.     },
  563.    
  564.     /**
  565.      * 检查字符串是否以指定前缀开头
  566.      * @param {string} str - 源字符串
  567.      * @param {string} prefix - 前缀
  568.      * @returns {boolean} 是否以该前缀开头
  569.      */
  570.     startsWith: function(str, prefix) {
  571.         if (prefix.length > str.length) return false;
  572.         return this.slice(str, 0, prefix.length) === prefix;
  573.     },
  574.    
  575.     /**
  576.      * 检查字符串是否以指定后缀结尾
  577.      * @param {string} str - 源字符串
  578.      * @param {string} suffix - 后缀
  579.      * @returns {boolean} 是否以该后缀结尾
  580.      */
  581.     endsWith: function(str, suffix) {
  582.         if (suffix.length > str.length) return false;
  583.         return this.slice(str, str.length - suffix.length) === suffix;
  584.     },
  585.    
  586.     /**
  587.      * 移除字符串中的空白字符
  588.      * @param {string} str - 源字符串
  589.      * @returns {string} 处理后的字符串
  590.      */
  591.     removeWhitespace: function(str) {
  592.         var result = '';
  593.         for (var i = 0; i < str.length; i++) {
  594.             if (str[i] !== ' ' && str[i] !== '\t' && str[i] !== '\n' && str[i] !== '\r') {
  595.                 result += str[i];
  596.             }
  597.         }
  598.         return result;
  599.     },
  600.    
  601.     /**
  602.      * 统计字符出现次数
  603.      * @param {string} str - 源字符串
  604.      * @param {string} char - 要统计的字符
  605.      * @returns {number} 出现次数
  606.      */
  607.     countChar: function(str, char) {
  608.         var count = 0;
  609.         for (var i = 0; i < str.length; i++) {
  610.             if (str[i] === char) count++;
  611.         }
  612.         return count;
  613.     },
  614.    
  615.     /**
  616.      * 生成随机字符串
  617.      * @param {number} length - 字符串长度
  618.      * @param {string} chars - 字符集
  619.      * @returns {string} 随机字符串
  620.      */
  621.     random: function(length, chars) {
  622.         chars = chars || 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
  623.         var result = '';
  624.         for (var i = 0; i < length; i++) {
  625.             result += chars.charAt(Math.floor(Math.random() * chars.length));
  626.         }
  627.         return result;
  628.     }
  629. };

  631. // =============================================================================
  632. // 第四部分：数学计算工具类 (MathUtils)
  633. // =============================================================================

  635. /**
  636. * 数学计算工具类
  637. * 提供数值计算、随机数生成、几何计算等高级功能
  638. */
  639. var MathUtils = {
  640.    
  641.     /**
  642.      * 角度转弧度
  643.      * @param {number} degrees - 角度值
  644.      * @returns {number} 弧度值
  645.      */
  646.     toRadians: function(degrees) {
  647.         return degrees * (Math.PI / 180);
  648.     },
  649.    
  650.     /**
  651.      * 弧度转角度
  652.      * @param {number} radians - 弧度值
  653.      * @returns {number} 角度值
  654.      */
  655.     toDegrees: function(radians) {
  656.         return radians * (180 / Math.PI);
  657.     },
  658.    
  659.     /**
  660.      * 限制数值在指定范围内
  661.      * @param {number} value - 要限制的数值
  662.      * @param {number} min - 最小值
  663.      * @param {number} max - 最大值
  664.      * @returns {number} 限制后的数值
  665.      */
  666.     clamp: function(value, min, max) {
  667.         return Math.min(Math.max(value, min), max);
  668.     },
  669.    
  670.     /**
  671.      * 线性插值
  672.      * @param {number} start - 起始值
  673.      * @param {number} end - 结束值
  674.      * @param {number} t - 插值系数 (0-1)
  675.      * @returns {number} 插值结果
  676.      */
  677.     lerp: function(start, end, t) {
  678.         return start + (end - start) * t;
  679.     },
  680.    
  681.     /**
  682.      * 两点间距离
  683.      * @param {number} x1 - 第一点X坐标
  684.      * @param {number} y1 - 第一点Y坐标
  685.      * @param {number} x2 - 第二点X坐标
  686.      * @param {number} y2 - 第二点Y坐标
  687.      * @returns {number} 距离
  688.      */
  689.     distance: function(x1, y1, x2, y2) {
  690.         var dx = x2 - x1;
  691.         var dy = y2 - y1;
  692.         return Math.sqrt(dx * dx + dy * dy);
  693.     },
  694.    
  695.     /**
  696.      * 计算两点间角度
  697.      * @param {number} x1 - 第一点X坐标
  698.      * @param {number} y1 - 第一点Y坐标
  699.      * @param {number} x2 - 第二点X坐标
  700.      * @param {number} y2 - 第二点Y坐标
  701.      * @returns {number} 角度（度）
  702.      */
  703.     angle: function(x1, y1, x2, y2) {
  704.         return this.toDegrees(Math.atan2(y2 - y1, x2 - x1));
  705.     },
  706.    
  707.     /**
  708.      * 生成指定范围内的随机整数
  709.      * @param {number} min - 最小值（包含）
  710.      * @param {number} max - 最大值（包含）
  711.      * @returns {number} 随机整数
  712.      */
  713.     randomInt: function(min, max) {
  714.         return Math.floor(Math.random() * (max - min + 1)) + min;
  715.     },
  716.    
  717.     /**
  718.      * 生成指定范围内的随机浮点数
  719.      * @param {number} min - 最小值
  720.      * @param {number} max - 最大值
  721.      * @returns {number} 随机浮点数
  722.      */
  723.     randomFloat: function(min, max) {
  724.         return Math.random() * (max - min) + min;
  725.     },
  726.    
  727.     /**
  728.      * 判断点是否在矩形内
  729.      * @param {number} px - 点X坐标
  730.      * @param {number} py - 点Y坐标
  731.      * @param {number} rx - 矩形左上角X坐标
  732.      * @param {number} ry - 矩形左上角Y坐标
  733.      * @param {number} rw - 矩形宽度
  734.      * @param {number} rh - 矩形高度
  735.      * @returns {boolean} 是否在矩形内
  736.      */
  737.     pointInRect: function(px, py, rx, ry, rw, rh) {
  738.         return px >= rx && px <= rx + rw && py >= ry && py <= ry + rh;
  739.     },
  740.    
  741.     /**
  742.      * 判断点是否在圆内
  743.      * @param {number} px - 点X坐标
  744.      * @param {number} py - 点Y坐标
  745.      * @param {number} cx - 圆心X坐标
  746.      * @param {number} cy - 圆心Y坐标
  747.      * @param {number} radius - 圆半径
  748.      * @returns {boolean} 是否在圆内
  749.      */
  750.     pointInCircle: function(px, py, cx, cy, radius) {
  751.         return this.distance(px, py, cx, cy) <= radius;
  752.     },
  753.    
  754.     /**
  755.      * 计算平均值
  756.      * @param {...number} numbers - 数值列表
  757.      * @returns {number} 平均值
  758.      */
  759.     average: function() {
  760.         var sum = 0;
  761.         for (var i = 0; i < arguments.length; i++) {
  762.             sum += arguments[i];
  763.         }
  764.         return sum / arguments.length;
  765.     },
  766.    
  767.     /**
  768.      * 计算标准差
  769.      * @param {Array} numbers - 数值数组
  770.      * @returns {number} 标准差
  771.      */
  772.     standardDeviation: function(numbers) {
  773.         var avg = this.average.apply(this, numbers);
  774.         var sumSquaredDiff = 0;
  775.         for (var i = 0; i < numbers.length; i++) {
  776.             var diff = numbers[i] - avg;
  777.             sumSquaredDiff += diff * diff;
  778.         }
  779.         return Math.sqrt(sumSquaredDiff / numbers.length);
  780.     },
  781.    
  782.     /**
  783.      * 判断两个矩形是否相交
  784.      * @param {Object} rect1 - 第一个矩形 {x, y, width, height}
  785.      * @param {Object} rect2 - 第二个矩形 {x, y, width, height}
  786.      * @returns {boolean} 是否相交
  787.      */
  788.     rectIntersect: function(rect1, rect2) {
  789.         return !(rect2.x > rect1.x + rect1.width ||
  790.                  rect2.x + rect2.width < rect1.x ||
  791.                  rect2.y > rect1.y + rect1.height ||
  792.                  rect2.y + rect2.height < rect1.y);
  793.     },
  794.    
  795.     /**
  796.      * 计算阶乘
  797.      * @param {number} n - 非负整数
  798.      * @returns {number} 阶乘结果
  799.      */
  800.     factorial: function(n) {
  801.         if (n < 0) return NaN;
  802.         if (n === 0 || n === 1) return 1;
  803.         var result = 1;
  804.         for (var i = 2; i <= n; i++) {
  805.             result *= i;
  806.         }
  807.         return result;
  808.     },
  809.    
  810.     /**
  811.      * 计算组合数 C(n, k)
  812.      * @param {number} n - 总数
  813.      * @param {number} k - 选取数
  814.      * @returns {number} 组合数
  815.      */
  816.     combination: function(n, k) {
  817.         if (k > n) return 0;
  818.         if (k === 0 || k === n) return 1;
  819.         return this.factorial(n) / (this.factorial(k) * this.factorial(n - k));
  820.     }
  821. };

  823. // =============================================================================
  824. // 第五部分：数字处理工具类 (NumberUtils)
  825. // =============================================================================

  827. /**
  828. * 数字处理工具类
  829. * 提供数字格式化、转换、验证等高级功能
  830. */
  831. var NumberUtils = {
  832.    
  833.     /**
  834.      * 将数字格式化为千分位字符串
  835.      * @param {number} num - 要格式化的数字
  836.      * @param {number} decimals - 小数位数
  837.      * @returns {string} 格式化后的字符串
  838.      */
  839.     formatThousands: function(num, decimals) {
  840.         decimals = decimals !== undefined ? decimals : 2;
  841.         var fixed = num.toFixed(decimals);
  842.         var parts = fixed.split('.');
  843.         var integerPart = parts[0];
  844.         var decimalPart = parts[1] || '';
  845.         var result = '';
  846.         var count = 0;
  847.         for (var i = integerPart.length - 1; i >= 0; i--) {
  848.             result = integerPart[i] + result;
  849.             count++;
  850.             if (count % 3 === 0 && i > 0 && integerPart[i - 1] !== '-') {
  851.                 result = ',' + result;
  852.             }
  853.         }
  854.         return decimalPart ? result + '.' + decimalPart : result;
  855.     },
  856.    
  857.     /**
  858.      * 将字节数转换为可读格式
  859.      * @param {number} bytes - 字节数
  860.      * @param {number} decimals - 小数位数
  861.      * @returns {string} 可读格式字符串
  862.      */
  863.     formatBytes: function(bytes, decimals) {
  864.         decimals = decimals !== undefined ? decimals : 2;
  865.         if (bytes === 0) return '0 Bytes';
  866.         var k = 1024;
  867.         var sizes = ['Bytes', 'KB', 'MB', 'GB', 'TB'];
  868.         var i = Math.floor(Math.log(bytes) / Math.log(k));
  869.         return parseFloat((bytes / Math.pow(k, i)).toFixed(decimals)) + ' ' + sizes[i];
  870.     },
  871.    
  872.     /**
  873.      * 将毫秒转换为可读时间
  874.      * @param {number} ms - 毫秒数
  875.      * @returns {string} 可读时间字符串
  876.      */
  877.     formatDuration: function(ms) {
  878.         if (ms < 1000) return ms + 'ms';
  879.         var seconds = Math.floor(ms / 1000);
  880.         if (seconds < 60) return seconds + 's';
  881.         var minutes = Math.floor(seconds / 60);
  882.         if (minutes < 60) return minutes + 'm ' + (seconds % 60) + 's';
  883.         var hours = Math.floor(minutes / 60);
  884.         return hours + 'h ' + (minutes % 60) + 'm';
  885.     },
  886.    
  887.     /**
  888.      * 检查是否为整数
  889.      * @param {*} value - 要检查的值
  890.      * @returns {boolean} 是否为整数
  891.      */
  892.     isInteger: function(value) {
  893.         return typeof value === 'number' && isFinite(value) && Math.floor(value) === value;
  894.     },
  895.    
  896.     /**
  897.      * 检查是否为数字
  898.      * @param {*} value - 要检查的值
  899.      * @returns {boolean} 是否为数字
  900.      */
  901.     isNumber: function(value) {
  902.         return typeof value === 'number' && isFinite(value);
  903.     },
  904.    
  905.     /**
  906.      * 将字符串转换为数字
  907.      * @param {string} str - 要转换的字符串
  908.      * @param {*} defaultValue - 转换失败时的默认值
  909.      * @returns {number} 转换后的数字
  910.      */
  911.     toNumber: function(str, defaultValue) {
  912.         var num = parseFloat(str);
  913.         return isNaN(num) ? defaultValue : num;
  914.     },
  915.    
  916.     /**
  917.      * 将数字转换为中文大写金额
  918.      * @param {number} num - 要转换的数字
  919.      * @returns {string} 中文大写金额
  920.      */
  921.     toChineseMoney: function(num) {
  922.         var units = ['', '十', '百', '千'];
  923.         var bigUnits = ['', '万', '亿'];
  924.         var digits = ['零', '一', '二', '三', '四', '五', '六', '七', '八', '九'];
  925.         
  926.         if (num === 0) return '零';
  927.         if (num < 0) return '负' + this.toChineseMoney(-num);
  928.         
  929.         var strNum = Math.floor(num).toString();
  930.         var result = '';
  931.         var zeroCount = 0;
  932.         var bigUnitIndex = 0;
  933.         
  934.         for (var i = strNum.length - 1; i >= 0; i -= 4) {
  935.             var part = '';
  936.             var partZero = true;
  937.             for (var j = 0; j < 4 && i - j >= 0; j++) {
  938.                 var digit = parseInt(strNum[i - j]);
  939.                 if (digit === 0) {
  940.                     zeroCount++;
  941.                 } else {
  942.                     if (zeroCount > 0) {
  943.                         part = digits[0] + part;
  944.                         zeroCount = 0;
  945.                     }
  946.                     part = digits[digit] + units[j] + part;
  947.                     partZero = false;
  948.                 }
  949.             }
  950.             if (!partZero) {
  951.                 result = part + bigUnits[bigUnitIndex] + result;
  952.             }
  953.             bigUnitIndex++;
  954.         }
  955.         
  956.         return result.replace(/零+/g, '零').replace(/零$/, '');
  957.     },
  958.    
  959.     /**
  960.      * 将数字转换为罗马数字
  961.      * @param {number} num - 要转换的数字 (1-3999)
  962.      * @returns {string} 罗马数字
  963.      */
  964.     toRoman: function(num) {
  965.         if (num < 1 || num > 3999) return '';
  966.         var values = [1000, 900, 500, 400, 100, 90, 50, 40, 10, 9, 5, 4, 1];
  967.         var symbols = ['M', 'CM', 'D', 'CD', 'C', 'XC', 'L', 'XL', 'X', 'IX', 'V', 'IV', 'I'];
  968.         var result = '';
  969.         for (var i = 0; i < values.length; i++) {
  970.             while (num >= values[i]) {
  971.                 result += symbols[i];
  972.                 num -= values[i];
  973.             }
  974.         }
  975.         return result;
  976.     },
  977.    
  978.     /**
  979.      * 将罗马数字转换为数字
  980.      * @param {string} roman - 罗马数字
  981.      * @returns {number} 转换后的数字
  982.      */
  983.     fromRoman: function(roman) {
  984.         var values = {I: 1, V: 5, X: 10, L: 50, C: 100, D: 500, M: 1000};
  985.         var result = 0;
  986.         for (var i = 0; i < roman.length; i++) {
  987.             var current = values[roman[i]];
  988.             var next = values[roman[i + 1]];
  989.             if (next && current < next) {
  990.                 result -= current;
  991.             } else {
  992.                 result += current;
  993.             }
  994.         }
  995.         return result;
  996.     },
  997.    
  998.     /**
  999.      * 生成指定范围内的随机数数组
  1000.      * @param {number} count - 数组长度
  1001.      * @param {number} min - 最小值
  1002.      * @param {number} max - 最大值
  1003.      * @returns {Array} 随机数数组
  1004.      */
  1005.     randomArray: function(count, min, max) {
  1006.         var result = [];
  1007.         for (var i = 0; i < count; i++) {
  1008.             result.push(MathUtils.randomInt(min, max));
  1009.         }
  1010.         return result;
  1011.     }
  1012. };

  1014. // =============================================================================
  1015. // 第六部分：时间管理工具类 (TimeUtils)
  1016. // =============================================================================

  1018. /**
  1019. * 时间管理工具类
  1020. * 提供日期时间格式化、计算、转换等高级功能
  1021. */
  1022. var TimeUtils = {
  1023.    
  1024.     /**
  1025.      * 格式化日期时间
  1026.      * @param {Date} date - 日期对象
  1027.      * @param {string} format - 格式字符串 (yyyy-MM-dd HH:mm:ss)
  1028.      * @returns {string} 格式化后的字符串
  1029.      */
  1030.     format: function(date, format) {
  1031.         format = format || 'yyyy-MM-dd HH:mm:ss';
  1032.         var year = date.getFullYear();
  1033.         var month = date.getMonth() + 1;
  1034.         var day = date.getDate();
  1035.         var hours = date.getHours();
  1036.         var minutes = date.getMinutes();
  1037.         var seconds = date.getSeconds();
  1038.         var milliseconds = date.getMilliseconds();
  1039.         
  1040.         return format
  1041.             .replace(/yyyy/g, year)
  1042.             .replace(/MM/g, StringUtils.padStart(month.toString(), 2, '0'))
  1043.             .replace(/dd/g, StringUtils.padStart(day.toString(), 2, '0'))
  1044.             .replace(/HH/g, StringUtils.padStart(hours.toString(), 2, '0'))
  1045.             .replace(/mm/g, StringUtils.padStart(minutes.toString(), 2, '0'))
  1046.             .replace(/ss/g, StringUtils.padStart(seconds.toString(), 2, '0'))
  1047.             .replace(/SSS/g, StringUtils.padStart(milliseconds.toString(), 3, '0'));
  1048.     },
  1049.    
  1050.     /**
  1051.      * 获取当前时间字符串
  1052.      * @param {string} format - 格式字符串
  1053.      * @returns {string} 当前时间字符串
  1054.      */
  1055.     now: function(format) {
  1056.         return this.format(new Date(), format);
  1057.     },
  1058.    
  1059.     /**
  1060.      * 获取今天的开始时间
  1061.      * @returns {Date} 今天的开始时间
  1062.      */
  1063.     startOfDay: function() {
  1064.         var date = new Date();
  1065.         date.setHours(0, 0, 0, 0);
  1066.         return date;
  1067.     },
  1068.    
  1069.     /**
  1070.      * 获取今天的结束时间
  1071.      * @returns {Date} 今天的结束时间
  1072.      */
  1073.     endOfDay: function() {
  1074.         var date = new Date();
  1075.         date.setHours(23, 59, 59, 999);
  1076.         return date;
  1077.     },
  1078.    
  1079.     /**
  1080.      * 添加时间
  1081.      * @param {Date} date - 原日期
  1082.      * @param {number} amount - 数量
  1083.      * @param {string} unit - 单位 (year, month, day, hour, minute, second)
  1084.      * @returns {Date} 新的日期
  1085.      */
  1086.     add: function(date, amount, unit) {
  1087.         var result = new Date(date);
  1088.         switch (unit) {
  1089.             case 'year':
  1090.                 result.setFullYear(result.getFullYear() + amount);
  1091.                 break;
  1092.             case 'month':
  1093.                 result.setMonth(result.getMonth() + amount);
  1094.                 break;
  1095.             case 'day':
  1096.                 result.setDate(result.getDate() + amount);
  1097.                 break;
  1098.             case 'hour':
  1099.                 result.setHours(result.getHours() + amount);
  1100.                 break;
  1101.             case 'minute':
  1102.                 result.setMinutes(result.getMinutes() + amount);
  1103.                 break;
  1104.             case 'second':
  1105.                 result.setSeconds(result.getSeconds() + amount);
  1106.                 break;
  1107.         }
  1108.         return result;
  1109.     },
  1110.    
  1111.     /**
  1112.      * 计算两个日期之间的差值
  1113.      * @param {Date} date1 - 第一个日期
  1114.      * @param {Date} date2 - 第二个日期
  1115.      * @param {string} unit - 返回单位 (ms, s, m, h, d)
  1116.      * @returns {number} 差值
  1117.      */
  1118.     diff: function(date1, date2, unit) {
  1119.         var diffMs = date2 - date1;
  1120.         switch (unit) {
  1121.             case 'ms': return diffMs;
  1122.             case 's': return Math.floor(diffMs / 1000);
  1123.             case 'm': return Math.floor(diffMs / (1000 * 60));
  1124.             case 'h': return Math.floor(diffMs / (1000 * 60 * 60));
  1125.             case 'd': return Math.floor(diffMs / (1000 * 60 * 60 * 24));
  1126.             default: return diffMs;
  1127.         }
  1128.     },
  1129.    
  1130.     /**
  1131.      * 判断是否为闰年
  1132.      * @param {number} year - 年份
  1133.      * @returns {boolean} 是否为闰年
  1134.      */
  1135.     isLeapYear: function(year) {
  1136.         return (year % 4 === 0 && year % 100 !== 0) || (year % 400 === 0);
  1137.     },
  1138.    
  1139.     /**
  1140.      * 获取月份天数
  1141.      * @param {number} year - 年份
  1142.      * @param {number} month - 月份 (1-12)
  1143.      * @returns {number} 天数
  1144.      */
  1145.     daysInMonth: function(year, month) {
  1146.         var days = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];
  1147.         if (month === 2 && this.isLeapYear(year)) {
  1148.             return 29;
  1149.         }
  1150.         return days[month - 1];
  1151.     },
  1152.    
  1153.     /**
  1154.      * 获取日期是星期几
  1155.      * @param {Date} date - 日期
  1156.      * @returns {string} 星期几
  1157.      */
  1158.     dayOfWeek: function(date) {
  1159.         var days = ['星期日', '星期一', '星期二', '星期三', '星期四', '星期五', '星期六'];
  1160.         return days[date.getDay()];
  1161.     },
  1162.    
  1163.     /**
  1164.      * 获取日期是一年中的第几天
  1165.      * @param {Date} date - 日期
  1166.      * @returns {number} 第几天
  1167.      */
  1168.     dayOfYear: function(date) {
  1169.         var start = new Date(date.getFullYear(), 0, 0);
  1170.         var diff = date - start;
  1171.         return Math.floor(diff / (1000 * 60 * 60 * 24));
  1172.     },
  1173.    
  1174.     /**
  1175.      * 获取日期所在周的起始日期
  1176.      * @param {Date} date - 日期
  1177.      * @returns {Date} 周起始日期（周一）
  1178.      */
  1179.     startOfWeek: function(date) {
  1180.         var result = new Date(date);
  1181.         var day = result.getDay();
  1182.         var diff = result.getDate() - day + (day === 0 ? -6 : 1);
  1183.         result.setDate(diff);
  1184.         result.setHours(0, 0, 0, 0);
  1185.         return result;
  1186.     },
  1187.    
  1188.     /**
  1189.      * 倒计时格式化
  1190.      * @param {number} seconds - 剩余秒数
  1191.      * @returns {string} 格式化后的倒计时
  1192.      */
  1193.     countdown: function(seconds) {
  1194.         var hours = Math.floor(seconds / 3600);
  1195.         var minutes = Math.floor((seconds % 3600) / 60);
  1196.         var secs = seconds % 60;
  1197.         return StringUtils.padStart(hours.toString(), 2, '0') + ':' +
  1198.                StringUtils.padStart(minutes.toString(), 2, '0') + ':' +
  1199.                StringUtils.padStart(secs.toString(), 2, '0');
  1200.     },
  1201.    
  1202.     /**
  1203.      * 获取相对时间描述
  1204.      * @param {Date} date - 日期
  1205.      * @returns {string} 相对时间描述
  1206.      */
  1207.     fromNow: function(date) {
  1208.         var now = new Date();
  1209.         var diff = Math.floor((now - date) / 1000);
  1210.         
  1211.         if (diff < 60) return '刚刚';
  1212.         if (diff < 3600) return Math.floor(diff / 60) + '分钟前';
  1213.         if (diff < 86400) return Math.floor(diff / 3600) + '小时前';
  1214.         if (diff < 604800) return Math.floor(diff / 86400) + '天前';
  1215.         return this.format(date, 'yyyy-MM-dd');
  1216.     },
  1217.    
  1218.     /**
  1219.      * 解析日期字符串
  1220.      * @param {string} str - 日期字符串
  1221.      * @returns {Date} 日期对象
  1222.      */
  1223.     parse: function(str) {
  1224.         return new Date(str);
  1225.     },
  1226.    
  1227.     /**
  1228.      * 获取时间戳
  1229.      * @param {Date} date - 日期对象，默认为当前时间
  1230.      * @returns {number} 时间戳
  1231.      */
  1232.     timestamp: function(date) {
  1233.         return (date || new Date()).getTime();
  1234.     },
  1235.    
  1236.     /**
  1237.      * 休眠指定毫秒数（阻塞式）
  1238.      * @param {number} ms - 毫秒数
  1239.      */
  1240.     sleep: function(ms) {
  1241.         var start = new Date().getTime();
  1242.         while (new Date().getTime() - start < ms) {
  1243.             // 阻塞等待
  1244.         }
  1245.     },
  1246.    
  1247.     /**
  1248.      * 生成时间范围数组
  1249.      * @param {Date} start - 开始日期
  1250.      * @param {Date} end - 结束日期
  1251.      * @param {string} unit - 步进单位 (day, week, month)
  1252.      * @returns {Array} 日期数组
  1253.      */
  1254.     range: function(start, end, unit) {
  1255.         var result = [];
  1256.         var current = new Date(start);
  1257.         var endDate = new Date(end);
  1258.         
  1259.         while (current <= endDate) {
  1260.             result.push(new Date(current));
  1261.             switch (unit) {
  1262.                 case 'day':
  1263.                     current.setDate(current.getDate() + 1);
  1264.                     break;
  1265.                 case 'week':
  1266.                     current.setDate(current.getDate() + 7);
  1267.                     break;
  1268.                 case 'month':
  1269.                     current.setMonth(current.getMonth() + 1);
  1270.                     break;
  1271.             }
  1272.         }
  1273.         return result;
  1274.     }
  1275. };

  1277. // =============================================================================
  1278. // 第七部分：综合演示函数
  1279. // =============================================================================

  1281. /**
  1282. * 延迟函数 - 毫秒
  1283. */
  1284. function delay(ms) {
  1285.     var start = new Date().getTime();
  1286.     while (new Date().getTime() - start < ms) {}
  1287. }

  1289. /**
  1290. * 运行所有工具类的演示
  1291. */
  1292. function runAllDemos() {
  1293.     printl('');
  1294.     printl('╔══════════════════════════════════════════════════════════════════╗');
  1295.     printl('║           AIWROK 核心工具库完整示例 v2.0                      ║');
  1296.     printl('╚══════════════════════════════════════════════════════════════════╝');
  1297.     printl('');
  1298.     delay(800);
  1299.    
  1300.     demoObjectUtils();
  1301.     delay(500);
  1302.     demoArrayUtils();
  1303.     delay(500);
  1304.     demoStringUtils();
  1305.     delay(500);
  1306.     demoMathUtils();
  1307.     delay(500);
  1308.     demoNumberUtils();
  1309.     delay(500);
  1310.     demoTimeUtils();
  1311.    
  1312.     printl('');
  1313.     printl('╔══════════════════════════════════════════════════════════════════╗');
  1314.     printl('║                   ✓ 所有演示已完成！                          ║');
  1315.     printl('╚══════════════════════════════════════════════════════════════════╝');
  1316.     printl('');
  1317. }

  1319. /**
  1320. * 对象操作工具类演示
  1321. */
  1322. function demoObjectUtils() {
  1323.     printl('┌──────────────────────────────────────────────────────────────────┐');
  1324.     printl('│  ObjectUtils - 对象操作工具类                                  │');
  1325.     printl('└──────────────────────────────────────────────────────────────────┘');
  1326.     printl('');
  1327.     delay(400);
  1328.    
  1329.     printl('▶ 1. 深度合并 - 合并多个对象（包含嵌套对象）');
  1330.     delay(300);
  1331.     var obj1 = { a: 1, b: { c: 2 } };
  1332.     var obj2 = { b: { d: 3 }, e: 4 };
  1333.     var merged = ObjectUtils.deepMerge({}, obj1, obj2);
  1334.     printl('   源对象1: ' + JSON.stringify(obj1));
  1335.     delay(200);
  1336.     printl('   源对象2: ' + JSON.stringify(obj2));
  1337.     delay(200);
  1338.     printl('   合并结果: ' + JSON.stringify(merged));
  1339.     delay(500);
  1340.    
  1341.     printl('▶ 2. 深度克隆 - 完整复制对象（包含嵌套对象）');
  1342.     delay(300);
  1343.     var original = { x: 1, y: { z: 2 } };
  1344.     var cloned = ObjectUtils.deepClone(original);
  1345.     printl('   原对象: ' + JSON.stringify(original));
  1346.     delay(200);
  1347.     printl('   克隆: ' + JSON.stringify(cloned));
  1348.     delay(500);
  1349.    
  1350.     printl('▶ 3. 安全获取 - 获取嵌套属性，避免报错');
  1351.     delay(300);
  1352.     var data = { user: { profile: { name: '张三' } } };
  1353.     var name = ObjectUtils.getSafe(data, 'user.profile.name', '未知');
  1354.     printl('   数据: { user: { profile: { name: "张三" } } }');
  1355.     delay(200);
  1356.     printl('   读取 user.profile.name: ' + name);
  1357.     delay(200);
  1358.     var noExist = ObjectUtils.getSafe(data, 'user.profile.age', '默认值');
  1359.     printl('   读取 user.profile.age（不存在）: ' + noExist);
  1360.     delay(500);
  1361.    
  1362.     printl('▶ 4. 对象转查询字符串');
  1363.     delay(300);
  1364.     var params = { name: '张三', age: 25 };
  1365.     var query = ObjectUtils.toQueryString(params);
  1366.     printl('   对象: ' + JSON.stringify(params));
  1367.     delay(200);
  1368.     printl('   查询字符串: ' + query);
  1369.     delay(500);
  1370.    
  1371.     printl('▶ 5. 查询字符串转对象');
  1372.     delay(300);
  1373.     var parsed = ObjectUtils.fromQueryString(query);
  1374.     printl('   解析结果: ' + JSON.stringify(parsed));
  1375.     delay(500);
  1376.    
  1377.     printl('');
  1378. }

  1380. /**
  1381. * 数组操作工具类演示
  1382. */
  1383. function demoArrayUtils() {
  1384.     printl('┌──────────────────────────────────────────────────────────────────┐');
  1385.     printl('│  ArrayUtils - 数组操作工具类                                  │');
  1386.     printl('└──────────────────────────────────────────────────────────────────┘');
  1387.     printl('');
  1388.     delay(400);
  1389.    
  1390.     printl('▶ 1. 数组去重 - 移除重复元素');
  1391.     delay(300);
  1392.     var arr1 = [1, 2, 2, 3, 3, 3, 4, 4, 5];
  1393.     printl('   原始数组: ' + JSON.stringify(arr1));
  1394.     delay(200);
  1395.     var unique = ArrayUtils.unique(arr1);
  1396.     printl('   去重结果: ' + JSON.stringify(unique));
  1397.     delay(500);
  1398.    
  1399.     printl('▶ 2. 数组过滤 - 按条件筛选');
  1400.     delay(300);
  1401.     var arr2 = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
  1402.     printl('   原始数组: ' + JSON.stringify(arr2));
  1403.     delay(200);
  1404.     var filtered = ArrayUtils.filter(arr2, function(x) { return x > 5; });
  1405.     printl('   过滤条件: x > 5');
  1406.     printl('   过滤结果: ' + JSON.stringify(filtered));
  1407.     delay(500);
  1408.    
  1409.     printl('▶ 3. 数组映射 - 转换每个元素');
  1410.     delay(300);
  1411.     printl('   原始数组: ' + JSON.stringify(arr2));
  1412.     delay(200);
  1413.     var mapped = ArrayUtils.map(arr2, function(x) { return x * 2; });
  1414.     printl('   映射规则: x * 2');
  1415.     printl('   映射结果: ' + JSON.stringify(mapped));
  1416.     delay(500);
  1417.    
  1418.     printl('▶ 4. 数组分块 - 将数组分成多个小块');
  1419.     delay(300);
  1420.     var arr3 = [1, 2, 3, 4, 5, 6];
  1421.     printl('   原始数组: ' + JSON.stringify(arr3));
  1422.     delay(200);
  1423.     var chunked = ArrayUtils.chunk(arr3, 2);
  1424.     printl('   分块大小: 2');
  1425.     printl('   分块结果: ' + JSON.stringify(chunked));
  1426.     delay(500);
  1427.    
  1428.     printl('▶ 5. 数组随机取样 - 随机抽取元素');
  1429.     delay(300);
  1430.     var arr4 = ['苹果', '香蕉', '橙子', '葡萄', '西瓜'];
  1431.     printl('   水果列表: ' + JSON.stringify(arr4));
  1432.     delay(200);
  1433.     var sample = ArrayUtils.sample(arr4);
  1434.     printl('   随机抽取: ' + sample + ' &#127881;');
  1435.     delay(500);
  1436.    
  1437.     printl('');
  1438. }

  1440. /**
  1441. * 字符串操作工具类演示
  1442. */
  1443. function demoStringUtils() {
  1444.     printl('┌──────────────────────────────────────────────────────────────────┐');
  1445.     printl('│  StringUtils - 字符串操作工具类                                │');
  1446.     printl('└──────────────────────────────────────────────────────────────────┘');
  1447.     printl('');
  1448.     delay(400);
  1449.    
  1450.     printl('▶ 1. 字符串填充 - 补齐位数');
  1451.     delay(300);
  1452.     var padded = StringUtils.padStart('42', 5, '0');
  1453.     printl('   原字符串: "42"');
  1454.     printl('   目标长度: 5, 填充字符: "0"');
  1455.     printl('   填充结果: "' + padded + '"');
  1456.     delay(500);
  1457.    
  1458.     printl('▶ 2. 字符串截断 - 限制长度');
  1459.     delay(300);
  1460.     var longText = '这是一段非常长的字符串，需要截断显示';
  1461.     printl('   原文: ' + longText);
  1462.     delay(200);
  1463.     var truncated = StringUtils.truncate(longText, 15);
  1464.     printl('   截断长度: 15');
  1465.     printl('   截断结果: ' + truncated);
  1466.     delay(500);
  1467.    
  1468.     printl('▶ 3. 驼峰转下划线 - 命名风格转换');
  1469.     delay(300);
  1470.     var camel = 'userNameAndPassword';
  1471.     printl('   驼峰命名: ' + camel);
  1472.     delay(200);
  1473.     var snake = StringUtils.camelToSnake(camel);
  1474.     printl('   下划线: ' + snake);
  1475.     delay(500);
  1476.    
  1477.     printl('▶ 4. 首字母大写');
  1478.     delay(300);
  1479.     var text = 'hello world';
  1480.     printl('   原文: ' + text);
  1481.     delay(200);
  1482.     var capitalized = StringUtils.capitalize(text);
  1483.     printl('   首字母大写: ' + capitalized);
  1484.     delay(500);
  1485.    
  1486.     printl('▶ 5. 生成随机字符串');
  1487.     delay(300);
  1488.     var random = StringUtils.random(12);
  1489.     printl('   随机字符串(12位): ' + random);
  1490.     delay(500);
  1491.    
  1492.     printl('');
  1493. }

  1495. /**
  1496. * 数学计算工具类演示
  1497. */
  1498. function demoMathUtils() {
  1499.     printl('┌──────────────────────────────────────────────────────────────────┐');
  1500.     printl('│  MathUtils - 数学计算工具类                                   │');
  1501.     printl('└──────────────────────────────────────────────────────────────────┘');
  1502.     printl('');
  1503.     delay(400);
  1504.    
  1505.     printl('▶ 1. 角度与弧度转换');
  1506.     delay(300);
  1507.     var degrees = 180;
  1508.     printl('   角度: ' + degrees + '°');
  1509.     delay(200);
  1510.     var radians = MathUtils.toRadians(degrees);
  1511.     printl('   弧度: ' + radians.toFixed(4));
  1512.     delay(500);
  1513.    
  1514.     printl('▶ 2. 数值范围限制');
  1515.     delay(300);
  1516.     var testValue = 150;
  1517.     printl('   测试值: ' + testValue);
  1518.     delay(200);
  1519.     var clamped = MathUtils.clamp(testValue, 0, 100);
  1520.     printl('   限制范围: 0-100');
  1521.     printl('   限制结果: ' + clamped);
  1522.     delay(500);
  1523.    
  1524.     printl('▶ 3. 两点距离计算');
  1525.     delay(300);
  1526.     var x1 = 0, y1 = 0, x2 = 3, y2 = 4;
  1527.     printl('   点A: (' + x1 + ', ' + y1 + ')');
  1528.     printl('   点B: (' + x2 + ', ' + y2 + ')');
  1529.     delay(200);
  1530.     var distance = MathUtils.distance(x1, y1, x2, y2);
  1531.     printl('   距离: ' + distance);
  1532.     delay(500);
  1533.    
  1534.     printl('▶ 4. 随机整数生成');
  1535.     delay(300);
  1536.     var min = 1, max = 100;
  1537.     printl('   范围: ' + min + ' - ' + max);
  1538.     delay(200);
  1539.     var randomInt = MathUtils.randomInt(min, max);
  1540.     printl('   随机整数: ' + randomInt);
  1541.     delay(500);
  1542.    
  1543.     printl('▶ 5. 计算平均值');
  1544.     delay(300);
  1545.     var nums = [10, 20, 30, 40, 50];
  1546.     printl('   数字列表: ' + JSON.stringify(nums));
  1547.     delay(200);
  1548.     var avg = MathUtils.average.apply(null, nums);
  1549.     printl('   平均值: ' + avg);
  1550.     delay(500);
  1551.    
  1552.     printl('');
  1553. }

  1555. /**
  1556. * 数字处理工具类演示
  1557. */
  1558. function demoNumberUtils() {
  1559.     printl('┌──────────────────────────────────────────────────────────────────┐');
  1560.     printl('│  NumberUtils - 数字处理工具类                                 │');
  1561.     printl('└──────────────────────────────────────────────────────────────────┘');
  1562.     printl('');
  1563.     delay(400);
  1564.    
  1565.     printl('▶ 1. 千分位格式化 - 金额显示');
  1566.     delay(300);
  1567.     var amount = 1234567.89;
  1568.     printl('   原始金额: ' + amount);
  1569.     delay(200);
  1570.     var formatted = NumberUtils.formatThousands(amount);
  1571.     printl('   格式化后: ¥' + formatted);
  1572.     delay(500);
  1573.    
  1574.     printl('▶ 2. 字节大小格式化 - 文件大小');
  1575.     delay(300);
  1576.     var fileSize = 1536000;
  1577.     printl('   原始字节: ' + fileSize + ' bytes');
  1578.     delay(200);
  1579.     var bytes = NumberUtils.formatBytes(fileSize);
  1580.     printl('   格式化后: ' + bytes);
  1581.     delay(500);
  1582.    
  1583.     printl('▶ 3. 时长格式化 - 显示友好的时间');
  1584.     delay(300);
  1585.     var ms = 3661000;
  1586.     printl('   原始毫秒: ' + ms);
  1587.     delay(200);
  1588.     var duration = NumberUtils.formatDuration(ms);
  1589.     printl('   格式化后: ' + duration);
  1590.     delay(500);
  1591.    
  1592.     printl('▶ 4. 数字转中文大写 - 金额显示');
  1593.     delay(300);
  1594.     var money = 12345;
  1595.     printl('   原始数字: ' + money);
  1596.     delay(200);
  1597.     var chinese = NumberUtils.toChineseMoney(money);
  1598.     printl('   中文大写: ' + chinese);
  1599.     delay(500);
  1600.    
  1601.     printl('▶ 5. 数字转罗马数字');
  1602.     delay(300);
  1603.     var year = 2024;
  1604.     printl('   原始数字: ' + year);
  1605.     delay(200);
  1606.     var roman = NumberUtils.toRoman(year);
  1607.     printl('   罗马数字: ' + roman);
  1608.     delay(500);
  1609.    
  1610.     printl('');
  1611. }

  1613. /**
  1614. * 时间管理工具类演示
  1615. */
  1616. function demoTimeUtils() {
  1617.     printl('┌──────────────────────────────────────────────────────────────────┐');
  1618.     printl('│  TimeUtils - 时间管理工具类                                    │');
  1619.     printl('└──────────────────────────────────────────────────────────────────┘');
  1620.     printl('');
  1621.     delay(400);
  1622.    
  1623.     printl('▶ 1. 时间格式化 - 自定义格式显示');
  1624.     delay(300);
  1625.     var now = new Date();
  1626.     printl('   当前时间: ' + TimeUtils.format(now, 'yyyy-MM-dd HH:mm:ss'));
  1627.     delay(200);
  1628.     printl('   简洁格式: ' + TimeUtils.format(now, 'MM/dd HH:mm'));
  1629.     delay(500);
  1630.    
  1631.     printl('▶ 2. 获取星期几');
  1632.     delay(300);
  1633.     printl('   今天: ' + TimeUtils.dayOfWeek(now));
  1634.     delay(500);
  1635.    
  1636.     printl('▶ 3. 今年第几天');
  1637.     delay(300);
  1638.     printl('   今天是今年第 ' + TimeUtils.dayOfYear(now) + ' 天');
  1639.     delay(500);
  1640.    
  1641.     printl('▶ 4. 倒计时显示');
  1642.     delay(300);
  1643.     var countdownSeconds = 3665;
  1644.     printl('   原始秒数: ' + countdownSeconds);
  1645.     delay(200);
  1646.     var countdown = TimeUtils.countdown(countdownSeconds);
  1647.     printl('   倒计时: ' + countdown);
  1648.     delay(500);
  1649.    
  1650.     printl('▶ 5. 日期加减计算');
  1651.     delay(300);
  1652.     printl('   今天是: ' + TimeUtils.format(now, 'yyyy-MM-dd'));
  1653.     delay(200);
  1654.     var future = TimeUtils.add(now, 7, 'day');
  1655.     printl('   7天后: ' + TimeUtils.format(future, 'yyyy-MM-dd'));
  1656.     delay(200);
  1657.     var past = TimeUtils.add(now, -3, 'day');
  1658.     printl('   3天前: ' + TimeUtils.format(past, 'yyyy-MM-dd'));
  1659.     delay(500);
  1660.    
  1661.     printl('');
  1662. }

  1664. // 主函数入口（由 start.js 调用）
  1665. function runMainDemo() {
  1666.     runAllDemos();
  1667. }

  1669. // 注意：不在此处自动运行，由 start.js 控制调用时机
  1670. // 如需直接运行此脚本，取消下面一行的注释
  1671. runMainDemo();
复制代码



aiwrok软件, AIWROK
楼主新帖
楼主热帖
untoAIWROK软件Function导入方法实例演示nextnocontent

相关帖子
回复

使用道具 举报

返回列表 发新帖
高级模式
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 | 立即注册

本版积分规则

相关导读
群发软件AIWROK安卓苹果平台设计的实用工具库
AIWROK安卓苹果平台设计的实用工具库
群发软件AIWROK软件Function导入方法实例演示
AIWROK软件Function导入方法实例演示
群发软件苹果脚本实例1项目project应用示例
苹果脚本实例1项目project应用示例
群发软件苹果脚本实例1剪贴板功能集成
苹果脚本实例1剪贴板功能集成
群发软件苹果iOS脚本Detect类系统性使用示例
苹果iOS脚本Detect类系统性使用示例
群发软件AIWROK苹果系统打印H5界面日志输出
AIWROK苹果系统打印H5界面日志输出
群发软件H5案例自动化看广告撸金币系统
H5案例自动化看广告撸金币系统
群发软件AIWROK苹果脚本H5任务执行小例子
AIWROK苹果脚本H5任务执行小例子
群发软件AIWROK软件苹果水平容器[Horizontal]小实例
AIWROK软件苹果水平容器[Horizontal]小实例
群发软件AIWROK苹果脚本实例1界面UI输入框类[Input]
AIWROK苹果脚本实例1界面UI输入框类
群发软件AIWROK软件苹果脚本案例1空白站位[Space]方法
AIWROK软件苹果脚本案例1空白站位[Space]方法
群发软件AIWROK软件苹查系统复选框用法
AIWROK软件苹查系统复选框用法
群发软件苹果AIWROK实例单选按钮组类[RadioButtonGroup]完整综合示例
苹果AIWROK实例单选按钮组类[RadioButtonGroup]完整综合示例
群发软件AIWROK软件苹果实例UI-垂直容器[Vertical]高级综合示例
AIWROK软件苹果实例UI-垂直容器[Vertical]高级综合示例
群发软件IOS苹果脚本View的完整功能实例
IOS苹果脚本View的完整功能实例
群发软件AIWROK苹果系统实例演示1标签类[Label]方法
AIWROK苹果系统实例演示1标签类[Label]方法
信息发布软件AIWROK软件苹果UI按钮Button方法示例
AIWROK软件苹果UI按钮Button方法示例
信息发布软件AIWROK软件苹果TAB界面视图示例
AIWROK软件苹果TAB界面视图示例
信息发布软件AIWROK苹果系统自带view视图简洁UI界面示例
AIWROK苹果系统自带view视图简洁UI界面示例
信息发布软件汇集HID安卓输入文字的方法和复制粘贴示例
汇集HID安卓输入文字的方法和复制粘贴示例
信息发布软件AIWROK软件找字与OCR方法汇总示例
AIWROK软件找字与OCR方法汇总示例
信息发布软件AIWROK软件找图方法汇总示例
AIWROK软件找图方法汇总示例
信息发布软件AIWROK软件滑动方法集合示例
AIWROK软件滑动方法集合示例
信息发布软件AIWROK软件安卓AIWROK汇集软件点击
AIWROK软件安卓AIWROK汇集软件点击
信息发布软件苹果系统点击方法综合示例
苹果系统点击方法综合示例
信息发布软件AIWROK苹果系统找图方法完整示例集合
AIWROK苹果系统找图方法完整示例集合
信息发布软件苹果系统找图方法完整示例集合
苹果系统找图方法完整示例集合
信息发布软件苹果IOS系统找字OCR方法例子
苹果IOS系统找字OCR方法例子
信息发布软件AIWORK软件数组高级示例
AIWORK软件数组高级示例
信息发布软件AIWROK软件运算符封装库示例
AIWROK软件运算符封装库示例
信息发布软件AIWROK软件语法运行小示例
AIWROK软件语法运行小示例
信息发布软件AIWROK软件JS循环小示例
AIWROK软件JS循环小示例
信息发布软件AIWROK软件H5网页被主脚本获取值用法
AIWROK软件H5网页被主脚本获取值用法
信息发布软件AIWROK软件创建可暂停恢复的多线程任务
AIWROK软件创建可暂停恢复的多线程任务
信息发布软件AIWROK软件类型转换方法例子
AIWROK软件类型转换方法例子
信息发布软件AIWROK软件H5脚本执行与进度显示
AIWROK软件H5脚本执行与进度显示 .
信息发布软件AIWROK软件根据时间段执行异步任务支持多线程并行处理
AIWROK软件根据时间段执行异步任务支持多线程并行处理
信息发布软件H5自动开关执行脚本功能演示
H5自动开关执行脚本功能演示
信息发布软件AIWROK软件H5单选脚本运行示例
AIWROK软件H5单选脚本运行示例
信息发布软件H5任务脚本选择与执行中心
H5任务脚本选择与执行中心
信息发布软件H5里CheckBox控件演示
H5里CheckBox控件演示
信息发布软件AIWROK软件正则用法实际例子
AIWROK软件正则用法实际例子
信息发布软件AIWROK软件权限管理器实现
AIWROK软件权限管理器实现
信息发布软件AIWORK软件节点方法无碍示例子
AIWORK软件节点方法无碍示例子
信息发布软件JSON.stringify 和 JSON.parse 完整示例
JSON.stringify 和 JSON.parse 完整示例
信息发布软件AIWROK软件展示JavaScript各种语句标识符的用法
AIWROK软件展示JavaScript各种语句标识符的用法
信息发布软件JS巧妙地组合使用各种条件语句
JS巧妙地组合使用各种条件语句
信息发布软件AIWROK手机数据库MySQL数据库截图片批量上传操作脚本
AIWROK手机数据库MySQL数据库截图片批量上传操作脚本
信息发布软件HID中文输入智能打字功能
HID中文输入智能打字功能
信息发布软件AIWROK软件对象工具函数库例子
AIWROK软件对象工具函数库例子
信息发布软件AIWROK软件H5交互演示黄色主题
AIWROK软件H5交互演示黄色主题
信息发布软件H5单按钮执行脚本示例
H5单按钮执行脚本示例
信息发布软件苹果H5界面完整调用脚本示例
苹果H5界面完整调用脚本示例
信息发布软件AIWROK软件平台设备信息全面检测工具例子
AIWROK软件平台设备信息全面检测工具例子
信息发布软件AIWROK创建和放大日志窗口并展示动态内容
AIWROK创建和放大日志窗口并展示动态内容
信息发布软件AIWROK软件device相关方法获取设备信息例子
AIWROK软件device相关方法获取设备信息例子[/backcolor]
信息发布软件数据库MySQL实时内容随机调用
数据库MySQL实时内容随机调用
信息发布软件AIWROK软件分享一个特效苹果H5页面
AIWROK软件分享一个特效苹果H5页面
信息发布软件数据库MYQ业务流程心跳程序启动
数据库MYQ业务流程心跳程序启动
信息发布软件数据库MySQL功能支持创建表插入中文数据查询删除功能例子
数据库MySQL功能支持创建表插入中文数据查询删除功能例子
信息发布软件AIWROK软件Zip 高级操作复杂示例
AIWROK软件Zip 高级操作复杂示例
信息发布软件AIWROK软件txt_文件读写方法小结
AIWROK软件txt_文件读写方法小结
信息发布软件AIWROK软件file文件操作方法小结
AIWROK软件file文件操作方法小结
信息发布软件AIWORK软件配置读写H5演示配套脚本
AIWORK软件配置读写H5演示配套脚本
信息发布软件AIWROK配置读写功能演示示例
AIWROK配置读写功能演示示例

QQ|( 京ICP备09078825号 )

本网站信息发布软件，是可以发布论坛，发送信息到各大博客，各大b2b软件自动发布，好不夸张的说：只要手工能发在电脑打开IE能发的网站，用这个宣传软件就可以仿制动作，进行推送发到您想发送的B2B网站或是信息发布平台上，不管是后台，还是前台，都可以进行最方便的广告发布，这个广告发布软件，可以按月购买，还可以试用软件，对网站的验证码也可以完全自动对信息发布，让客户自动找上门,使企业轻松实现b2b发布，这个信息发布软件，均是本站原创正版开发，拥有正版的血统，想要新功能，欢迎提意见给我，一好的分类信息群发软件在手，舍我其谁。QQ896757558

GMT+8, 2026-3-17 13:37 , Processed in 0.370987 second(s), 51 queries .

宣传软件--信息发布软件--b2b软件【广告发布软件】

快速回复 返回顶部 返回列表