注册 登录
发贴工具
自动发帖软件»群发软件 › 群发软件公告教程 › AIWORK源码分享 › AIWROK软件示例数组方法实战应用
返回列表 发帖
查看: 1|回复: 0
打印 上一主题 下一主题

[24小时收录超级好的网站] AIWROK软件示例数组方法实战应用

[复制链接]

2540

主题

2588

帖子

1万

积分

积分
15414
跳转到指定楼层
楼主
发帖软件 发表于 1 小时前 | 只看该作者 |只看大图 回帖奖励 |倒序浏览 |阅读模式
AIWROK软件示例数组方法实战应用
AIWROK软件示例数组方法实战应用 群发软件发帖工具

  1. /**
  2. * AIWROK数组方法实战应用示例
  3. * 专为AIWROK安卓自动化环境设计的真实数组应用场景
  4. *
  5. * @功能特点
  6. * - UI控件数组的查找、筛选和批量操作
  7. * - 图像识别结果的数组处理和坐标计算
  8. * - 设备信息数组的管理和查询
  9. * - 任务队列数组的调度和执行
  10. *
  11. * @作者 AIWROK开发团队
  12. * @版本 3.0 - 实战版
  13. * @日期 2024
  14. */

  16. //===========================================
  17. // 基础兼容性设置
  18. //===========================================

  20. // AIWROK环境统一使用console.log输出日志

  22. //===========================================
  23. // 高级数组工具类 - 增强版
  24. //===========================================

  26. /**
  27. * AdvancedArrayUtils - 高级数组操作工具类
  28. * 提供链式调用、批量处理和性能优化功能
  29. */
  30. function AdvancedArrayUtils() {
  31.     this.version = "2.0.0";
  32.     this.performanceMetrics = {
  33.         operations: 0,
  34.         startTime: 0,
  35.         endTime: 0,
  36.         memoryUsage: 0
  37.     };
  38. }

  40. /**
  41. * 开始性能监控
  42. */
  43. AdvancedArrayUtils.prototype.startPerformanceMonitoring = function() {
  44.     this.performanceMetrics.startTime = new Date().getTime();
  45.     this.performanceMetrics.operations = 0;
  46.     return this;
  47. };

  49. /**
  50. * 结束性能监控并返回报告
  51. */
  52. AdvancedArrayUtils.prototype.endPerformanceMonitoring = function() {
  53.     this.performanceMetrics.endTime = new Date().getTime();
  54.     var duration = this.performanceMetrics.endTime - this.performanceMetrics.startTime;
  55.     return {
  56.         duration: duration,
  57.         operations: this.performanceMetrics.operations,
  58.         opsPerSecond: Math.round(this.performanceMetrics.operations / (duration / 1000)),
  59.         memoryUsage: this.performanceMetrics.memoryUsage
  60.     };
  61. };

  63. /**
  64. * 安全数组遍历 - 支持中断和异常处理
  65. * @param {Array} array - 要遍历的数组
  66. * @param {Function} callback - 回调函数，返回false可中断遍历
  67. * @param {Object} context - 回调函数上下文
  68. * @returns {AdvancedArrayUtils} 支持链式调用
  69. */
  70. AdvancedArrayUtils.prototype.forEachSafe = function(array, callback, context) {
  71.     if (!Array.isArray(array)) throw new Error('参数必须是数组');
  72.     if (typeof callback !== 'function') throw new Error('回调函数必须是函数');
  73.    
  74.     context = context || this;
  75.    
  76.     try {
  77.         for (var i = 0; i < array.length; i++) {
  78.             this.performanceMetrics.operations++;
  79.             var result = callback.call(context, array[i], i, array);
  80.             if (result === false) break; // 支持主动中断
  81.         }
  82.     } catch (e) {
  83.         console.log("数组遍历错误 at index " + i + ": " + (e.message || e));
  84.     }
  85.    
  86.     return this;
  87. };

  89. /**
  90. * 智能数组过滤 - 支持多条件和复杂逻辑
  91. * @param {Array} array - 源数组
  92. * @param {Array} conditions - 过滤条件数组
  93. * @returns {Array} 过滤后的数组
  94. *
  95. * @示例
  96. * var result = advancedArrayUtils.smartFilter(data, [
  97. *     { field: 'age', operator: '>', value: 18 },
  98. *     { field: 'name', operator: 'contains', value: '张' },
  99. *     { field: 'score', operator: 'between', value: [60, 100] }
  100. * ]);
  101. */
  102. AdvancedArrayUtils.prototype.smartFilter = function(array, conditions) {
  103.     if (!Array.isArray(array)) throw new Error('第一个参数必须是数组');
  104.     if (!Array.isArray(conditions)) throw new Error('条件参数必须是数组');
  105.    
  106.     var self = this;
  107.    
  108.     return array.filter(function(item) {
  109.         self.performanceMetrics.operations++;
  110.         
  111.         for (var i = 0; i < conditions.length; i++) {
  112.             var condition = conditions[i];
  113.             var fieldValue = self.getFieldValue(item, condition.field);
  114.             
  115.             if (!self.evaluateCondition(fieldValue, condition.operator, condition.value)) {
  116.                 return false;
  117.             }
  118.         }
  119.         
  120.         return true;
  121.     });
  122. };

  124. /**
  125. * 获取对象字段值 - 支持嵌套属性访问
  126. */
  127. AdvancedArrayUtils.prototype.getFieldValue = function(obj, field) {
  128.     if (!obj || !field) return undefined;
  129.    
  130.     var parts = field.split('.');
  131.     var result = obj;
  132.    
  133.     for (var i = 0; i < parts.length; i++) {
  134.         if (result === null || result === undefined) return undefined;
  135.         result = result[parts[i]];
  136.     }
  137.    
  138.     return result;
  139. };

  141. /**
  142. * 评估条件 - 支持多种操作符
  143. */
  144. AdvancedArrayUtils.prototype.evaluateCondition = function(fieldValue, operator, conditionValue) {
  145.     switch (operator) {
  146.         case '==': return fieldValue == conditionValue;
  147.         case '===': return fieldValue === conditionValue;
  148.         case '!=': return fieldValue != conditionValue;
  149.         case '!==': return fieldValue !== conditionValue;
  150.         case '>': return fieldValue > conditionValue;
  151.         case '>=': return fieldValue >= conditionValue;
  152.         case '<': return fieldValue < conditionValue;
  153.         case '<=': return fieldValue <= conditionValue;
  154.         case 'contains':
  155.             return String(fieldValue).indexOf(conditionValue) !== -1;
  156.         case 'startsWith':
  157.             return String(fieldValue).indexOf(conditionValue) === 0;
  158.         case 'endsWith':
  159.             var str = String(fieldValue);
  160.             return str.lastIndexOf(conditionValue) === str.length - conditionValue.length;
  161.         case 'between':
  162.             return fieldValue >= conditionValue[0] && fieldValue <= conditionValue[1];
  163.         case 'in':
  164.             return conditionValue.indexOf(fieldValue) !== -1;
  165.         case 'notIn':
  166.             return conditionValue.indexOf(fieldValue) === -1;
  167.         default:
  168.             return false;
  169.     }
  170. };

  172. /**
  173. * 数组数据聚合 - 支持多种聚合函数
  174. * @param {Array} array - 源数组
  175. * @param {Object} config - 聚合配置
  176. * @returns {Object} 聚合结果
  177. *
  178. * @示例
  179. * var stats = advancedArrayUtils.aggregate(salesData, {
  180. *     groupBy: 'category',
  181. *     metrics: {
  182. *         totalSales: { field: 'amount', operation: 'sum' },
  183. *         avgPrice: { field: 'price', operation: 'avg' },
  184. *         count: { operation: 'count' }
  185. *     }
  186. * });
  187. */
  188. AdvancedArrayUtils.prototype.aggregate = function(array, config) {
  189.     if (!Array.isArray(array)) throw new Error('参数必须是数组');
  190.    
  191.     var result = {};
  192.     var self = this;
  193.    
  194.     // 分组处理
  195.     if (config.groupBy) {
  196.         var groups = {};
  197.         
  198.         array.forEach(function(item) {
  199.             self.performanceMetrics.operations++;
  200.             var groupKey = self.getFieldValue(item, config.groupBy);
  201.             if (!groups[groupKey]) {
  202.                 groups[groupKey] = [];
  203.             }
  204.             groups[groupKey].push(item);
  205.         });
  206.         
  207.         // 对每个分组进行聚合
  208.         for (var groupKey in groups) {
  209.             if (groups.hasOwnProperty(groupKey)) {
  210.                 result[groupKey] = self.calculateMetrics(groups[groupKey], config.metrics);
  211.             }
  212.         }
  213.     } else {
  214.         // 不分组，直接聚合
  215.         result = this.calculateMetrics(array, config.metrics);
  216.     }
  217.    
  218.     return result;
  219. };

  221. /**
  222. * 计算指标 - 支持多种聚合操作
  223. */
  224. AdvancedArrayUtils.prototype.calculateMetrics = function(array, metrics) {
  225.     var result = {};
  226.     var self = this;
  227.    
  228.     for (var metricName in metrics) {
  229.         if (metrics.hasOwnProperty(metricName)) {
  230.             var metric = metrics[metricName];
  231.             result[metricName] = self.calculateMetric(array, metric);
  232.         }
  233.     }
  234.    
  235.     return result;
  236. };

  238. /**
  239. * 计算单个指标
  240. */
  241. AdvancedArrayUtils.prototype.calculateMetric = function(array, metric) {
  242.     var operation = metric.operation;
  243.     var field = metric.field;
  244.    
  245.     switch (operation) {
  246.         case 'count':
  247.             return array.length;
  248.             
  249.         case 'sum':
  250.             return array.reduce(function(sum, item) {
  251.                 return sum + (field ? this.getFieldValue(item, field) : item);
  252.             }.bind(this), 0);
  253.             
  254.         case 'avg':
  255.             var sum = array.reduce(function(sum, item) {
  256.                 return sum + (field ? this.getFieldValue(item, field) : item);
  257.             }.bind(this), 0);
  258.             return array.length > 0 ? sum / array.length : 0;
  259.             
  260.         case 'max':
  261.             return Math.max.apply(Math, array.map(function(item) {
  262.                 return field ? this.getFieldValue(item, field) : item;
  263.             }.bind(this)));
  264.             
  265.         case 'min':
  266.             return Math.min.apply(Math, array.map(function(item) {
  267.                 return field ? this.getFieldValue(item, field) : item;
  268.             }.bind(this)));
  269.             
  270.         default:
  271.             return 0;
  272.     }
  273. };

  275. /**
  276. * 数组分页处理 - 支持大数据集的分页显示
  277. * @param {Array} array - 源数组
  278. * @param {number} pageSize - 每页大小
  279. * @param {number} pageNumber - 页码（从1开始）
  280. * @returns {Object} 分页结果
  281. */
  282. AdvancedArrayUtils.prototype.paginate = function(array, pageSize, pageNumber) {
  283.     if (!Array.isArray(array)) throw new Error('参数必须是数组');
  284.    
  285.     pageSize = Math.max(1, pageSize || 10);
  286.     pageNumber = Math.max(1, pageNumber || 1);
  287.    
  288.     var totalItems = array.length;
  289.     var totalPages = Math.ceil(totalItems / pageSize);
  290.     var startIndex = (pageNumber - 1) * pageSize;
  291.     var endIndex = Math.min(startIndex + pageSize, totalItems);
  292.    
  293.     return {
  294.         items: array.slice(startIndex, endIndex),
  295.         pagination: {
  296.             pageNumber: pageNumber,
  297.             pageSize: pageSize,
  298.             totalItems: totalItems,
  299.             totalPages: totalPages,
  300.             hasPrevious: pageNumber > 1,
  301.             hasNext: pageNumber < totalPages,
  302.             startIndex: startIndex,
  303.             endIndex: endIndex - 1
  304.         }
  305.     };
  306. };

  308. /**
  309. * 数组去重 - 支持复杂对象的去重
  310. * @param {Array} array - 源数组
  311. * @param {string|Function} keySelector - 用于去重的键选择器
  312. * @returns {Array} 去重后的数组
  313. */
  314. AdvancedArrayUtils.prototype.distinct = function(array, keySelector) {
  315.     if (!Array.isArray(array)) throw new Error('参数必须是数组');
  316.    
  317.     var seen = {};
  318.     var result = [];
  319.     var self = this;
  320.    
  321.     array.forEach(function(item) {
  322.         self.performanceMetrics.operations++;
  323.         
  324.         var key;
  325.         if (typeof keySelector === 'function') {
  326.             key = keySelector(item);
  327.         } else if (typeof keySelector === 'string') {
  328.             key = self.getFieldValue(item, keySelector);
  329.         } else {
  330.             key = item;
  331.         }
  332.         
  333.         var keyString = String(key);
  334.         if (!seen.hasOwnProperty(keyString)) {
  335.             seen[keyString] = true;
  336.             result.push(item);
  337.         }
  338.     });
  339.    
  340.     return result;
  341. };

  343. //===========================================
  344. // AIWROK特定功能集成
  345. //===========================================

  347. /**
  348. * UI控件批量处理 - 结合AIWROK的UI操作
  349. * @param {Array} uiElements - UI元素数组
  350. * @param {Function} processor - 处理函数
  351. * @param {Object} options - 处理选项
  352. */
  353. AdvancedArrayUtils.prototype.batchUIProcess = function(uiElements, processor, options) {
  354.     options = options || {};
  355.     var batchSize = options.batchSize || 10;
  356.     var delay = options.delay || 100;
  357.     var self = this;
  358.    
  359.     console.log("开始批量处理 " + uiElements.length + " 个UI元素");
  360.    
  361.     var batches = [];
  362.     for (var i = 0; i < uiElements.length; i += batchSize) {
  363.         batches.push(uiElements.slice(i, i + batchSize));
  364.     }
  365.    
  366.     // 分批处理（AIWROK环境使用threads.sleep代替setTimeout）
  367.     for (var batchIndex = 0; batchIndex < batches.length; batchIndex++) {
  368.         var batch = batches[batchIndex];
  369.         console.log("处理第 " + (batchIndex + 1) + " 批，共 " + batch.length + " 个元素");
  370.         
  371.         batch.forEach(function(element, index) {
  372.             try {
  373.                 processor(element, index);
  374.                 self.performanceMetrics.operations++;
  375.             } catch (e) {
  376.                 console.log("处理UI元素失败: " + (e.message || e));
  377.             }
  378.         });
  379.         
  380.         // 批次间延时
  381.         if (batchIndex < batches.length - 1) {
  382.             sleep.second(delay / 1000);
  383.         }
  384.     }
  385.    
  386.     console.log("批量处理完成");
  387.    
  388.     return this;
  389. };

  391. /**
  392. * OCR结果智能筛选 - 结合AIWROK的OCR功能
  393. * @param {Array} ocrResults - OCR识别结果数组
  394. * @param {Object} filterOptions - 筛选选项
  395. * @returns {Array} 筛选后的结果
  396. */
  397. AdvancedArrayUtils.prototype.filterOCRResults = function(ocrResults, filterOptions) {
  398.     filterOptions = filterOptions || {};
  399.    
  400.     var conditions = [];
  401.    
  402.     // 文本长度过滤
  403.     if (filterOptions.minLength) {
  404.         conditions.push({
  405.             field: 'text',
  406.             operator: '>',
  407.             value: filterOptions.minLength
  408.         });
  409.     }
  410.    
  411.     // 置信度过滤
  412.     if (filterOptions.minConfidence) {
  413.         conditions.push({
  414.             field: 'confidence',
  415.             operator: '>=',
  416.             value: filterOptions.minConfidence
  417.         });
  418.     }
  419.    
  420.     // 文本内容过滤
  421.     if (filterOptions.contains) {
  422.         conditions.push({
  423.             field: 'text',
  424.             operator: 'contains',
  425.             value: filterOptions.contains
  426.         });
  427.     }
  428.    
  429.     // 位置过滤
  430.     if (filterOptions.minX !== undefined) {
  431.         conditions.push({
  432.             field: 'x',
  433.             operator: '>=',
  434.             value: filterOptions.minX
  435.         });
  436.     }
  437.    
  438.     return this.smartFilter(ocrResults, conditions);
  439. };

  441. /**
  442. * 日志数据聚合分析 - 结合AIWROK的日志功能
  443. * @param {Array} logEntries - 日志条目数组
  444. * @param {Object} analysisConfig - 分析配置
  445. * @returns {Object} 分析结果
  446. */
  447. AdvancedArrayUtils.prototype.analyzeLogs = function(logEntries, analysisConfig) {
  448.     analysisConfig = analysisConfig || {};
  449.    
  450.     var timeWindow = analysisConfig.timeWindow || 3600000; // 1小时
  451.     var logLevelWeights = analysisConfig.logLevelWeights || {
  452.         'ERROR': 10,
  453.         'WARN': 5,
  454.         'INFO': 1,
  455.         'DEBUG': 0.5
  456.     };
  457.    
  458.     var currentTime = new Date().getTime();
  459.     var recentLogs = logEntries.filter(function(log) {
  460.         return currentTime - log.timestamp <= timeWindow;
  461.     });
  462.    
  463.     var analysis = {
  464.         totalLogs: recentLogs.length,
  465.         levelDistribution: {},
  466.         errorRate: 0,
  467.         warningRate: 0,
  468.         healthScore: 100
  469.     };
  470.    
  471.     // 统计日志级别分布
  472.     recentLogs.forEach(function(log) {
  473.         var level = log.level || 'INFO';
  474.         analysis.levelDistribution[level] = (analysis.levelDistribution[level] || 0) + 1;
  475.     });
  476.    
  477.     // 计算错误率和警告率
  478.     var errorCount = analysis.levelDistribution['ERROR'] || 0;
  479.     var warnCount = analysis.levelDistribution['WARN'] || 0;
  480.    
  481.     analysis.errorRate = analysis.totalLogs > 0 ? (errorCount / analysis.totalLogs) * 100 : 0;
  482.     analysis.warningRate = analysis.totalLogs > 0 ? (warnCount / analysis.totalLogs) * 100 : 0;
  483.    
  484.     // 计算健康分数
  485.     var totalWeight = 0;
  486.     var weightedScore = 0;
  487.    
  488.     for (var level in analysis.levelDistribution) {
  489.         if (analysis.levelDistribution.hasOwnProperty(level)) {
  490.             var count = analysis.levelDistribution[level];
  491.             var weight = logLevelWeights[level] || 1;
  492.             totalWeight += count * weight;
  493.             weightedScore += count * weight;
  494.         }
  495.     }
  496.    
  497.     if (totalWeight > 0) {
  498.         analysis.healthScore = Math.max(0, 100 - (errorCount * 10) - (warnCount * 3));
  499.     }
  500.    
  501.     return analysis;
  502. };

  504. //===========================================
  505. // 使用示例和测试
  506. //===========================================

  508. function uiControlArrayExample() {
  509.     console.log("=== 示例1: UI控件数组操作 ===");
  510.    
  511.     // 模拟通过findControls获取的UI控件数组
  512.     var uiControls = [
  513.         { id: 'btn_login', type: 'Button', text: '登录', visible: true, enabled: true, x: 100, y: 200, width: 200, height: 80 },
  514.         { id: 'btn_register', type: 'Button', text: '注册', visible: true, enabled: true, x: 100, y: 300, width: 200, height: 80 },
  515.         { id: 'input_username', type: 'EditText', text: '', visible: true, enabled: true, x: 50, y: 100, width: 300, height: 60 },
  516.         { id: 'input_password', type: 'EditText', text: '', visible: true, enabled: true, x: 50, y: 170, width: 300, height: 60 },
  517.         { id: 'chk_remember', type: 'CheckBox', text: '记住密码', visible: true, enabled: true, x: 50, y: 250, width: 150, height: 40 },
  518.         { id: 'txt_forgot', type: 'TextView', text: '忘记密码？', visible: true, enabled: true, x: 250, y: 250, width: 120, height: 40 },
  519.         { id: 'btn_cancel', type: 'Button', text: '取消', visible: false, enabled: false, x: 100, y: 400, width: 200, height: 80 }
  520.     ];
  521.    
  522.     console.log("找到 " + uiControls.length + " 个UI控件");
  523.    
  524.     // 1. 筛选所有可见且可用的按钮
  525.     var clickableButtons = [];
  526.     for (var i = 0; i < uiControls.length; i++) {
  527.         var ctrl = uiControls[i];
  528.         if (ctrl.type === 'Button' && ctrl.visible && ctrl.enabled) {
  529.             clickableButtons.push(ctrl);
  530.         }
  531.     }
  532.    
  533.     console.log("可点击的按钮有 " + clickableButtons.length + " 个:");
  534.     for (var j = 0; j < clickableButtons.length; j++) {
  535.         console.log("  - " + clickableButtons[j].text + " (位置: " + clickableButtons[j].x + "," + clickableButtons[j].y + ")");
  536.     }
  537.    
  538.     // 2. 查找特定文本的控件
  539.     var loginButton = null;
  540.     for (var k = 0; k < uiControls.length; k++) {
  541.         if (uiControls[k].text === '登录') {
  542.             loginButton = uiControls[k];
  543.             break;
  544.         }
  545.     }
  546.    
  547.     if (loginButton) {
  548.         console.log("找到登录按钮:");
  549.         console.log("  ID: " + loginButton.id);
  550.         console.log("  类型: " + loginButton.type);
  551.         console.log("  位置: (" + loginButton.x + ", " + loginButton.y + ")");
  552.         console.log("  尺寸: " + loginButton.width + "x" + loginButton.height);
  553.         console.log("  中心点: (" + (loginButton.x + loginButton.width/2) + ", " + (loginButton.y + loginButton.height/2) + ")");
  554.     }
  555.    
  556.     // 3. 批量计算控件中心坐标（用于点击操作）
  557.     console.log("所有输入框的中心坐标:");
  558.     for (var m = 0; m < uiControls.length; m++) {
  559.         var control = uiControls[m];
  560.         if (control.type === 'EditText') {
  561.             var centerX = control.x + control.width / 2;
  562.             var centerY = control.y + control.height / 2;
  563.             console.log("  " + control.id + ": (" + centerX + ", " + centerY + ")");
  564.         }
  565.     }
  566.    
  567.     // 步骤间延时2秒
  568.     console.log("等待2秒...");
  569.     sleep.second(2);
  570. }

  572. /**
  573. * 图像识别结果数组处理示例
  574. */
  575. function imageRecognitionArrayExample() {
  576.     console.log("=== 示例2: 图像识别结果数组处理 ===");
  577.    
  578.     // 模拟通过findImage或shapeSearch返回的识别结果数组
  579.     var recognitionResults = [
  580.         { name: '登录按钮', confidence: 0.95, x: 150, y: 300, width: 180, height: 60, timestamp: new Date().getTime() },
  581.         { name: '登录按钮', confidence: 0.92, x: 152, y: 298, width: 178, height: 62, timestamp: new Date().getTime() + 100 },
  582.         { name: '提交按钮', confidence: 0.88, x: 200, y: 500, width: 160, height: 55, timestamp: new Date().getTime() + 200 },
  583.         { name: '验证码图片', confidence: 0.75, x: 100, y: 400, width: 200, height: 80, timestamp: new Date().getTime() + 300 },
  584.         { name: '登录按钮', confidence: 0.90, x: 148, y: 302, width: 182, height: 58, timestamp: new Date().getTime() + 400 }
  585.     ];
  586.    
  587.     console.log("识别到 " + recognitionResults.length + " 个目标");
  588.    
  589.     // 1. 筛选高置信度的结果（>0.85）
  590.     var highConfidenceResults = [];
  591.     for (var i = 0; i < recognitionResults.length; i++) {
  592.         if (recognitionResults[i].confidence > 0.85) {
  593.             highConfidenceResults.push(recognitionResults[i]);
  594.         }
  595.     }
  596.    
  597.     console.log("高置信度结果（>0.85）有 " + highConfidenceResults.length + " 个:");
  598.     for (var j = 0; j < highConfidenceResults.length; j++) {
  599.         var result = highConfidenceResults[j];
  600.         console.log("  - " + result.name + " (置信度: " + result.confidence + ", 位置: " + result.x + "," + result.y + ")");
  601.     }
  602.    
  603.     // 2. 按名称分组统计
  604.     var groupedByName = {};
  605.     for (var k = 0; k < recognitionResults.length; k++) {
  606.         var item = recognitionResults[k];
  607.         if (!groupedByName[item.name]) {
  608.             groupedByName[item.name] = [];
  609.         }
  610.         groupedByName[item.name].push(item);
  611.     }
  612.    
  613.     console.log("按名称分组统计:");
  614.     for (var name in groupedByName) {
  615.         if (groupedByName.hasOwnProperty(name)) {
  616.             var items = groupedByName[name];
  617.             console.log("  " + name + ": " + items.length + " 次匹配");
  618.             
  619.             // 计算平均置信度
  620.             var totalConfidence = 0;
  621.             for (var m = 0; m < items.length; m++) {
  622.                 totalConfidence += items[m].confidence;
  623.             }
  624.             var avgConfidence = totalConfidence / items.length;
  625.             console.log("    平均置信度: " + avgConfidence.toFixed(3));
  626.             
  627.             // 找到最佳匹配（最高置信度）
  628.             var bestMatch = items[0];
  629.             for (var n = 1; n < items.length; n++) {
  630.                 if (items[n].confidence > bestMatch.confidence) {
  631.                     bestMatch = items[n];
  632.                 }
  633.             }
  634.             console.log("    最佳匹配: (" + bestMatch.x + ", " + bestMatch.y + ") 置信度: " + bestMatch.confidence);
  635.         }
  636.     }
  637.    
  638.     // 3. 计算多个匹配点的中心位置（用于提高点击精度）
  639.     var loginButtons = groupedByName['登录按钮'];
  640.     if (loginButtons && loginButtons.length > 0) {
  641.         var sumX = 0, sumY = 0;
  642.         for (var p = 0; p < loginButtons.length; p++) {
  643.             sumX += loginButtons[p].x + loginButtons[p].width / 2;
  644.             sumY += loginButtons[p].y + loginButtons[p].height / 2;
  645.         }
  646.         var centerX = sumX / loginButtons.length;
  647.         var centerY = sumY / loginButtons.length;
  648.         
  649.         console.log("登录按钮的平均中心位置:");
  650.         console.log("  X: " + Math.round(centerX));
  651.         console.log("  Y: " + Math.round(centerY));
  652.         console.log("  建议点击坐标: (" + Math.round(centerX) + ", " + Math.round(centerY) + ")");
  653.     }
  654.    
  655.     // 步骤间延时2秒
  656.     console.log("等待2秒...");
  657.     sleep.second(2);
  658. }

  660. /**
  661. * 任务队列数组调度示例
  662. */
  663. function taskQueueArrayExample() {
  664.     console.log("=== 示例3: 任务队列数组调度 ===");
  665.    
  666.     // 模拟任务队列数组
  667.     var taskQueue = [
  668.         { id: 1, name: '打开应用', priority: 1, status: 'pending', duration: 2000 },
  669.         { id: 2, name: '等待首页加载', priority: 2, status: 'pending', duration: 3000 },
  670.         { id: 3, name: '点击登录按钮', priority: 3, status: 'pending', duration: 1000 },
  671.         { id: 4, name: '输入用户名', priority: 4, status: 'pending', duration: 1500 },
  672.         { id: 5, name: '输入密码', priority: 5, status: 'pending', duration: 1500 },
  673.         { id: 6, name: '点击提交', priority: 6, status: 'pending', duration: 1000 },
  674.         { id: 7, name: '验证登录结果', priority: 7, status: 'pending', duration: 2000 }
  675.     ];
  676.    
  677.     console.log("任务队列共有 " + taskQueue.length + " 个任务");
  678.    
  679.     // 1. 按优先级排序
  680.     taskQueue.sort(function(a, b) {
  681.         return a.priority - b.priority;
  682.     });
  683.    
  684.     console.log("按优先级排序后的任务列表:");
  685.     for (var i = 0; i < taskQueue.length; i++) {
  686.         var task = taskQueue[i];
  687.         console.log("  [" + task.priority + "] " + task.name + " (预计耗时: " + task.duration + "ms)");
  688.     }
  689.    
  690.     // 2. 模拟执行任务队列
  691.     console.log("开始执行任务队列:");
  692.     var completedTasks = [];
  693.     var failedTasks = [];
  694.    
  695.     for (var j = 0; j < taskQueue.length; j++) {
  696.         var currentTask = taskQueue[j];
  697.         console.log("  执行任务 #" + (j+1) + ": " + currentTask.name);
  698.         
  699.         // 模拟任务执行（成功率90%）
  700.         var success = Math.random() > 0.1;
  701.         
  702.         if (success) {
  703.             currentTask.status = 'completed';
  704.             completedTasks.push(currentTask);
  705.             console.log("    ✓ 完成");
  706.         } else {
  707.             currentTask.status = 'failed';
  708.             failedTasks.push(currentTask);
  709.             console.log("    ✗ 失败");
  710.         }
  711.         
  712.         // 任务间短暂延时
  713.         sleep.second(0.3);
  714.     }
  715.    
  716.     console.log("");
  717.     console.log("任务执行统计:");
  718.     console.log("  总任务数: " + taskQueue.length);
  719.     console.log("  成功: " + completedTasks.length);
  720.     console.log("  失败: " + failedTasks.length);
  721.     console.log("  成功率: " + (completedTasks.length / taskQueue.length * 100).toFixed(1) + "%");
  722.    
  723.     if (failedTasks.length > 0) {
  724.         console.log("");
  725.         console.log("失败的任务:");
  726.         for (var k = 0; k < failedTasks.length; k++) {
  727.             console.log("  - " + failedTasks[k].name);
  728.         }
  729.     }
  730.    
  731.     // 步骤间延时2秒
  732.     console.log("等待2秒...");
  733.     sleep.second(2);
  734. }

  736. /**
  737. * 设备信息数组管理示例
  738. */
  739. function deviceInfoArrayExample() {
  740.     console.log("=== 示例4: 设备信息数组管理 ===");
  741.    
  742.     // 模拟多设备信息数组
  743.     var devices = [
  744.         { deviceId: 'device_001', model: '小米11', androidVersion: '12', screenWidth: 1080, screenHeight: 2400, battery: 85, online: true },
  745.         { deviceId: 'device_002', model: '华为P40', androidVersion: '11', screenWidth: 1080, screenHeight: 2340, battery: 62, online: true },
  746.         { deviceId: 'device_003', model: 'OPPO Reno6', androidVersion: '11', screenWidth: 1080, screenHeight: 2400, battery: 45, online: false },
  747.         { deviceId: 'device_004', model: 'vivo X60', androidVersion: '12', screenWidth: 1080, screenHeight: 2376, battery: 90, online: true },
  748.         { deviceId: 'device_005', model: '三星S21', androidVersion: '13', screenWidth: 1080, screenHeight: 2400, battery: 30, online: true }
  749.     ];
  750.    
  751.     console.log("设备列表共有 " + devices.length + " 台设备");
  752.    
  753.     // 1. 筛选在线设备
  754.     var onlineDevices = [];
  755.     for (var i = 0; i < devices.length; i++) {
  756.         if (devices[i].online) {
  757.             onlineDevices.push(devices[i]);
  758.         }
  759.     }
  760.    
  761.     console.log("在线设备: " + onlineDevices.length + " 台");
  762.     for (var j = 0; j < onlineDevices.length; j++) {
  763.         var device = onlineDevices[j];
  764.         console.log("  - " + device.model + " (电量: " + device.battery + "%, Android " + device.androidVersion + ")");
  765.     }
  766.    
  767.     // 2. 查找低电量设备（<50%）
  768.     var lowBatteryDevices = [];
  769.     for (var k = 0; k < devices.length; k++) {
  770.         if (devices[k].battery < 50) {
  771.             lowBatteryDevices.push(devices[k]);
  772.         }
  773.     }
  774.    
  775.     if (lowBatteryDevices.length > 0) {
  776.         console.log("低电量设备警告 (<50%): " + lowBatteryDevices.length + " 台");
  777.         for (var m = 0; m < lowBatteryDevices.length; m++) {
  778.             var lowDevice = lowBatteryDevices[m];
  779.             console.log("  ⚠ " + lowDevice.model + " - 电量: " + lowDevice.battery + "%");
  780.         }
  781.     } else {
  782.         console.log("所有设备电量充足");
  783.     }
  784.    
  785.     // 3. 按Android版本分组
  786.     var versionGroups = {};
  787.     for (var n = 0; n < devices.length; n++) {
  788.         var dev = devices[n];
  789.         var version = 'Android ' + dev.androidVersion;
  790.         if (!versionGroups[version]) {
  791.             versionGroups[version] = [];
  792.         }
  793.         versionGroups[version].push(dev);
  794.     }
  795.    
  796.     console.log("按Android版本分组:");
  797.     for (var version in versionGroups) {
  798.         if (versionGroups.hasOwnProperty(version)) {
  799.             var group = versionGroups[version];
  800.             console.log("  " + version + ": " + group.length + " 台设备");
  801.             for (var p = 0; p < group.length; p++) {
  802.                 console.log("    - " + group[p].model);
  803.             }
  804.         }
  805.     }
  806.    
  807.     // 4. 计算平均电量
  808.     var totalBattery = 0;
  809.     for (var q = 0; q < devices.length; q++) {
  810.         totalBattery += devices[q].battery;
  811.     }
  812.     var avgBattery = totalBattery / devices.length;
  813.    
  814.     console.log("设备统计信息:");
  815.     console.log("  平均电量: " + avgBattery.toFixed(1) + "%");
  816.     console.log("  最高电量: " + Math.max.apply(Math, devices.map(function(d) { return d.battery; })) + "%");
  817.     console.log("  最低电量: " + Math.min.apply(Math, devices.map(function(d) { return d.battery; })) + "%");
  818.    
  819.     // 步骤间延时2秒
  820.     console.log("等待2秒...");
  821.     sleep.second(2);
  822. }

  824. //===========================================
  825. // 主函数和执行入口
  826. //===========================================

  828. /**
  829. * 运行所有示例
  830. */
  831. function runAllExamples() {
  832.     try {
  833.         uiControlArrayExample();
  834.         imageRecognitionArrayExample();
  835.         taskQueueArrayExample();
  836.         deviceInfoArrayExample();
  837.         console.log("=== 所有示例执行完成 ===");
  838.     } catch (e) {
  839.         console.log("执行示例时发生错误: " + (e.message || e));
  840.     }
  841. }

  843. // 执行所有示例
  844. runAllExamples();
复制代码



AIWROK, AIWROK软件
楼主新帖
楼主热帖
unto示例JavaScript的 try-catch-finally-throw用法nextnocontent

相关帖子
回复

使用道具 举报

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

本版积分规则

相关导读了
    采集亚马逊正版群发工具有没有？
    Apr.20旅行X心语今天来说说YYPOST新功能的一个灵活用法，采集亚马逊商品信息，并且获得排名的软件，亚马逊现在越来越多客户做，淘宝的水是越来越清了，以前做电商的客户，现在都转战到外国，最赚钱的要数一些客户往亚马逊里堆了吧，拿我这个YYPOST的客户，最多的是采集，分析排名，刷价格，刷数量，改价，刷访问量等等技术
    企业发展B2B网站有什么东东软件可以发呢
    标题企业发展网B2B软件，现在虽然B2B网站收录不错，可愁的是心急的人们，他们太想一口吃撑胖子了，发帖宣传虽然不能像佛系那样淡定，但也不能像跑火车那般急躁对待，自己内容不收录，完全是自己操作内容问题，可以参考一下别人的内容是怎么弄的，然后自己要试着转变，而且收录这个内容，常常会变化的，不是一种规则就吃到老
    搜房天下房聊软件哪一个好呢
    本帖最后由 发帖软件 于 2019-5-22 16:15 编辑 2搜房天下群发房聊信息软件，开始本来打算做58同城的，但发一个就要一次点触验证码，这就让人没有感觉到存在的价值了吧，都是卖二手房和新房的搜房天下倒是可以发即时聊天信息，也没有发现他这个网站有啥子限制，登陆一个搜房天下账号，然后采集回来分类列表的网址，然后就一
    大家坛有没有好用的群发工具下载呢
    当你的笑容给我礼貌的招呼，大家坛全自动发帖软件，宣传推广是一场持久战，总是有一些人把软件用了一天，或是几个小时，就觉得自己付出太多了，那加进来的粉丝，或是流量，应该是和宣传多少成正比的，其实没有这么便宜的事，就像很多阅读量超过一百万的视频，或是电影，真正会在屏幕打赏的人不会超过三千，真正大额打赏给主
    群发正版软件中国塑料网
    中国塑料网群发软件YYPOST脚本下载地址，这个网站会有一个很奇怪的问题就是你在首页登陆无半个验证码，但在登陆网址登陆就会有一个验证码，所以我们灵活一些，在首页登陆就不用输入验证码了哈。网站秒收录比较高，但发的都是五金和建筑行业，先前有很多人都是发土建工程的大公司操作的，现在这个网站专为那个行业诞生的吧。
    OpenStreetMap网站正版2019年发帖工具下载
    本帖最后由 发帖软件 于 2019-5-21 11:13 编辑 OpenStreetMap网站全自动群发，OpenStreetMapOpenStreetMap（简称OSM，中文是公开地图）是一个网上地图协作计划，目标是创造一个内容自由且能让所有人编辑的世界地图。有的人编辑地图然后等收录，有的人发日志等收录，我们这里也是利用地图日志做为宣传的目标，简单的脚本理
    搜房天下全自动收短信全自动识别验证码注册账号软件
    房天下自动注册机，这个脚本是前几天发房聊的脚本廷伸品种，这个脚本能做到自动注册账号，自动保存账号，自动发房聊的效果，不过今天我们主要说一说怎么注册账号写脚本吧，这个搜房天天下的账号，可以发提问，可以发房聊，发论坛，发博客，还有发个人中心页都是有秒收的效果的，这样就省去了去买号，去乱花钱的效果了吧，而
    企业邮箱安卓端有什么APP软件可以发的呢
    请输入标题企业邮箱安卓发发送邮箱脚本，这个脚本是利用企业邮箱进行群发的，全程是一种模拟手工操作的过程，所以封号是很少的，而且企业邮箱群发到普通QQ邮箱不容易进垃圾箱中的，所以这个脚本也是这样的原理，不过最好是利用一些多开器，登陆多点的QQ邮箱账号会比较流畅一些，然后用软件一个一个的切换APP进行群发邮件会
    头条留评论软件有没有好用的呢？
    今天整一个今日头条留言软件，对于留言YYPOST是优势是比较大的存在，因为他往往专注一些下拉定位的优点，像今日头条这样，还是需要一些特殊下拉定位的，因为他新闻有长有短，有图有视频的，所以综合起来定位是比较难的，如果用POST也不是很轻松可以破解他的加密参数。这个脚本也是有一个不好的地方就是换号会比较麻烦，您电
    单网页生成神器
    最近新技术，网页生成机占领了整个网络的半壁江山，效果很疯狂，虽然不知道能持续多久，作为开发软件的领头者，一直在找收录的方法，一直在努力创新着，一直被人模仿，却从没有被超越过，这个网页生成机，已经出来有一段时间了，一直没有拿出来分享，醉过醉过，它是利用的一些小小收录漏洞整的，您最好用一些老站域名，进行
关闭
本站开发自动发帖软件是目前效果最好的发贴工具，软件可以兼容所有的论坛，进行群发贴子，可以对各大论坛自主录制操作流程，自动识别 验证码，自动注册账号，自动群发贴子，还可以设置成自动抢沙发，是推广宣传的神级软件，软件可以兼容任何IE能顶贴发贴论坛，完全可以 做成论坛发贴软件，生成脚本，对各大论坛程序完美支持的。软件不但发的贴子收录快，而且只用法简单，使用方便，价格便宜，软件客服16 小时在线全程协助，为您的宣传保驾护航。用最少的投资，实现最大的收益，用最简单的方式，完全最复杂的操作。 QQ

Copyright © 2014 ( 京ICP备09078825号 )

Powered by Discuz! X3.2

群发软件发帖工具
快速回复 返回列表 返回顶部
本站自动发贴软件，是现在最流行的做脚本软件，这种发贴工具，不但发贴收录快，而且抢占好的先机，完全自由编辑，实现针对性群发模拟操作，软件可以顶贴，也可以发贴，可以兼容支持Discuz、PHPWind、Dvbbs三大主流论坛，有手机验证码收件，邮件收发的功能，支持验证码识别，注册问题识别，多线程任务，自动上传头像，自动激活注册邮件，兼容防注册插件，本站软件原创正版，更新效率最快的原创软件。 『网络推广软件』『自动发帖软件』『 自动发帖』