Golang parse time.Duration

Question

I would like to parse time.Duration. The duration is "PT15M" (string/bytes) and would like to convert it to a valid time.Duration.

---

If this were a time.Time thing, I would use:

t, err := time.Parse(time.RFC3339Nano, "2013-06-05T14:10:43.678Z")

But this doesn't exist (ParseDuration only takes one parameter):

d, err := time.ParseDuration(time.RFC3339Nano, "PT15M")

---

How can I parse this ISO 8601 duration?

Solution 1

It's not exactly "out of the box" but a regular expression does the job:

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)
}

Solution 2

Here is code that handles fractional time units like 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
}