AIWROK软件时间方法集合小结

QQ896757558

AIWROK软件时间方法集合小结

http://www.postbbs.com/template/ ... mg/codebg.gif"); color: rgb(102, 102, 102); zoom: 1;">

//适用本文档ES5系统安卓 JavaScript引擎Rhino

const 时间 = {
/**
* 获取当前时间戳
* @returns {number} 返回当前的时间戳（毫秒）
* @example
* var timestamp = 时间.当前时间戳();
* printl(timestamp); // 输出类似: 1677649423000
*/
当前时间戳: function() {
return Date.now();
},

/**
* 格式化时间为指定格式
* @param {Date|number|string} date 要格式化的日期，可以是Date对象、时间戳或日期字符串
* @param {string} format 输出格式，默认为"YYYY-MM-DD HH:mm:ss"
* @returns {string|null} 成功返回格式化后的时间字符串，失败返回null
* @example
* // 示例1：格式化当前时间
* var now = new Date();
* var str = 时间.格式化(now);
* printl(str); // 输出: "2024-01-20 15:30:45"
*
* // 示例2：自定义格式
* var str = 时间.格式化(new Date(), "YYYY年MM月DD日");
* printl(str); // 输出: "2024年01月20日"
*/
格式化: function(date, format) {
try {
// 设置默认格式
format = format || "YYYY-MM-DD HH:mm:ss";

// 参数验证
if (!date) {
console.error("[时间.格式化] 错误：date参数未定义");
return null;
}

// 转换为Date对象
var dateObj;
if (date instanceof Date) {
dateObj = date;
} else if (typeof date === 'number' || typeof date === 'string') {
dateObj = new Date(date);
} else {
console.error("[时间.格式化] 错误：date参数类型不正确");
return null;
}

// 验证日期是否有效
if (isNaN(dateObj.getTime())) {
console.error("[时间.格式化] 错误：无效的日期");
return null;
}

// 格式化函数
var formatMap = {
YYYY: dateObj.getFullYear(),
MM: String(dateObj.getMonth() + 1).padStart(2, '0'),
DD: String(dateObj.getDate()).padStart(2, '0'),
HH: String(dateObj.getHours()).padStart(2, '0'),
mm: String(dateObj.getMinutes()).padStart(2, '0'),
ss: String(dateObj.getSeconds()).padStart(2, '0'),
SSS: String(dateObj.getMilliseconds()).padStart(3, '0')
};

return format.replace(/YYYY|MM|DD|HH|mm|ss|SSS/g, function(match) {
return formatMap[match];
});
} catch (error) {
console.error("[时间.格式化] 错误：" + error);
return null;
}
},

/**
* 计算两个日期之间的时间差
* @param {Date|number|string} date1 第一个日期
* @param {Date|number|string} date2 第二个日期
* @param {string} unit 返回的时间单位，可选值：years, months, days, hours, minutes, seconds, milliseconds
* @returns {number|null} 成功返回时间差，失败返回null
* @example
* // 示例1：计算两个日期之间的天数差
* var date1 = new Date('2024-01-01');
* var date2 = new Date('2024-02-01');
* var diff = 时间.时间差(date1, date2, 'days');
* printl(diff); // 输出: 31
*
* // 示例2：计算小时差
* var diff = 时间.时间差(date1, date2, 'hours');
* printl(diff); // 输出: 744
*/
时间差: function(date1, date2, unit) {
try {
// 设置默认单位
unit = unit || "milliseconds";

// 参数验证
if (!date1 || !date2) {
console.error("[时间.时间差] 错误：日期参数未定义");
return null;
}

// 转换为Date对象
var d1 = new Date(date1);
var d2 = new Date(date2);

// 验证日期是否有效
if (isNaN(d1.getTime()) || isNaN(d2.getTime())) {
console.error("[时间.时间差] 错误：无效的日期");
return null;
}

// 计算毫秒差值
var diff = Math.abs(d2.getTime() - d1.getTime());

// 根据单位转换
var conversions = {
milliseconds: 1,
seconds: 1000,
minutes: 1000 * 60,
hours: 1000 * 60 * 60,
days: 1000 * 60 * 60 * 24,
months: 1000 * 60 * 60 * 24 * 30.436875, // 平均每月天数
years: 1000 * 60 * 60 * 24 * 365.25 // 平均每年天数
};

if (!conversions[unit]) {
console.error("[时间.时间差] 错误：无效的时间单位");
return null;
}

return Math.floor(diff / conversions[unit]);
} catch (error) {
console.error("[时间.时间差] 错误：" + error);
return null;
}
}
};

// 示例1：获取当前时间戳
var timestamp = 时间.当前时间戳();
printl("当前时间戳：", timestamp);

// 示例2：格式化当前时间
var now = new Date();
var formattedDate = 时间.格式化(now);
printl("格式化当前时间：", formattedDate);

// 示例3：自定义格式化
var customFormat = 时间.格式化(now, "YYYY年MM月DD日 HH时mm分ss秒");
printl("自定义格式：", customFormat);

// 示例4：计算时间差
var date1 = new Date('2024-01-01');
var date2 = new Date('2024-02-01');
var daysDiff = 时间.时间差(date1, date2, 'days');
printl("相差天数：", daysDiff);

var hoursDiff = 时间.时间差(date1, date2, 'hours');
printl("相差小时：", hoursDiff);

1. 基础时间获取方法

/**
 * 获取当前时间戳
 */
当前时间戳: function() {
    return Date.now();
}

这是最基础的方法，返回当前时间的毫秒级时间戳。常用于记录时间点或计算时间差。

/**
 * 获取当前时间
 */
当前时间: function() {
    return new Date();
}

返回当前的Date对象，可以用于后续的时间处理。

2. 时间等待和休眠方法

/**
 * 休眠指定的毫秒数（同步方式）
 */
休眠: function(ms) {
  try {
    // 参数验证
    if (typeof ms !== 'number' || ms < 0) {
      console.error("[时间.休眠] 错误：参数必须是非负数");
      return;
    }

    var start = new Date().getTime();
    while (new Date().getTime() < start + ms) {
      // 空循环等待
    }
  } catch (error) {
    console.error("[时间.休眠] 错误：" + error);
  }
}

这是一个同步的休眠方法，会阻塞执行指定的毫秒数。注意：这会阻塞主线程。

/**
 * 等待指定时间（异步方式）
 */
等待指定时间: function(ms) {
  try {
    if (typeof ms !== 'number' || ms < 0) {
      console.error("[时间.等待指定时间] 错误：ms必须是非负数");
      return Promise.reject("ms必须是非负数");
    }

    return new Promise(function(resolve) {
      setTimeout(resolve, ms);
    });
  } catch (error) {
    console.error("[时间.等待指定时间] 错误：" + error);
    return Promise.reject(error);
  }
}

这是异步版本的等待，返回Promise，不会阻塞主线程。推荐使用这个方法而不是休眠。

3. 时间格式化和转换

/**
 * 格式化时间为指定格式
 */
格式化: function(date, format) {
  try {
    format = format || "YYYY-MM-DD HH:mm:ss";

    // ... 参数验证 ...

    var formatMap = {
      YYYY: dateObj.getFullYear(),
      MM: String(dateObj.getMonth() + 1).padStart(2, '0'),
      DD: String(dateObj.getDate()).padStart(2, '0'),
      HH: String(dateObj.getHours()).padStart(2, '0'),
      mm: String(dateObj.getMinutes()).padStart(2, '0'),
      ss: String(dateObj.getSeconds()).padStart(2, '0'),
      SSS: String(dateObj.getMilliseconds()).padStart(3, '0')
    };

    return format.replace(/YYYY|MM|DD|HH|mm|ss|SSS/g, function(match) {
      return formatMap[match];
    });
  } catch (error) {
    console.error("[时间.格式化] 错误：" + error);
    return null;
  }
}

这个方法可以将日期格式化为指定的字符串格式。支持的格式标记：

• YYYY: 年份
• MM: 月份（01-12）
• DD: 日期（01-31）
• HH: 小时（00-23）
• mm: 分钟（00-59）
• ss: 秒（00-59）
• SSS: 毫秒（000-999）

4. 时间组件获取

获取年: function(date) {
  try {
    var dateObj = date ? new Date(date) : new Date();
    return dateObj.getFullYear();
  } catch (error) {
    console.error("[时间.获取年] 错误：" + error);
    return null;
  }
}

类似的还有获取月、获取时、获取分、获取秒、获取毫秒方法，它们都：

• 接受可选的日期参数，不传则使用当前时间
• 返回对应的时间组件
• 包含错误处理

5. 高级功能

/**
 * 倒计时秒
 */
倒计时秒: function(seconds, callback, doneCallback) {
  try {
    var remainingSeconds = seconds;

    // 立即执行一次回调
    if (typeof callback === 'function') {
      callback(remainingSeconds);
    }

    var intervalId = setInterval(function() {
      remainingSeconds--;

      if (typeof callback === 'function') {
        callback(remainingSeconds);
      }

      if (remainingSeconds <= 0) {
        clearInterval(intervalId);
        if (typeof doneCallback === 'function') {
          doneCallback();
        }
      }
    }, 1000);

    return intervalId;
  } catch (error) {
    console.error("[时间.倒计时秒] 错误：" + error);
    return null;
  }
}

这是一个倒计时功能：

• 每秒调用一次callback
• 传入剩余秒数
• 倒计时结束时调用doneCallback
• 返回intervalId供取消使用

/**
 * 等待指定字符出现
 */
等待指定字符出现: function(checkFn, timeout, interval) {
  try {
    if (typeof checkFn !== 'function') {
      console.error("[时间.等待指定字符出现] 错误：checkFn必须是函数");
      return Promise.reject("checkFn必须是函数");
    }

    timeout = timeout || 5000;
    interval = interval || 100;

    return new Promise(function(resolve, reject) {
      if (checkFn()) {
        resolve();
        return;
      }

      var startTime = Date.now();
      var intervalId = setInterval(function() {
        if (Date.now() - startTime > timeout) {
          clearInterval(intervalId);
          reject("等待超时");
          return;
        }

        if (checkFn()) {
          clearInterval(intervalId);
          resolve();
        }
      }, interval);
    });
  } catch (error) {
    console.error("[时间.等待指定字符出现] 错误：" + error);
    return Promise.reject(error);
  }
}

这是一个高级的等待功能：

• 接受一个检查函数
• 定期检查条件是否满足
• 支持超时设置
• 返回Promise

6. 错误处理特点

所有方法都采用了统一的错误处理模式：

1. try-catch 包裹主要逻辑
2. 详细的参数验证
3. 统一的错误日志格式
4. 失败时返回null或reject Promise

7. 使用示例

// 基础用法
var now = 时间.当前时间();
var formatted = 时间.格式化(now, "YYYY年MM月DD日");

// 异步等待
时间.等待指定时间(1000).then(function() {
  console.log("1秒后执行");
});

// 倒计时
时间.倒计时秒(5, 
        function(remain) { console.log(remain + "秒"); },
        function() { console.log("倒计时结束"); }
       );

// 等待条件
时间.等待指定字符出现(
  function() { return 屏幕文字.indexOf("成功") >= 0; },
  5000
).then(function() {
  console.log("找到了");
});

这个时间工具库设计得非常实用，既有基础的时间处理功能，也有高级的异步等待功能，错误处理完善，使用方便。您觉得还需要我解释哪部分更详细吗？