如何在Go中表示RFC-3339`-00：00`偏移量？

RFC-3339 Section 4.3 (https://tools.ietf.org/html/rfc3339#section-4.3) defines the -00:00 offset as the following, which is different than Z or +00:00.

4.3. Unknown Local Offset Convention

   If the time in UTC is known, but the offset to local time is unknown,
   this can be represented with an offset of "-00:00".  This differs
   semantically from an offset of "Z" or "+00:00", which imply that UTC
   is the preferred reference point for the specified time.  RFC2822
   [IMAIL-UPDATE] describes a similar convention for email.

However, I'm not sure how to represent this in Go. When I parse a time with -00:00 and format it, I get a Z offset. For example:

• Input: 2018-01-01T00:00:00-00:00
• Output: 2018-01-01T00:00:00Z

Here's some example code (https://play.golang.org/p/CVmNnhaSiiT):

package main

import (
    "fmt"
    "time"
)

func main() {
    t := "2018-01-01T00:00:00-00:00"
    fmt.Println("Input  " + t)
    p, err := time.Parse(time.RFC3339, t)
    if err != nil {
        fmt.Println(err)
    } else {
        t2 := p.Format(time.RFC3339)

        fmt.Println("Output " + t2)
    }
}

Package time

import "time"

RFC3339, RFC822, RFC822Z, RFC1123, and RFC1123Z are useful for formatting; when used with time.Parse they do not accept all the time formats permitted by the RFCs.

Go does not accept all the time formats permitted by the RFCs.

The Go time.Time type uses integers which, unlike floating-point, have no concept of plus and minus zero. The results for parsing offsets of -00:00 and +00:00 are identical.

For example,

package main

import (
    "fmt"
    "time"
)

func main() {
    var err error
    var minus, plus time.Time
    t := "2018-01-01T00:00:00-00:00"
    minus, err = time.Parse(time.RFC3339, t)
    if err != nil {
        fmt.Println(err)
    }
    t = "2018-01-01T00:00:00+00:00"
    plus, err = time.Parse(time.RFC3339, t)
    if err != nil {
        fmt.Println(err)
    }
    fmt.Println(minus, plus, minus.Equal(plus), minus == plus)
}

Playground: https://play.golang.org/p/Urf8VlKYoMH

Output:

2018-01-01 00:00:00 +0000 UTC 2018-01-01 00:00:00 +0000 UTC true true

PeterSO's answer is perfect IMHO. If you need to act differently based on the information that the offset is unknown, then this might help you.

You can build your own time data type:

type MyTime struct {
    // based on time.Time so we can do all normal time.Time stuff
    time.Time

    offsetUnknown bool
}

func ParseRFC3339(s string) (MyTime, error) {
    time, err := time.Parse(time.RFC3339, s)
    if err != nil {
        return MyTime{}, err
    }

    return MyTime{
        Time: time,
        // maybe this condition needs improvement in case of false positives
        offsetUnknown: strings.Contains(s, "-00:00"),
    }, nil
}

Any functions you need to behave differently based on offsetUnknown you can then override on the MyTime struct. Here one example:

func (s MyTime) Format(layout string) string {
    out := s.Time.Format(layout)
    // again this is probably not the best solution
    if layout == time.RFC3339 && s.offsetUnknown {
        out = strings.Replace(out, "+00:00", "-00:00", -1)
    }
    return out
}