Parsing Golang解析时间。持续时间

我想解析

time.Duration

。持续时间为

“PT15M”

（字符串/字节），希望将其转换为有效的

时间。持续时间

---

如果这是一个

time.time

的东西，我会使用：

t，err:=time.Parse（time.RFC3339Nano，“2013-06-05T14:10:43.678Z”）

但这不存在（

ParseDuration

只接受一个参数）：

d，err:=time.ParseDuration（time.RFC3339Nano，“PT15M”）

---

我如何解析这个

这并不完全是“开箱即用”，但正则表达式起作用：

package main

import "fmt"
import "regexp"
import "strconv"
import "time"

func main() {
    fmt.Println(ParseDuration("PT15M"))
    fmt.Println(ParseDuration("P12Y4MT15M"))
}

func ParseDuration(str string) time.Duration {
    durationRegex := regexp.MustCompile(`P(?P<years>\d+Y)?(?P<months>\d+M)?(?P<days>\d+D)?T?(?P<hours>\d+H)?(?P<minutes>\d+M)?(?P<seconds>\d+S)?`)
    matches := durationRegex.FindStringSubmatch(str)

    years := ParseInt64(matches[1])
    months := ParseInt64(matches[2])
    days := ParseInt64(matches[3])
    hours := ParseInt64(matches[4])
    minutes := ParseInt64(matches[5])
    seconds := ParseInt64(matches[6])

    hour := int64(time.Hour)
    minute := int64(time.Minute)
    second := int64(time.Second)
    return time.Duration(years*24*365*hour + months*30*24*hour + days*24*hour + hours*hour + minutes*minute + seconds*second)
}

func ParseInt64(value string) int64 {
    if len(value) == 0 {
        return 0
    }
    parsed, err := strconv.Atoi(value[:len(value)-1])
    if err != nil {
        return 0
    }
    return int64(parsed)
}

主程序包
输入“fmt”
导入“regexp”
导入“strconv”
导入“时间”
func main（）{
fmt.Println（持续时间（“PT15M”））
格式打印LN（解析持续时间（“P12Y4MT15M”））
}
func ParseDuration（str字符串）time.Duration{
durationRegex:=regexp.MustCompile（`P（？P\d+Y）→P\d+M）→P\d+d）→T（→P\d+H）→P\d+M）→P\d+S）`）
匹配项：=durationRegex.FindStringSubmatch（str）
年份：=ParseInt64（匹配[1]）
月份：=ParseInt64（匹配[2]）
天数：=ParseInt64（匹配[3]）
小时数：=ParseInt64（匹配[4]）
分钟数：=ParseInt64（匹配[5]）
秒数：=ParseInt64（匹配[6]）
小时数：=int64（time.hour）
分钟：=int64（time.minute）
秒：=int64（时间秒）
返回时间。持续时间（年*24*365*小时+月*30*24*小时+天*24*小时*小时+分钟*分+秒*秒）
}
func ParseInt64（值字符串）int64{
如果len（值）==0{
返回0
}
已分析，错误：=strconv.Atoi（值[：len（值）-1]）
如果错误！=零{
返回0
}
返回int64（已解析）
}

以下是处理分数时间单位的代码，如

PT3.001S

var durationRegex = regexp.MustCompile(`P([\d\.]+Y)?([\d\.]+M)?([\d\.]+D)?T?([\d\.]+H)?([\d\.]+M)?([\d\.]+?S)?`)

// ParseDuration converts a ISO8601 duration into a time.Duration
func ParseDuration(str string) time.Duration {
   matches := durationRegex.FindStringSubmatch(str)

   years := parseDurationPart(matches[1], time.Hour*24*365)
   months := parseDurationPart(matches[2], time.Hour*24*30)
   days := parseDurationPart(matches[3], time.Hour*24)
   hours := parseDurationPart(matches[4], time.Hour)
   minutes := parseDurationPart(matches[5], time.Second*60)
   seconds := parseDurationPart(matches[6], time.Second)

   return time.Duration(years + months + days + hours + minutes + seconds)
}

func parseDurationPart(value string, unit time.Duration) time.Duration {
   if len(value) != 0 {
       if parsed, err := strconv.ParseFloat(value[:len(value)-1], 64); err == nil {
           return time.Duration(float64(unit) * parsed)
       }
   }
   return 0
}

---

快速谷歌：没有现成的东西？希望这有帮助：没有，标准库中没有。你为什么这么关心使用图书馆？这在围棋中没什么大不了的，不需要外部依赖工具和静态二进制文件。很好，很简单，但不支持分数倍。使用的最小值也可能有小数点，如“P0.5Y”中表示半年。该小数可以用逗号或句号表示，如“P0.5Y”或“P0.5Y”。毫秒通常表示为PT0.032S。如果计划将持续时间添加到时间中，则此处会出现问题，因为年和月的含义取决于将持续时间添加到的实际时间。例如，如果你加上闰年或没有30天的月份，你会得到错误的答案。