Go语言中从复杂字符串子串解析日期时间的高效策略

package main

import (
    "fmt"
    "regexp"
    "time"
)

// 定义用于匹配日志行的正则表达式
// ^((?:\d{1,3}\.){3}\d{1,3}) 匹配IP地址
// ([a-zA-Z]{3} \d{1,2} \d{4} \d{1,2}:\d{2}:\d{2}) 匹配日期时间部分
// (.*) 匹配剩余的消息内容
var r = regexp.MustCompile(`^((?:\d{1,3}\.){3}\d{1,3}) ([a-zA-Z]{3} \d{1,2} \d{4} \d{1,2}:\d{2}:\d{2}) (.*)`)

// 定义日期时间解析的参考格式
// "Jan 02 2006 15:04:05" 是Go语言中 time.Parse 的标准参考时间格式
const longForm = "Jan 02 2006 15:04:05"

// parseRegex 函数通过正则表达式解析日志字符串
// 返回IP地址、消息内容和解析后的时间对象
func parseRegex(s string) (ip, msg string, t time.Time, err error) {
    m := r.FindStringSubmatch(s)
    if len(m) != 4 { // 期望匹配到4个子串：整个匹配，IP，日期时间，消息
        return "", "", time.Time{}, fmt.Errorf("string does not match expected format: %s", s)
    }

    // m[1] 是IP地址
    ip = m[1]
    // m[2] 是日期时间字符串，使用 time.Parse 进行解析
    t, err = time.Parse(longForm, m[2])
    if err != nil {
        return "", "", time.Time{}, fmt.Errorf("failed to parse time: %w", err)
    }
    // m[3] 是消息内容
    msg = m[3]
    return ip, msg, t, nil
}

func main() {
    s := `10.0.0.1 Jan 11 2014 10:00:00 hello world`
    ip, msg, t, err := parseRegex(s)
    if err != nil {
        fmt.Printf("Error parsing string: %v\n", err)
        return
    }
    fmt.Printf("Regex Parsing Result:\n")
    fmt.Printf("IP: %s\n", ip)
    fmt.Printf("Time: %s\n", t.Format(time.RFC3339))
    fmt.Printf("Message: %s\n", msg)

    s2 := `invalid format string`
    _, _, _, err = parseRegex(s2)
    if err != nil {
        fmt.Printf("Error parsing invalid string: %v\n", err)
    }
}

package main

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

// 定义日期时间解析的参考格式
const longForm = "Jan 02 2006 15:04:05"

// parseSplit 函数通过 strings.SplitN 解析日志字符串
// 返回IP地址、消息内容和解析后的时间对象
func parseSplit(s string) (ip, msg string, t time.Time, err error) {
    // 将字符串按空格分割，最多分割6次。
    // 这样可以确保IP地址、日期时间（4个部分）被单独分割，
    // 剩余的所有内容（消息）作为最后一个元素。
    parts := strings.SplitN(s, " ", 6)
    if len(parts) != 6 {
        return "", "", time.Time{}, fmt.Errorf("string does not have enough parts: %s", s)
    }

    // parts[0] 是IP地址
    ip = parts[0]
    // parts[1] 到 parts[4] 组合成日期时间字符串
    dateTimeStr := strings.Join(parts[1:5], " ")
    t, err = time.Parse(longForm, dateTimeStr)
    if err != nil {
        return "", "", time.Time{}, fmt.Errorf("failed to parse time: %w", err)
    }
    // parts[5] 是消息内容
    msg = parts[5]
    return ip, msg, t, nil
}

func main() {
    s := `10.0.0.1 Jan 11 2014 10:00:00 hello world`
    ip, msg, t, err := parseSplit(s)
    if err != nil {
        fmt.Printf("Error parsing string: %v\n", err)
        return
    }
    fmt.Printf("\nSplitN Parsing Result:\n")
    fmt.Printf("IP: %s\n", ip)
    fmt.Printf("Time: %s\n", t.Format(time.RFC3339))
    fmt.Printf("Message: %s\n", msg)

    s2 := `10.0.0.1 Jan 11 2014 10:00:00` // 消息部分缺失
    _, _, _, err = parseSplit(s2)
    if err != nil {
        fmt.Printf("Error parsing string with missing message: %v\n", err)
    }
}