Golang中如何将字符串转换为time.Time（时间戳）

Golang中如何将字符串转换为time.Time（时间戳） 你好，

我想将任何输入的字符串转换为 time.Time 格式，例如：

给定的字符串可能是“27/12/2021 18:19”或“27/12/2021 18:19:02” 转换为“27/12/2021 18:19:00”或“27/12/2021 18:19:02”。

我使用了 time.Parse(layout, given_string)，其中 layout = “02/01/2006 15:04:05”

但它在第二种情况下工作正常，而在第一种情况下返回解析错误。

在 Go 中，是否可以通过为缺失的部分添加 0 来将任何字符串转换为给定的布局？

提前感谢


更多关于Golang中如何将字符串转换为time.Time（时间戳）的实战教程也可以访问 https://www.itying.com/category-94-b0.html

5 回复

先用一种格式解析，如果失败，再尝试另一种格式。

更多关于Golang中如何将字符串转换为time.Time（时间戳）的实战系列教程也可以访问 https://www.itying.com/category-94-b0.html


我们能否在单个case中实现这一点？

当我需要处理字符串格式的日期解析时，我会使用 dateparse 库，这样我就不用处理所有情况了。

time package - time - Go Packages

time 包提供了测量和显示时间的功能。

第二个参数必须能够使用作为第一个参数提供的格式字符串（布局）进行解析。

除了小数秒之外，没有提到格式的可选部分。

我认为，为了一个没有意外行为的 API，这并没有什么难以接受的。

func ParseTimeWithFallback(layout, fallbackLayout, value string) (Time,error) {
  t, e := time.Parse(layout, value)
  if e!=nil {
    t, e = time.Parse(fallbackLayout, value)
  }
  return t,e
}

在Go中处理不同格式的时间字符串时，可以使用time.ParseInLocation结合自定义解析逻辑。以下是针对您需求的解决方案：

package main

import (
    "fmt"
    "strings"
    "time"
)

func parseTimeString(timeStr string) (time.Time, error) {
    layouts := []string{
        "02/01/2006 15:04:05",
        "02/01/2006 15:04",
    }
    
    for _, layout := range layouts {
        t, err := time.Parse(layout, timeStr)
        if err == nil {
            return t, nil
        }
    }
    
    return time.Time{}, fmt.Errorf("无法解析时间字符串: %s", timeStr)
}

func parseTimeStringWithDefaultSeconds(timeStr string) (time.Time, error) {
    // 检查是否包含秒部分
    if !strings.Contains(timeStr, ":") {
        return time.Time{}, fmt.Errorf("无效的时间格式")
    }
    
    parts := strings.Split(timeStr, " ")
    if len(parts) != 2 {
        return time.Time{}, fmt.Errorf("无效的时间格式")
    }
    
    timePart := parts[1]
    timeComponents := strings.Split(timePart, ":")
    
    // 根据冒号数量判断格式
    switch len(timeComponents) {
    case 2: // 只有小时和分钟
        timeStr = timeStr + ":00"
    case 3: // 已有小时、分钟和秒
        // 不做处理
    default:
        return time.Time{}, fmt.Errorf("无效的时间格式")
    }
    
    layout := "02/01/2006 15:04:05"
    return time.Parse(layout, timeStr)
}

func main() {
    testCases := []string{
        "27/12/2021 18:19",
        "27/12/2021 18:19:02",
        "27/12/2021 18:19:35",
    }
    
    fmt.Println("方法1: 尝试多种布局")
    for _, tc := range testCases {
        t, err := parseTimeString(tc)
        if err != nil {
            fmt.Printf("错误: %v\n", err)
        } else {
            fmt.Printf("%s -> %s\n", tc, t.Format("02/01/2006 15:04:05"))
        }
    }
    
    fmt.Println("\n方法2: 自动补全秒部分")
    for _, tc := range testCases {
        t, err := parseTimeStringWithDefaultSeconds(tc)
        if err != nil {
            fmt.Printf("错误: %v\n", err)
        } else {
            fmt.Printf("%s -> %s\n", tc, t.Format("02/01/2006 15:04:05"))
        }
    }
}

更通用的解决方案，可以处理更多格式：

func flexibleTimeParse(timeStr string) (time.Time, error) {
    // 定义可能的时间分隔符和格式
    timeFormats := []string{
        "02/01/2006 15:04:05",
        "02/01/2006 15:04",
        "2006-01-02 15:04:05",
        "2006-01-02 15:04",
        "02-01-2006 15:04:05",
        "02-01-2006 15:04",
    }
    
    // 标准化输入字符串
    normalized := strings.TrimSpace(timeStr)
    
    // 尝试所有格式
    for _, format := range timeFormats {
        t, err := time.Parse(format, normalized)
        if err == nil {
            return t, nil
        }
    }
    
    // 如果都没有匹配，尝试自动补全秒
    if strings.Count(normalized, ":") == 1 {
        // 找到最后一个空格的位置
        lastSpace := strings.LastIndex(normalized, " ")
        if lastSpace > 0 {
            timePart := normalized[lastSpace+1:]
            if len(strings.Split(timePart, ":")) == 2 {
                normalized = normalized + ":00"
                return time.Parse("02/01/2006 15:04:05", normalized)
            }
        }
    }
    
    return time.Time{}, fmt.Errorf("无法解析时间: %s", timeStr)
}

使用示例：

func main() {
    inputs := []string{
        "27/12/2021 18:19",
        "27/12/2021 18:19:02",
        "27/12/2021 18:19:35",
        "2021-12-27 18:19",
        "27-12-2021 18:19:45",
    }
    
    for _, input := range inputs {
        t, err := flexibleTimeParse(input)
        if err != nil {
            fmt.Printf("解析失败: %s, 错误: %v\n", input, err)
        } else {
            fmt.Printf("%s -> %s\n", input, t.Format("2006-01-02 15:04:05"))
        }
    }
}

这些方法可以处理不同格式的时间字符串，自动为缺失的秒部分补零，并返回正确的time.Time对象。

回到顶部