UNIX下C语言编程与实践36-UNIX 时钟：系统时间、高分辨率时间与日历时间的转换与使用

迎風吹頭髮2025-10-08 13:40

从时间格式定义到实战转换，掌握 UNIX 系统时间处理的核心逻辑

一、UNIX 系统中的三种核心时间格式

UNIX 系统为满足不同场景的时间需求（如计时、显示、高精度测量），定义了三种核心时间格式，每种格式有明确的存储结构和适用场景。理解它们的本质差异，是正确处理时间的基础。

1. 系统时间（System Time）：秒级时间戳

定义 ：又称"UNIX 时间戳（Unix Timestamp）"，表示从**1970年1月1日00:00:00 UTC（协调世界时）**到当前时刻的总秒数，不包含闰秒，是 UNIX 系统中最基础的时间表示方式。

存储类型 ：使用 time_t 类型存储（本质为 32 位或 64 位整数，现代系统多为 64 位，避免"2038年问题"）。

核心特点：

  • 取值为整数，便于计算时间差（如两个时间戳相减得到秒数差）；
  • 精度为秒，无法满足微秒级计时需求；
  • 与时区无关（UTC 时间），转换为本地时间需结合时区配置。

获取函数 ：time(time_t *t)，若 t 非 NULL，会将时间戳存入 *t，同时返回时间戳。

2. 高分辨率时间（High-Resolution Time）：微秒/纳秒级时间

定义：用于高精度时间测量的格式，精度可达微秒（μs）或纳秒（ns），弥补系统时间秒级精度的不足，适用于性能测试、高频事件计时等场景。

存储结构：

  • 微秒级：使用 struct timeval 结构，包含秒和微秒字段；
  • 纳秒级：使用 struct timespec 结构（POSIX.1b 标准），包含秒和纳秒字段。
c 复制代码 
// 微秒级时间结构（struct timeval）
#include <sys/time.h> 
struct timeval {
    time_t tv_sec;    // 秒数（与系统时间的秒数一致）
    suseconds_t tv_usec; // 微秒数（0 ~ 999999）
};

// 纳秒级时间结构（struct timespec）
struct timespec {
    time_t tv_sec;    // 秒数
    long tv_nsec;     // 纳秒数（0 ~ 999999999）
};

核心特点：

  • 精度高（微秒/纳秒级），适合测量短时间间隔（如函数执行耗时）；
  • 需通过专门函数获取，且部分嵌入式系统可能不支持纳秒级精度；
  • 不直接表示"绝对时间"，多用于计算"时间差"（如两次获取的高分辨率时间相减）。

获取函数 ：gettimeofday(struct timeval *tv, struct timezone *tz)（微秒级）、clock_gettime(clockid_t clk_id, struct timespec *ts)（纳秒级）。

3. 日历时间（Calendar Time）：可读时间格式

定义：将时间拆分为"年、月、日、时、分、秒"等人类可读的字段，适用于日志显示、界面展示等需要直观时间的场景。

存储结构 ：使用 struct tm 结构，定义在 <time.h> 中，包含完整的日历字段。

c 复制代码 
#include <time.h>

struct tm {
    int tm_sec;   // 秒（0 ~ 59）
    int tm_min;   // 分（0 ~ 59）
    int tm_hour;  // 时（0 ~ 23）
    int tm_mday;  // 日（1 ~ 31）
    int tm_mon;   // 月（0 ~ 11，0 表示1月）
    int tm_year;  // 年（从 1900 开始计算，如 2024 年为 2024-1900=124）
    int tm_wday;  // 星期（0 ~ 6，0 表示周日）
    int tm_yday;  // 年内天数（0 ~ 365）
    int tm_isdst; // 夏令时标志（正数表示启用，0 表示禁用，负数表示未知）
};

核心特点：

  • 字段直观，便于格式化显示（如"2024-09-30 15:30:00"）；
  • 字段取值有特殊规则（如月份从 0 开始、年份需加 1900），转换时易出错；
  • 通常由系统时间转换而来，无法直接获取，需借助 localtime 等函数。

转换函数 ：localtime(const time_t *timep)（系统时间→本地日历时间）、gmtime(const time_t *timep)（系统时间→UTC 日历时间）。

二、时间格式转换：核心函数与实战

UNIX 系统提供一系列标准函数，实现三种时间格式之间的转换。掌握这些函数的使用方法，能灵活应对"计时→显示→计算"等复杂时间处理场景。

1. 核心转换函数汇总

转换方向 函数原型 功能说明 返回值
系统时间 → 本地日历时间 struct tm *localtime(const time_t *timep); 将 UTC 系统时间转换为本地时区的日历时间（如北京时间），考虑夏令时 成功：指向 struct tm 的指针（静态内存）；失败：NULL
系统时间 → UTC 日历时间 struct tm *gmtime(const time_t *timep); 将 UTC 系统时间转换为 UTC 时区的日历时间（无夏令时） 成功：指向 struct tm 的指针（静态内存）；失败：NULL
日历时间 → 系统时间 time_t mktime(struct tm *tm); 将本地时区的日历时间转换为 UTC 系统时间，自动处理字段合法性（如月份 13 转为次年 1 月） 成功：对应的系统时间戳；失败：(time_t)-1
系统时间差计算 double difftime(time_t time1, time_t time0); 计算 time1 - time0 的时间差（单位：秒），处理 time_t 类型的溢出问题 时间差（double 类型，支持小数秒）
日历时间 → 字符串 char *strftime(char *str, size_t maxsize, const char *format, const struct tm *tm); 按 format 格式将日历时间转换为字符串（如"%Y-%m-%d %H:%M:%S"） 成功：写入 str 的字符数；失败：0（缓冲区不足）
字符串 → 日历时间 char *strptime(const char *str, const char *format, struct tm *tm); 按 format 格式从字符串中解析出日历时间，存入 tm 成功：指向字符串中未解析部分的指针；失败：NULL

2. 实战 1：系统时间与日历时间的转换

需求

获取当前系统时间，转换为本地日历时间并格式化显示；再将日历时间转换回系统时间，验证转换正确性。

代码格式化

c 复制代码 
#include <stdio.h>
#include <time.h>
#include <stdlib.h>

int main() {
    time_t now;
    struct tm *local_tm;
    char time_str[64];

    // 1. 获取当前系统时间（时间戳）
    now = time(NULL);
    printf("当前系统时间（时间戳）：%ld\n", now);

    // 2. 系统时间 → 本地日历时间
    local_tm = localtime(&now);
    if (local_tm == NULL) {
        perror("localtime 失败");
        exit(EXIT_FAILURE);
    }
    printf("\n本地日历时间（struct tm 字段）：\n");
    printf("年：%d（1900+%d）\n", local_tm->tm_year + 1900, local_tm->tm_year);
    printf("月：%d（%d+1）\n", local_tm->tm_mon + 1, local_tm->tm_mon);
    printf("日：%d\n", local_tm->tm_mday);
    printf("时：%d\n", local_tm->tm_hour);
    printf("分：%d\n", local_tm->tm_min);
    printf("秒：%d\n", local_tm->tm_sec);
    printf("星期：%d（0=周日）\n", local_tm->tm_wday);

    // 3. 日历时间 → 格式化字符串（YYYY-MM-DD HH:MM:SS）
    strftime(time_str, sizeof(time_str), "%Y-%m-%d %H:%M:%S", local_tm);
    printf("\n格式化本地时间：%s\n", time_str);

    // 4. 日历时间 → 系统时间（验证转换正确性）
    time_t converted_now = mktime(local_tm);
    if (converted_now == (time_t)-1) {
        perror("mktime 失败");
        exit(EXIT_FAILURE);
    }
    printf("\n日历时间转换回系统时间：%ld\n", converted_now);
    printf("转换前后差值：%f 秒（应为 0 或 1 秒内）\n", difftime(converted_now, now));

    return EXIT_SUCCESS;
}

编译与运行

bash 复制代码 
# 编译程序
gcc time_convert1.c -o time_convert1

# 运行程序
./time_convert1

示例输出

复制代码 
当前系统时间（时间戳）：1727679000

本地日历时间（struct tm 字段）：
年：2024（1900+124）
月：9（8+1）
日：30
时：15
分：30
秒：0
星期：1（0=周日）

格式化本地时间：2024-09-30 15:30:00

日历时间转换回系统时间：1727679000
转换前后差值：0.000000 秒（应为 0 或 1 秒内）

关键注意：

  • localtime 返回的指针指向静态内存，后续调用 localtime 或 gmtime 会覆盖该内存，多线程环境需使用线程安全版本 localtime_r；
  • struct tm 的 tm_year 需加 1900、tm_mon 需加 1 才是实际年份和月份，格式化时需特别注意；
  • mktime 会自动修正非法字段（如 tm_sec=61 会转为 tm_sec=1 且 tm_min 加 1），确保转换后时间合法。

3. 实战 2：高分辨率时间的获取与时间差计算

需求

使用高分辨率时间测量"循环 1000000 次空操作"的耗时，对比微秒级和纳秒级精度的测量结果。

代码内容

c 复制代码 
#include <stdio.h>
#include <sys/time.h>
#include <time.h>
#include <stdlib.h>

#define LOOP_COUNT 1000000 // 循环次数

// 微秒级时间差计算（单位：微秒）
long long timeval_diff(const struct timeval *start, const struct timeval *end) {
    return (end->tv_sec - start->tv_sec) * 1000000LL + (end->tv_usec - start->tv_usec);
}

// 纳秒级时间差计算（单位：纳秒）
long long timespec_diff(const struct timespec *start, const struct timespec *end) {
    return (end->tv_sec - start->tv_sec) * 1000000000LL + (end->tv_nsec - start->tv_nsec);
}

int main() {
    struct timeval tv_start, tv_end;
    struct timespec ts_start, ts_end;
    long long usec_diff;
    long long nsec_diff;
    int i;

    // 1. 微秒级计时
    if (gettimeofday(&tv_start, NULL) == -1) {
        perror("gettimeofday 失败");
        exit(EXIT_FAILURE);
    }

    // 循环空操作
    for (i = 0; i < LOOP_COUNT; i++);

    if (gettimeofday(&tv_end, NULL) == -1) {
        perror("gettimeofday 失败");
        exit(EXIT_FAILURE);
    }

    usec_diff = timeval_diff(&tv_start, &tv_end);
    printf("微秒级计时结果：\n");
    printf("循环 %d 次耗时：%lld 微秒 = %.3f 毫秒\n", LOOP_COUNT, usec_diff, usec_diff / 1000.0);

    // 2. 纳秒级计时（使用 CLOCK_MONOTONIC 时钟，不受系统时间调整影响）
    if (clock_gettime(CLOCK_MONOTONIC, &ts_start) == -1) {
        perror("clock_gettime 失败（可能不支持纳秒级）");
        exit(EXIT_FAILURE);
    }

    // 循环空操作
    for (i = 0; i < LOOP_COUNT; i++);

    if (clock_gettime(CLOCK_MONOTONIC, &ts_end) == -1) {
        perror("clock_gettime 失败");
        exit(EXIT_FAILURE);
    }

    nsec_diff = timespec_diff(&ts_start, &ts_end);
    printf("\n纳秒级计时结果：\n");
    printf("循环 %d 次耗时：%lld 纳秒 = %.3f 微秒 = %.3f 毫秒\n", LOOP_COUNT, nsec_diff, nsec_diff / 1000.0, nsec_diff / 1000000.0);

    return EXIT_SUCCESS;
}

编译与运行命令

bash 复制代码 
# 1. 编译程序（需链接 rt 库以支持 clock_gettime）
gcc time_highres.c -o time_highres -lrt

# 2. 运行程序
./time_highres

示例输出

复制代码 
微秒级计时结果：
循环 1000000 次耗时：1234 微秒 = 1.234 毫秒

纳秒级计时结果：
循环 1000000 次耗时：1234567 纳秒 = 1234.567 微秒 = 1.235 毫秒

关键注意：

  • gettimeofday 部分系统已标记为"过时"，推荐使用 clock_gettime，并指定时钟类型（如 CLOCK_MONOTONIC 为单调时钟，不受系统时间手动调整影响，适合计时）；
  • 纳秒级精度依赖硬件支持，部分虚拟机或嵌入式系统可能仅支持微秒级；
  • 计算时间差时需注意数据类型溢出（使用 long long 存储差值，避免 32 位整数溢出）。

4. 实战 3：字符串与日历时间的转换

需求

将字符串"2024-10-01 08:00:00"解析为日历时间，再转换为系统时间，计算与当前时间的差值。

c 复制代码 
#include <stdio.h>
#include <time.h>
#include <stdlib.h>
#include <string.h>

int main() {
    const char *time_str = "2024-10-01 08:00:00";
    struct tm target_tm = {0}; // 初始化，避免垃圾数据
    time_t target_time, now_time;
    double diff;

    // 1. 字符串 → 日历时间（按格式 "%Y-%m-%d %H:%M:%S" 解析）
    if (strptime(time_str, "%Y-%m-%d %H:%M:%S", &target_tm) == NULL) {
        perror("strptime 解析失败");
        exit(EXIT_FAILURE);
    }
    printf("解析后的日历时间：\n");
    printf("年：%d，月：%d，日：%d，时：%d，分：%d，秒：%d\n",
           target_tm.tm_year + 1900, target_tm.tm_mon + 1,
           target_tm.tm_mday, target_tm.tm_hour,
           target_tm.tm_min, target_tm.tm_sec);

    // 2. 日历时间 → 系统时间
    target_time = mktime(&target_tm);
    if (target_time == (time_t)-1) {
        perror("mktime 转换失败");
        exit(EXIT_FAILURE);
    }
    printf("\n目标时间（时间戳）：%ld\n", target_time);

    // 3. 计算与当前时间的差值
    now_time = time(NULL);
    diff = difftime(target_time, now_time);
    if (diff > 0) {
        printf("\n当前时间距离目标时间还有 %.0f 秒（约 %.0f 小时）\n", diff, diff / 3600);
    } else if (diff < 0) {
        printf("\n目标时间已过去 %.0f 秒（约 %.0f 小时）\n", -diff, -diff / 3600);
    } else {
        printf("\n当前时间与目标时间一致\n");
    }
    return EXIT_SUCCESS;
}

编译与运行示例

bash 复制代码 
# 编译程序
gcc time_str_parse.c -o time_str_parse

# 运行程序（假设当前时间为 2024-09-30 16:00:00）
./time_str_parse

# 输出示例
解析后的日历时间：
年：2024，月：10，日：1，时：8，分：0，秒：0
目标时间（时间戳）：1727721600
当前时间距离目标时间还有 16800 秒（约 4 小时）

关键注意：

  • strptime 的格式字符串必须与目标字符串完全匹配（如"%Y-%m-%d"对应"2024-10-01"，不能是"2024/10/01"），否则解析失败；
  • 解析前需初始化 struct tm（如 memset(&tm, 0, sizeof(tm))，避免未初始化字段（如 tm_isdst）导致转换错误；
  • difftime 支持小数秒，适合计算高精度时间差，且自动处理 time_t 类型的位数差异（32 位/64 位）。

三、时间处理的常见问题与解决方法

在 UNIX 时间处理中，易因字段规则、函数特性或平台差异导致错误。以下是高频问题及对应的解决方法：

struct tm 字段规则特殊：

  • tm_year 是"当前年份 - 1900"（2024-1900=124）；

  • tm_mon 从 0 开始（9 月为 8）；

  • 未对字段进行修正直接显示

常见问题 问题现象 原因分析 解决方法
日历时间字段取值错误（如年份显示为 124） 显示年份为 124 而非 2024，月份为 8 而非 9 1. 显示年份时需加 1900（tm.tm_year + 1900）； 2. 显示月份时需加 1（tm.tm_mon + 1）； 3. 推荐使用 strftime 自动格式化（如"%Y-%m-%d"直接生成正确年份和月份），避免手动计算。
localtime 线程不安全导致数据错乱 多线程程序中，不同线程调用 localtime 后，获取的日历时间字段混乱（如年份错误、月份异常） localtime 返回的指针指向全局静态内存，多线程同时调用时会覆盖该内存，导致数据竞争和错乱 1. 多线程环境中，使用线程安全版本 localtime_r(const time_t *timep, struct tm *result)，将结果存入线程私有变量； 2. 若系统不支持 localtime_r，可通过互斥锁（如 pthread_mutex_t）保护 localtime 调用，确保同一时间仅一个线程使用； 3. 示例： struct tm tm; localtime_r(&now, &tm); // 线程安全
高分辨率时间函数平台兼容性问题 在嵌入式系统或旧版本 UNIX 中，clock_gettime 未定义，或 gettimeofday 调用失败 1. clock_gettime 是 POSIX.1b 标准函数，部分老旧系统（如 Solaris 8）不支持； 2. gettimeofday 在部分系统（如 Linux 3.3+）已标记为"过时"，但仍可使用； 3. 嵌入式系统可能未实现微秒/纳秒级时间接口 1. 增加平台兼容性判断，优先使用 clock_gettime，不支持时降级为 gettimeofday； 2. 示例代码： #ifdef _POSIX_TIMERS clock_gettime(CLOCK_MONOTONIC, &ts); #else gettimeofday(&tv, NULL); #endif 3. 嵌入式系统若无高精度接口，可使用 clock() 函数（精度为时钟周期，需结合 CLOCKS_PER_SEC 转换）。
mktime 转换失败（返回 (time_t)-1） 将 struct tm 转换为 time_t 时返回 -1，无法获取系统时间 1. struct tm 字段非法（如 tm_mday=32、tm_hour=25）； 2. 未初始化 struct tm，存在垃圾数据（如 tm_isdst 为负数且系统无法判断夏令时）； 3. 转换后的时间超出 time_t 类型的取值范围（如 32 位 time_t 无法表示 2038 年后的时间） 1. 确保 struct tm 字段合法： - tm_sec：0~59； - tm_min：0~59； - tm_hour：0~23； - tm_mday：1~31（需与月份匹配）； - tm_mon：0~11； - tm_year：0~（取决于 time_t 位数）； 2. 初始化 struct tm（如 memset(&tm, 0, sizeof(tm))），明确设置 tm_isdst（0 表示禁用夏令时）； 3. 使用 64 位 time_t（编译时添加 -D_FILE_OFFSET_BITS=64），避免 2038 年问题。
strftime 缓冲区溢出 调用 strftime 后，目标缓冲区 str 内容错乱，或程序崩溃 1. strftime 的 maxsize 参数小于格式化后字符串的长度，导致缓冲区溢出； 2. 未检查 strftime 的返回值，未发现缓冲区不足问题 1. 合理设置缓冲区大小：根据格式化字符串估算最大长度（如"%Y-%m-%d %H:%M:%S"最大长度为 20，缓冲区设为 32 字节足够）； 2. 检查 strftime 的返回值：若返回 0，说明缓冲区不足，需增大缓冲区； 3. 示例： char buf[64]; if (strftime(buf, sizeof(buf), "%Y-%m-%d %H:%M:%S", &tm) == 0) { fprintf(stderr, "缓冲区不足\n"); exit(EXIT_FAILURE); }

四、时间格式的适用场景与时间戳的应用

三种时间格式各有优势，需根据具体场景选择；同时，时间戳作为 UNIX 时间的核心表示，在日志、同步等场景中有广泛应用。

1. 时间格式的适用场景选择

  • 系统时间（时间戳）：适合计时与存储
    • 场景：计算时间差（如任务执行耗时）、存储时间（如数据库中记录数据创建时间）、网络传输时间（如 API 接口传递时间戳）；
    • 优势：存储占用小（8 字节）、计算高效（整数相减）、与时区无关（避免跨时区转换问题）；
    • 示例：数据库表中用 BIGINT 类型存储时间戳，记录用户注册时间。
  • 高分辨率时间：适合高精度计时
    • 场景：性能测试（如函数执行耗时、代码块效率对比）、高频事件间隔测量（如网络数据包接收间隔）、实时系统任务调度；
    • 优势：精度高（微秒/纳秒级）、不受系统时间调整影响（使用 CLOCK_MONOTONIC 时钟）；
    • 示例：测量 sort 函数对 100 万条数据的排序耗时，精确到微秒。
  • 日历时间：适合显示与交互
    • 场景：日志显示（如应用日志中的"2024-09-30 15:30:00 [INFO] 服务启动"）、用户界面展示（如客户端显示文件修改时间）、时间字符串解析（如解析用户输入的预约时间）；
    • 优势：人类可读、支持灵活格式化（如"%Y年%m月%d日 %H:%M"）；
    • 示例：Web 服务器日志中，将请求时间格式化为"[30/Sep/2024:15:30:00 +0800]"输出。

2. 时间戳的典型应用场景

时间戳（系统时间）作为 UNIX 系统中时间的"统一语言"，在多个领域有不可替代的作用：

（1）日志记录与审计

应用程序日志中，每条日志需包含时间戳，用于定位问题发生时间、追溯事件顺序。例如：

c 复制代码 
// 日志记录示例（包含时间戳和格式化时间）
void log_info(const char *msg) {
    time_t now = time(NULL);
    struct tm *tm = localtime(&now);
    char time_str[64];
    strftime(time_str, sizeof(time_str), "%Y-%m-%d %H:%M:%S", tm);
    printf("[%s] [INFO] [timestamp: %ld] %s\n", time_str, now, msg);
}

// 调用日志函数
log_info("User 'bill' logged in successfully");

// 输出示例
[2024-09-30 15:30:00] [INFO] [timestamp: 1727679000] User 'bill' logged in successfully

优势：时间戳便于日志分析工具（如 ELK）排序和筛选，格式化时间便于人工阅读。

（2）数据同步与一致性

分布式系统中，通过时间戳实现数据同步（如判断数据版本新旧）、避免重复处理（如消息队列去重）。例如：

  • 数据库主从同步：主库记录每条数据的修改时间戳，从库仅同步时间戳大于本地最大时间戳的数据；
  • API 接口幂等性：客户端请求时携带时间戳，服务端记录已处理的时间戳，避免重复处理同一请求；
  • 文件同步：对比本地文件和远程文件的修改时间戳，仅同步时间戳更新的文件。

优势：时间戳全局唯一且递增，无需复杂的版本号机制，简化同步逻辑。

（3）缓存控制与过期处理

缓存系统中，用时间戳控制缓存过期（如设置缓存有效期为 3600 秒），或记录缓存更新时间。例如：

c 复制代码 
// 缓存结构体（包含数据和过期时间戳）
typedef struct {
    char data[1024];
    time_t expire_time; // 过期时间戳（当前时间+3600）
} CacheItem;

// 检查缓存是否过期
int is_cache_expired(const CacheItem *item) {
    time_t now = time(NULL);
    return (now > item->expire_time) ? 1 : 0;
}

// 设置缓存（有效期 1 小时）
void set_cache(CacheItem *item, const char *data) {
    strncpy(item->data, data, sizeof(item->data)-1);
    item->expire_time = time(NULL) + 3600; // 1 小时后过期
}

优势 ：时间戳计算过期逻辑简单（now > expire_time），无需依赖复杂的定时器。

UNIX 系统中三种核心时间格式（系统时间、高分辨率时间、日历时间）的定义、转换方法和适用场景，结合实战案例演示了时间处理的关键函数，同时总结了常见问题与解决方法。时间处理是 UNIX 编程的基础技能，需重点掌握 struct tm 字段规则、线程安全函数使用和平台兼容性处理。

在实际开发中，需根据场景选择合适的时间格式：计时用高分辨率时间，存储用系统时间，显示用日历时间；同时，充分利用时间戳的特性，简化日志、同步和缓存等场景的逻辑。通过规范的时间处理，可提升程序的可读性、可维护性和跨平台兼容性。

相关推荐
Yupureki2 小时前
从零开始的C++学习生活 5:内存管理和模板初阶
c语言·c++·学习·visual studio
为java加瓦3 小时前
IO多路复用的两种触发机制：ET和LT触发机制。以及IO操作是异步的还是同步的理解
java·服务器·网络
毕业设计论文3 小时前
个人备忘录的设计与实现
运维·服务器·网络
SccTsAxR4 小时前
[初学C语言]关于scanf和printf函数
c语言·开发语言·经验分享·笔记·其他
尹蓝锐5 小时前
在学校Linux服务器上配置go语言环境
linux·运维·服务器
爱编程的鱼6 小时前
Python 与 C++、C 语言的区别及选择指南
c语言·开发语言·c++
运维闲章印时光6 小时前
网络断网、环路、IP 冲突？VRRP+MSTP+DHCP 联动方案一次性解决
运维·服务器·开发语言·网络·php
Arlene6 小时前
IP 协议的相关特性
服务器·网络·tcp/ip
shylyly_6 小时前
Linux-＞ TCP 编程2
linux·服务器·网络·tcp/ip·松耦合·command程序
热门推荐
01KGG转MP3工具|非KGM文件|解密音频02GitHub 镜像站点03UV安装并设置国内源04BongoCat - 跨平台键盘猫动画工具05jdk21下载、安装（Windows、Linux、macOS）06两千字总结：Codex 国内如何安装和使用的教程，以及如何设置中文回答07Linux下V2Ray安装配置指南08零基础搭建赛博朋克个人主页：蓝耘Claude Code完整实战教程0946个Nano-banana 精选提示词，持续更新中10adb安装教程（附adb命令大全详解）adb环境配置教程