date

package
v7.0.0+incompatible Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Mar 25, 2016 License: Apache-2.0 Imports: 4 Imported by: 0

Documentation

Overview

Package date provides time.Time derivatives that conform to the Swagger.io (https://swagger.io/) defined date formats: Date and DateTime. Both types may, in most cases, be used in lieu of time.Time types. And both convert to time.Time through a ToTime method.

Index

Examples

Constants

This section is empty.

Variables

This section is empty.

Functions

func ParseTime 

func ParseTime(format string, t string) (d time.Time, err error)

ParseTime to parse Time string to specified format.

Example 
d, _ := ParseTime(rfc3339, "2001-02-03T04:05:06Z")
fmt.Println(d)

Output:

2001-02-03 04:05:06 +0000 UTC

Types

type Date 

type Date struct {
	time.Time
}

Date defines a type similar to time.Time but assumes a layout of RFC3339 full-date (i.e., 2006-01-02).

Example 
d, err := ParseDate("2001-02-03")
if err != nil {
	fmt.Println(err)
}

t, err := time.Parse(time.RFC3339, "2001-02-04T00:00:00Z")
if err != nil {
	fmt.Println(err)
}

// Date acts as time.Time when the receiver
if d.Before(t) {
	fmt.Printf("Before ")
} else {
	fmt.Printf("After ")
}

// Convert Date when needing a time.Time
if t.After(d.ToTime()) {
	fmt.Printf("After")
} else {
	fmt.Printf("Before")
}

Output:

Before After

func ParseDate 

func ParseDate(date string) (d Date, err error)

ParseDate create a new Date from the passed string.

Example 
d, err := ParseDate("2001-02-03")
if err != nil {
	fmt.Println(err)
}
fmt.Println(d)

Output:

2001-02-03

func (Date) MarshalBinary 

func (d Date) MarshalBinary() ([]byte, error)

MarshalBinary preserves the Date as a byte array conforming to RFC3339 full-date (i.e., 2006-01-02).

Example 
d, err := ParseDate("2001-02-03")
if err != nil {
	fmt.Println(err)
}
t, err := d.MarshalBinary()
if err != nil {
	fmt.Println(err)
}
fmt.Println(string(t))

Output:

2001-02-03

func (Date) MarshalJSON 

func (d Date) MarshalJSON() (json []byte, err error)

MarshalJSON preserves the Date as a JSON string conforming to RFC3339 full-date (i.e., 2006-01-02).

Example 
d, err := ParseDate("2001-02-03")
if err != nil {
	fmt.Println(err)
}
j, err := json.Marshal(d)
if err != nil {
	fmt.Println(err)
}
fmt.Println(string(j))

Output:

"2001-02-03"

func (Date) MarshalText 

func (d Date) MarshalText() (text []byte, err error)

MarshalText preserves the Date as a byte array conforming to RFC3339 full-date (i.e., 2006-01-02).

Example 
d, err := ParseDate("2001-02-03")
if err != nil {
	fmt.Println(err)
}
t, err := d.MarshalText()
if err != nil {
	fmt.Println(err)
}
fmt.Println(string(t))

Output:

2001-02-03

func (Date) String 

func (d Date) String() string

String returns the Date formatted as an RFC3339 full-date string (i.e., 2006-01-02).

func (Date) ToTime 

func (d Date) ToTime() time.Time

ToTime returns a Date as a time.Time

func (*Date) UnmarshalBinary 

func (d *Date) UnmarshalBinary(data []byte) error

UnmarshalBinary reconstitutes a Date saved as a byte array conforming to RFC3339 full-date (i.e., 2006-01-02).

Example 
d := Date{}
t := "2001-02-03"

if err := d.UnmarshalBinary([]byte(t)); err != nil {
	fmt.Println(err)
}
fmt.Println(d)

Output:

2001-02-03

func (*Date) UnmarshalJSON 

func (d *Date) UnmarshalJSON(data []byte) (err error)

UnmarshalJSON reconstitutes the Date from a JSON string conforming to RFC3339 full-date (i.e., 2006-01-02).

Example 
var d struct {
	Date Date `json:"date"`
}
j := `{"date" : "2001-02-03"}`

if err := json.Unmarshal([]byte(j), &d); err != nil {
	fmt.Println(err)
}
fmt.Println(d.Date)

Output:

2001-02-03

func (*Date) UnmarshalText 

func (d *Date) UnmarshalText(data []byte) (err error)

UnmarshalText reconstitutes a Date saved as a byte array conforming to RFC3339 full-date (i.e., 2006-01-02).

Example 
d := Date{}
t := "2001-02-03"

if err := d.UnmarshalText([]byte(t)); err != nil {
	fmt.Println(err)
}
fmt.Println(d)

Output:

2001-02-03

type Time 

type Time struct {
	time.Time
}

Time defines a type similar to time.Time but assumes a layout of RFC3339 date-time (i.e., 2006-01-02T15:04:05Z).

func (Time) MarshalBinary 

func (t Time) MarshalBinary() ([]byte, error)

MarshalBinary preserves the Time as a byte array conforming to RFC3339 date-time (i.e., 2006-01-02T15:04:05Z).

Example 
ti, err := ParseTime(rfc3339, "2001-02-03T04:05:06Z")
if err != nil {
	fmt.Println(err)
}
d := Time{ti}
t, err := d.MarshalBinary()
if err != nil {
	fmt.Println(err)
}
fmt.Println(string(t))

Output:

2001-02-03T04:05:06Z

func (Time) MarshalJSON 

func (t Time) MarshalJSON() (json []byte, err error)

MarshalJSON preserves the Time as a JSON string conforming to RFC3339 date-time (i.e., 2006-01-02T15:04:05Z).

Example 
d, err := ParseTime(rfc3339, "2001-02-03T04:05:06Z")
if err != nil {
	fmt.Println(err)
}
j, err := json.Marshal(d)
if err != nil {
	fmt.Println(err)
}
fmt.Println(string(j))

Output:

"2001-02-03T04:05:06Z"

func (Time) MarshalText 

func (t Time) MarshalText() (text []byte, err error)

MarshalText preserves the Time as a byte array conforming to RFC3339 date-time (i.e., 2006-01-02T15:04:05Z).

Example 
d, err := ParseTime(rfc3339, "2001-02-03T04:05:06Z")
if err != nil {
	fmt.Println(err)
}
t, err := d.MarshalText()
if err != nil {
	fmt.Println(err)
}
fmt.Println(string(t))

Output:

2001-02-03T04:05:06Z

func (Time) String 

func (t Time) String() string

String returns the Time formatted as an RFC3339 date-time string (i.e., 2006-01-02T15:04:05Z).

func (Time) ToTime 

func (t Time) ToTime() time.Time

ToTime returns a Time as a time.Time

func (*Time) UnmarshalBinary 

func (t *Time) UnmarshalBinary(data []byte) error

UnmarshalBinary reconstitutes a Time saved as a byte array conforming to RFC3339 date-time (i.e., 2006-01-02T15:04:05Z).

Example 
d := Time{}
t := "2001-02-03T04:05:06Z"

if err := d.UnmarshalBinary([]byte(t)); err != nil {
	fmt.Println(err)
}
fmt.Println(d)

Output:

2001-02-03T04:05:06Z

func (*Time) UnmarshalJSON 

func (t *Time) UnmarshalJSON(data []byte) (err error)

UnmarshalJSON reconstitutes the Time from a JSON string conforming to RFC3339 date-time (i.e., 2006-01-02T15:04:05Z).

Example 
var d struct {
	Time Time `json:"datetime"`
}
j := `{"datetime" : "2001-02-03T04:05:06Z"}`

if err := json.Unmarshal([]byte(j), &d); err != nil {
	fmt.Println(err)
}
fmt.Println(d.Time)

Output:

2001-02-03T04:05:06Z

func (*Time) UnmarshalText 

func (t *Time) UnmarshalText(data []byte) (err error)

UnmarshalText reconstitutes a Time saved as a byte array conforming to RFC3339 date-time (i.e., 2006-01-02T15:04:05Z).

Example 
d := Time{}
t := "2001-02-03T04:05:06Z"

if err := d.UnmarshalText([]byte(t)); err != nil {
	fmt.Println(err)
}
fmt.Println(d)

Output:

2001-02-03T04:05:06Z

type TimeRfc1123 

type TimeRfc1123 struct {
	time.Time
}

TimeRfc1123 defines a type similar to time.Time but assumes a layout of RFC1123 date-time (i.e., Mon, 02 Jan 2006 15:04:05 MST).

func (TimeRfc1123) MarshalBinary 

func (t TimeRfc1123) MarshalBinary() ([]byte, error)

MarshalBinary preserves the Time as a byte array conforming to RFC1123 date-time (i.e., Mon, 02 Jan 2006 15:04:05 MST).

Example 
ti, err := ParseTime(rfc1123, "Mon, 02 Jan 2006 15:04:05 MST")
if err != nil {
	fmt.Println(err)
}
d := TimeRfc1123{ti}
b, err := d.MarshalBinary()
if err != nil {
	fmt.Println(err)
}
fmt.Println(string(b))

Output:

Mon, 02 Jan 2006 15:04:05 MST

func (TimeRfc1123) MarshalJSON 

func (t TimeRfc1123) MarshalJSON() ([]byte, error)

MarshalJSON preserves the Time as a JSON string conforming to RFC1123 date-time (i.e., Mon, 02 Jan 2006 15:04:05 MST).

Example 
ti, err := ParseTime(rfc1123, "Mon, 02 Jan 2006 15:04:05 MST")
if err != nil {
	fmt.Println(err)
}
d := TimeRfc1123{ti}
j, err := json.Marshal(d)
if err != nil {
	fmt.Println(err)
}
fmt.Println(string(j))

Output:

"Mon, 02 Jan 2006 15:04:05 MST"

func (TimeRfc1123) MarshalText 

func (t TimeRfc1123) MarshalText() ([]byte, error)

MarshalText preserves the Time as a byte array conforming to RFC1123 date-time (i.e., Mon, 02 Jan 2006 15:04:05 MST).

Example 
ti, err := ParseTime(rfc3339, "2001-02-03T04:05:06Z")
if err != nil {
	fmt.Println(err)
}
d := TimeRfc1123{ti}
t, err := d.MarshalText()
if err != nil {
	fmt.Println(err)
}
fmt.Println(string(t))

Output:

Sat, 03 Feb 2001 04:05:06 UTC

func (TimeRfc1123) String 

func (t TimeRfc1123) String() string

String returns the Time formatted as an RFC1123 date-time string (i.e., Mon, 02 Jan 2006 15:04:05 MST).

func (TimeRfc1123) ToTime 

func (t TimeRfc1123) ToTime() time.Time

ToTime returns a Time as a time.Time

func (*TimeRfc1123) UnmarshalBinary 

func (t *TimeRfc1123) UnmarshalBinary(data []byte) error

UnmarshalBinary reconstitutes a Time saved as a byte array conforming to RFC1123 date-time (i.e., Mon, 02 Jan 2006 15:04:05 MST).

Example 
d := TimeRfc1123{}
t := "Mon, 02 Jan 2006 15:04:05 MST"
if err := d.UnmarshalBinary([]byte(t)); err != nil {
	fmt.Println(err)
}
fmt.Println(d)

Output:

Mon, 02 Jan 2006 15:04:05 MST

func (*TimeRfc1123) UnmarshalJSON 

func (t *TimeRfc1123) UnmarshalJSON(data []byte) (err error)

UnmarshalJSON reconstitutes the Time from a JSON string conforming to RFC1123 date-time (i.e., Mon, 02 Jan 2006 15:04:05 MST).

Example 
var d struct {
	Time TimeRfc1123 `json:"datetime"`
}
j := `{"datetime" : "Mon, 02 Jan 2006 15:04:05 MST"}`

if err := json.Unmarshal([]byte(j), &d); err != nil {
	fmt.Println(err)
}
fmt.Println(d.Time)

Output:

Mon, 02 Jan 2006 15:04:05 MST

func (*TimeRfc1123) UnmarshalText 

func (t *TimeRfc1123) UnmarshalText(data []byte) (err error)

UnmarshalText reconstitutes a Time saved as a byte array conforming to RFC1123 date-time (i.e., Mon, 02 Jan 2006 15:04:05 MST).

Example 
d := TimeRfc1123{}
t := "Sat, 03 Feb 2001 04:05:06 UTC"

if err := d.UnmarshalText([]byte(t)); err != nil {
	fmt.Println(err)
}
fmt.Println(d)

Output:

Sat, 03 Feb 2001 04:05:06 UTC

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.