Go语言time库核心用法与避坑指南

package main
import (
    "fmt"
    "time"
)
func main() {
    now := time.Now() // 获取本地时区当前时间，包含完整时区信息
    fmt.Printf("当前时间（本地时区）：%v\n", now)
    fmt.Printf("当前时间（UTC时区）：%v\n", now.In(time.UTC))
    fmt.Printf("秒级时间戳：%d\n", now.Unix())
    fmt.Printf("纳秒级时间戳：%d\n", now.UnixNano())
    fmt.Printf("是否为零时间：%v\n", time.Time{}.IsZero())
    // 时间截断至小时（分、秒、纳秒归零）
    truncatedHour := now.Truncate(time.Hour)
    fmt.Printf("截断至小时：%v\n", truncatedHour)
}

package main
import (
    "fmt"
    "time"
)
func main() {
    now := time.Now()
    // 1. TTL转时间：计算缓存过期时间（TTL=30分钟）
    cacheTTL := 30 * time.Minute
    cacheExpire := now.Add(cacheTTL)
    fmt.Printf("缓存过期时间：%v\n", cacheExpire.Format("2006-01-02 15:04:05"))
    // 2. 时间转TTL：计算剩余存活时间
    remainingTTL := cacheExpire.Sub(now)
    fmt.Printf("缓存剩余TTL：%v\n", remainingTTL)
    // 3. 有效性校验：避免负TTL导致逻辑异常
    invalidTime := now.Add(-10 * time.Minute) // 过去的时间
    if !invalidTime.After(now) {
        fmt.Println("目标时间已过期，TTL为负")
        return
    }
}

package main
import (
    "fmt"
    "time"
)
func main() {
    now := time.Now()
    // 1. 时间格式化（Time → 字符串）
    layout1 := "2006-01-02 15:04:05"
    fmt.Printf("标准格式：%v\n", now.Format(layout1)) // 2026-01-28 14:30:00
    layout2 := "2006年01月02日 15时04分05秒 时区：Z07:00"
    fmt.Printf("带时区格式：%v\n", now.Format(layout2)) // 2026年01月28日 14时30分00秒 时区：+08:00
    layout3 := "01/02/2006 3:04 PM"
    fmt.Printf("12小时制格式：%v\n", now.Format(layout3)) // 01/28/2006 2:30 PM
    // 2. 时间解析（字符串 → Time）
    strTime := "2026-03-10 14:30:00"
    // Parse默认解析为UTC时区
    utcTime, err := time.Parse(layout1, strTime)
    if err != nil {
        fmt.Printf("解析失败：%v\n", err)
        return
    }
    fmt.Printf("解析结果（UTC）：%v\n", utcTime)
    // 解析为本地时区（推荐，适配业务场景）
    localTime, err := time.ParseInLocation(layout1, strTime, time.Local)
    if err != nil {
        fmt.Printf("本地时区解析失败：%v\n", err)
        return
    }
    fmt.Printf("解析结果（本地）：%v\n", localTime)
}

package main
import (
    "fmt"
    "time"
)
func main() {
    // 获取上海时区（Asia/Shanghai，UTC+8）
    shLoc, err := time.LoadLocation("Asia/Shanghai")
    if err != nil {
        fmt.Printf("加载上海时区失败：%v\n", err)
        return
    }
    shTime := time.Now().In(shLoc)
    fmt.Printf("上海时间：%v\n", shTime.Format("2006-01-02 15:04:05"))
    // 转换为纽约时间（America/New_York，UTC-5/UTC-4，自动适配夏令时）
    nyLoc, err := time.LoadLocation("America/New_York")
    if err != nil {
        fmt.Printf("加载纽约时区失败：%v\n", err)
        return
    }
    nyTime := shTime.In(nyLoc)
    fmt.Printf("纽约时间：%v\n", nyTime.Format("2006-01-02 15:04:05"))
}

package main
import (
    "fmt"
    "time"
)
func main() {
    // 场景1：延迟1秒执行任务
    timer1 := time.NewTimer(1 * time.Second)
    go func() {
        <-timer1.C // 阻塞等待定时器触发（通道接收时间）
        fmt.Println("1秒后执行单次任务")
    }()
    time.Sleep(1500 * time.Millisecond) // 等待任务执行完成
    // 场景2：停止定时器（避免未触发的定时器占用资源）
    timer2 := time.NewTimer(2 * time.Second)
    go func() {
        <-timer2.C
        fmt.Println("该任务不会执行")
    }()
    stopped := timer2.Stop()
    if stopped {
        fmt.Println("定时器已成功停止")
    }
    // 场景3：重置定时器（修改触发时间）
    timer3 := time.NewTimer(3 * time.Second)
    timer3.Reset(1 * time.Second) // 重置为1秒后触发
    <-timer3.C
    fmt.Println("定时器重置后，1秒触发")
}

package main
import (
    "fmt"
    "time"
)
func main() {
    // 创建每秒触发一次的定时器
    ticker := time.NewTicker(1 * time.Second)
    done := make(chan struct{}) // 用于控制任务停止的信号通道
    go func() {
        for {
            select {
            case <-done:
                ticker.Stop() // 停止定时器，释放资源
                fmt.Println("周期性任务已停止")
                return
            case t := <-ticker.C:
                fmt.Printf("周期性任务执行：%v\n", t.Format("15:04:05"))
            }
        }
    }()
    // 运行5秒后停止任务
    time.Sleep(5 * time.Second)
    close(done) // 关闭通道，发送停止信号
    time.Sleep(100 * time.Millisecond) // 等待goroutine退出
}

package main
import (
    "context"
    "fmt"
    "time"
)
// 模拟耗时接口请求（随机耗时500-1200毫秒）
func fetchData(ctx context.Context, url string) (string, error) {
    delay := time.Duration(500 + time.Now().UnixNano()%700) * time.Millisecond
    select {
    case <-time.After(delay):
        // 任务正常完成，返回结果
        return fmt.Sprintf("成功获取[%s]的核心数据", url), nil
    case <-ctx.Done():
        // 感知超时/取消信号，释放资源并返回错误
        return "", fmt.Errorf("请求[%s]失败：%v", url, ctx.Err())
    }
}
func main() {
    // 创建带1秒超时的Context（父Context为背景Context）
    ctx, cancel := context.WithTimeout(context.Background(), 1*time.Second)
    defer cancel() // 确保函数退出时释放Context资源，避免泄漏
    // 启动goroutine执行请求任务
    resultChan := make(chan string)
    errChan := make(chan error)
    go func() {
        res, err := fetchData(ctx, "https://example.com/api")
        if err != nil {
            errChan <- err
            return
        }
        resultChan <- res
    }()
    // 等待结果或超时
    select {
    case res := <-resultChan:
        fmt.Printf("任务成功：%v\n", res)
    case err := <-errChan:
        fmt.Printf("任务失败：%v\n", err) // 超时会打印：请求失败：context deadline exceeded
    }
}

package main
import (
    "fmt"
    "time"
)
// 模拟实际接口请求，可能返回错误
func requestAPI(url string) (string, error) {
    // 模拟接口耗时（100-1200毫秒）
    delay := time.Duration(100 + time.Now().UnixNano()%1100) * time.Millisecond
    time.Sleep(delay)
    // 模拟接口异常（耗时超过800毫秒视为超时错误）
    if delay > 800*time.Millisecond {
        return "", fmt.Errorf("接口响应超时（耗时：%v）", delay)
    }
    return fmt.Sprintf("请求[%s]成功，返回数据长度：1024", url), nil
}
// 带超时控制的接口请求封装
func requestWithTimeout(url string, timeout time.Duration) (string, error, time.Duration) {
    start := time.Now()
    ch := make(chan string)
    errCh := make(chan error)
    // 启动goroutine执行接口请求
    go func() {
        res, err := requestAPI(url)
        if err != nil {
            errCh <- err
            return
        }
        ch <- res
    }()
    // 等待结果、异常或超时
    select {
    case res := <-ch:
        cost := time.Since(start)
        return res, nil, cost
    case err := <-errCh:
        cost := time.Since(start)
        return "", err, cost
    case <-time.After(timeout):
        cost := time.Since(start)
        return "", fmt.Errorf("请求超时（设定超时时间：%v）", timeout), cost
    }
}
func main() {
    url := "https://example.com/user/api"
    timeout := 800 * time.Millisecond
    res, err, cost := requestWithTimeout(url, timeout)
    if err != nil {
        fmt.Printf("请求失败：%v，总耗时：%v\n", err, cost)
        return
    }
    fmt.Printf("请求成功：%v，总耗时：%v\n", res, cost)
}

package main
import (
    "fmt"
    "time"
)
func main() {
    now := time.Now()
    fmt.Printf("当前时间：%v\n", now.Format("2006-01-02 15:04:05"))
    // 1. 获取明天零点（当前时间+1天，再截断至天精度）
    tomorrowZero := now.AddDate(0, 0, 1).Truncate(24 * time.Hour)
    fmt.Printf("明天零点：%v\n", tomorrowZero.Format("2006-01-02 15:04:05"))
    // 2. 获取下月初零点（当前时间+1个月，构造当月1号0点）
    nextMonth := now.AddDate(0, 1, 0)
    nextMonthZero := time.Date(
        nextMonth.Year(),
        nextMonth.Month(),
        1,          // 每月1号
        0, 0, 0, 0, // 时、分、秒、纳秒归零
        now.Location(), // 保持与当前时间时区一致
    )
    fmt.Printf("下月初零点：%v\n", nextMonthZero.Format("2006-01-02 15:04:05"))
    // 扩展：获取本月最后一天23:59:59（下月初1号减1秒）
    thisMonthLastDay := nextMonthZero.Add(-1 * time.Second)
    fmt.Printf("本月最后一天（23:59:59）：%v\n", thisMonthLastDay.Format("2006-01-02 15:04:05"))
}