CN·语言

时间

时间戳、单调时钟与 strftime 风格格式化。

导入写法CN

导入 时间::{当前时间戳, 单调时钟毫秒, 格式化时间};

时间函数

当前时间戳 为 Unix 纪元秒(UTC);单调时钟毫秒 单调不减,测耗时必须用它(墙钟可能回拨)。格式化时间 用 strftime 格式串、本地时区。

时间函数.cnCN

导入 时间::{当前时间戳, 单调时钟毫秒, 格式化时间};

函数 主() -> 整32 {
    整64 起 = 单调时钟毫秒();
    整64 总 = 0;
    整64 i = 0;
    当 (i < 1000000) { 总 = 总 + i; i++; }
    打印("计时非负:", 单调时钟毫秒() >= 起);
    结果<字符串, 整32> 文 = 格式化时间(当前时间戳(), "%Y");
    如果 (文.正常) { 打印("年份四位:", 字符串长度(文.值) == 4); }
    否则 { 打印("格式化失败"); }
    返回 0;
}

输出:计时非负:真 年份四位:真

当前时间戳

函数 当前时间戳() -> 整64

Unix 纪元起的秒数(UTC 墙钟)。

返回 秒级时间戳。

主.cnCN

函数 主() -> 整32 {
    打印("===== 时间库(Task 6.5)=====");

    // ==================== 1. 当前时间戳(秒级,递增) ====================
    整64 戳1 = 时间::当前时间戳();
    整64 戳2 = 时间::当前时间戳();
    打印("时间戳合理: ", 戳2 >= 戳1);       // 1(第二次 ≥ 第一次)
    打印("时间戳大于0: ", 戳1 > 0);         // 1(Unix 纪元后)

    // ==================== 2. 单调时钟毫秒(递增) ====================
    整64 毫1 = 时间::单调时钟毫秒();
    整64 毫2 = 时间::单调时钟毫秒();
    打印("时钟毫秒合理: ", 毫2 >= 毫1);     // 1

    // ==================== 3. 格式化时间 ====================
    // "%Y-%m-%d" → "2026-08-14" 形态:长度=10、第4/7位是 '-'
    字符串 日期 = 时间::格式化时间(戳1, "%Y-%m-%d");
    如果 (日期 != 无) {
        布尔 长度对 = 字符串长度(日期) == 10;
        // 字符串比较运算符(==)规格书未定义——用 字符串比较 内置(相等返回 真)
        字符串 分隔符1 = 字符串子串(日期, 4, 1);
        字符串 分隔符2 = 字符串子串(日期, 7, 1);
        布尔 分隔对 = 字符串比较(分隔符1, "-") && 字符串比较(分隔符2, "-");
        打印("日期长度=10: ", 长度对);       // 1
        打印("日期分隔符: ", 分隔对);         // 1
        // 日期内容随运行日期变化(E2E 固定文本比对不能打印实际值)
    } 否则 {
        打印("格式化时间失败");
    }

    // "%Y" → 4 位数字年份(内容随年份变化,只断言长度)
    字符串 年 = 时间::格式化时间(戳1, "%Y");
    如果 (年 != 无) {
        打印("年份长度=4: ", 字符串长度(年) == 4);  // 1
    } 否则 {
        打印("格式化年份失败");
    }

    // 非法时间戳(负数)→ nullptr → 失败
    字符串 非法 = 时间::格式化时间(-1, "%Y");
    如果 (非法 != 无) {
        打印("非法时间戳处理: ", 非法);
    } 否则 {
        打印("非法时间戳失败");              // 失败
    }

    打印("===== 时间库测试完成 =====");
    返回 0;
}

输出:===== 时间库(Task 6.5)===== 时间戳合理: 真 时间戳大于0: 真 时钟毫秒合理: 真 日期长度=10: 真 日期分隔符: 真 年份长度=4: 真 非法时间戳失败 ===== 时间库测试完成 =====

单调时钟毫秒

函数 单调时钟毫秒() -> 整64

单调不减的毫秒时钟——耗时测量唯一正确选择(墙钟可能因校时回拨)。两次取值相减即耗时。

返回 单调毫秒数。

主.cnCN

函数 主() -> 整32 {
    打印("===== 时间库(Task 6.5)=====");

    // ==================== 1. 当前时间戳(秒级,递增) ====================
    整64 戳1 = 时间::当前时间戳();
    整64 戳2 = 时间::当前时间戳();
    打印("时间戳合理: ", 戳2 >= 戳1);       // 1(第二次 ≥ 第一次)
    打印("时间戳大于0: ", 戳1 > 0);         // 1(Unix 纪元后)

    // ==================== 2. 单调时钟毫秒(递增) ====================
    整64 毫1 = 时间::单调时钟毫秒();
    整64 毫2 = 时间::单调时钟毫秒();
    打印("时钟毫秒合理: ", 毫2 >= 毫1);     // 1

    // ==================== 3. 格式化时间 ====================
    // "%Y-%m-%d" → "2026-08-14" 形态:长度=10、第4/7位是 '-'
    字符串 日期 = 时间::格式化时间(戳1, "%Y-%m-%d");
    如果 (日期 != 无) {
        布尔 长度对 = 字符串长度(日期) == 10;
        // 字符串比较运算符(==)规格书未定义——用 字符串比较 内置(相等返回 真)
        字符串 分隔符1 = 字符串子串(日期, 4, 1);
        字符串 分隔符2 = 字符串子串(日期, 7, 1);
        布尔 分隔对 = 字符串比较(分隔符1, "-") && 字符串比较(分隔符2, "-");
        打印("日期长度=10: ", 长度对);       // 1
        打印("日期分隔符: ", 分隔对);         // 1
        // 日期内容随运行日期变化(E2E 固定文本比对不能打印实际值)
    } 否则 {
        打印("格式化时间失败");
    }

    // "%Y" → 4 位数字年份(内容随年份变化,只断言长度)
    字符串 年 = 时间::格式化时间(戳1, "%Y");
    如果 (年 != 无) {
        打印("年份长度=4: ", 字符串长度(年) == 4);  // 1
    } 否则 {
        打印("格式化年份失败");
    }

    // 非法时间戳(负数)→ nullptr → 失败
    字符串 非法 = 时间::格式化时间(-1, "%Y");
    如果 (非法 != 无) {
        打印("非法时间戳处理: ", 非法);
    } 否则 {
        打印("非法时间戳失败");              // 失败
    }

    打印("===== 时间库测试完成 =====");
    返回 0;
}

输出:===== 时间库(Task 6.5)===== 时间戳合理: 真 时间戳大于0: 真 时钟毫秒合理: 真 日期长度=10: 真 日期分隔符: 真 年份长度=4: 真 非法时间戳失败 ===== 时间库测试完成 =====

格式化时间

函数 格式化时间(整64 时间戳, 字符串 格式) -> 结果<字符串, 整32>

按 strftime 格式串格式化时间戳为本地时间字符串。常用占位符:%Y 年 %m 月 %d 日 %H 时 %M 分 %S 秒。

参数类型说明
时间戳整64Unix 秒级时间戳
格式字符串strftime 格式串

返回 正常(格式化串)(拥有型);非法 → 错误(6)。

主.cnCN

函数 主() -> 整32 {
    打印("===== 时间库(Task 6.5)=====");

    // ==================== 1. 当前时间戳(秒级,递增) ====================
    整64 戳1 = 时间::当前时间戳();
    整64 戳2 = 时间::当前时间戳();
    打印("时间戳合理: ", 戳2 >= 戳1);       // 1(第二次 ≥ 第一次)
    打印("时间戳大于0: ", 戳1 > 0);         // 1(Unix 纪元后)

    // ==================== 2. 单调时钟毫秒(递增) ====================
    整64 毫1 = 时间::单调时钟毫秒();
    整64 毫2 = 时间::单调时钟毫秒();
    打印("时钟毫秒合理: ", 毫2 >= 毫1);     // 1

    // ==================== 3. 格式化时间 ====================
    // "%Y-%m-%d" → "2026-08-14" 形态:长度=10、第4/7位是 '-'
    字符串 日期 = 时间::格式化时间(戳1, "%Y-%m-%d");
    如果 (日期 != 无) {
        布尔 长度对 = 字符串长度(日期) == 10;
        // 字符串比较运算符(==)规格书未定义——用 字符串比较 内置(相等返回 真)
        字符串 分隔符1 = 字符串子串(日期, 4, 1);
        字符串 分隔符2 = 字符串子串(日期, 7, 1);
        布尔 分隔对 = 字符串比较(分隔符1, "-") && 字符串比较(分隔符2, "-");
        打印("日期长度=10: ", 长度对);       // 1
        打印("日期分隔符: ", 分隔对);         // 1
        // 日期内容随运行日期变化(E2E 固定文本比对不能打印实际值)
    } 否则 {
        打印("格式化时间失败");
    }

    // "%Y" → 4 位数字年份(内容随年份变化,只断言长度)
    字符串 年 = 时间::格式化时间(戳1, "%Y");
    如果 (年 != 无) {
        打印("年份长度=4: ", 字符串长度(年) == 4);  // 1
    } 否则 {
        打印("格式化年份失败");
    }

    // 非法时间戳(负数)→ nullptr → 失败
    字符串 非法 = 时间::格式化时间(-1, "%Y");
    如果 (非法 != 无) {
        打印("非法时间戳处理: ", 非法);
    } 否则 {
        打印("非法时间戳失败");              // 失败
    }

    打印("===== 时间库测试完成 =====");
    返回 0;
}

输出:===== 时间库(Task 6.5)===== 时间戳合理: 真 时间戳大于0: 真 时钟毫秒合理: 真 日期长度=10: 真 日期分隔符: 真 年份长度=4: 真 非法时间戳失败 ===== 时间库测试完成 =====