now: github.com/jinzhu/now Index | Examples | Files

package now

import "github.com/jinzhu/now"

Package now is a time toolkit for golang.

More details README here: https://github.com/jinzhu/now

import "github.com/jinzhu/now"

now.BeginningOfMinute() // 2013-11-18 17:51:00 Mon
now.BeginningOfDay()    // 2013-11-18 00:00:00 Mon
now.EndOfDay()          // 2013-11-18 23:59:59.999999999 Mon

Code:

package main

import (
    "testing"
    "time"
)

var (
    format          = "2006-01-02 15:04:05.999999999"
    locationCaracas *time.Location
    locationBerlin  *time.Location
    timeCaracas     time.Time
)

func init() {
    var err error
    if locationCaracas, err = time.LoadLocation("America/Caracas"); err != nil {
        panic(err)
    }

    if locationBerlin, err = time.LoadLocation("Europe/Berlin"); err != nil {
        panic(err)
    }

    timeCaracas = time.Date(2016, 1, 1, 12, 10, 0, 0, locationCaracas)
}

func assertT(t *testing.T) func(time.Time, string, string) {
    return func(actual time.Time, expected string, msg string) {
        actualStr := actual.Format(format)
        if actualStr != expected {
            t.Errorf("Failed %s: actual: %v, expected: %v", msg, actualStr, expected)
        }
    }
}

func TestBeginningOf(t *testing.T) {
    assert := assertT(t)

    n := time.Date(2013, 11, 18, 17, 51, 49, 123456789, time.UTC)

    assert(With(n).BeginningOfMinute(), "2013-11-18 17:51:00", "BeginningOfMinute")

    WeekStartDay = time.Monday
    assert(With(n).BeginningOfWeek(), "2013-11-18 00:00:00", "BeginningOfWeek, FirstDayMonday")

    WeekStartDay = time.Tuesday
    assert(With(n).BeginningOfWeek(), "2013-11-12 00:00:00", "BeginningOfWeek, FirstDayTuesday")

    WeekStartDay = time.Wednesday
    assert(With(n).BeginningOfWeek(), "2013-11-13 00:00:00", "BeginningOfWeek, FirstDayWednesday")

    WeekStartDay = time.Thursday
    assert(With(n).BeginningOfWeek(), "2013-11-14 00:00:00", "BeginningOfWeek, FirstDayThursday")

    WeekStartDay = time.Friday
    assert(With(n).BeginningOfWeek(), "2013-11-15 00:00:00", "BeginningOfWeek, FirstDayFriday")

    WeekStartDay = time.Saturday
    assert(With(n).BeginningOfWeek(), "2013-11-16 00:00:00", "BeginningOfWeek, FirstDaySaturday")

    WeekStartDay = time.Sunday
    assert(With(n).BeginningOfWeek(), "2013-11-17 00:00:00", "BeginningOfWeek, FirstDaySunday")

    assert(With(n).BeginningOfHour(), "2013-11-18 17:00:00", "BeginningOfHour")

    // Truncate with hour bug
    assert(With(timeCaracas).BeginningOfHour(), "2016-01-01 12:00:00", "BeginningOfHour Caracas")

    assert(With(n).BeginningOfDay(), "2013-11-18 00:00:00", "BeginningOfDay")

    location, err := time.LoadLocation("Japan")
    if err != nil {
        t.Fatalf("Error loading location: %v", err)
    }
    beginningOfDay := time.Date(2015, 05, 01, 0, 0, 0, 0, location)
    assert(With(beginningOfDay).BeginningOfDay(), "2015-05-01 00:00:00", "BeginningOfDay")

    // DST
    dstBeginningOfDay := time.Date(2017, 10, 29, 10, 0, 0, 0, locationBerlin)
    assert(With(dstBeginningOfDay).BeginningOfDay(), "2017-10-29 00:00:00", "BeginningOfDay DST")

    assert(With(n).BeginningOfWeek(), "2013-11-17 00:00:00", "BeginningOfWeek")

    dstBegginingOfWeek := time.Date(2017, 10, 30, 12, 0, 0, 0, locationBerlin)
    assert(With(dstBegginingOfWeek).BeginningOfWeek(), "2017-10-29 00:00:00", "BeginningOfWeek")

    dstBegginingOfWeek = time.Date(2017, 10, 29, 12, 0, 0, 0, locationBerlin)
    assert(With(dstBegginingOfWeek).BeginningOfWeek(), "2017-10-29 00:00:00", "BeginningOfWeek")

    WeekStartDay = time.Monday
    assert(With(n).BeginningOfWeek(), "2013-11-18 00:00:00", "BeginningOfWeek, FirstDayMonday")
    dstBegginingOfWeek = time.Date(2017, 10, 24, 12, 0, 0, 0, locationBerlin)
    assert(With(dstBegginingOfWeek).BeginningOfWeek(), "2017-10-23 00:00:00", "BeginningOfWeek, FirstDayMonday")

    dstBegginingOfWeek = time.Date(2017, 10, 29, 12, 0, 0, 0, locationBerlin)
    assert(With(dstBegginingOfWeek).BeginningOfWeek(), "2017-10-23 00:00:00", "BeginningOfWeek, FirstDayMonday")

    WeekStartDay = time.Sunday

    assert(With(n).BeginningOfMonth(), "2013-11-01 00:00:00", "BeginningOfMonth")

    // DST
    dstBeginningOfMonth := time.Date(2017, 10, 31, 0, 0, 0, 0, locationBerlin)
    assert(With(dstBeginningOfMonth).BeginningOfMonth(), "2017-10-01 00:00:00", "BeginningOfMonth DST")

    assert(With(n).BeginningOfQuarter(), "2013-10-01 00:00:00", "BeginningOfQuarter")

    // DST
    assert(With(dstBeginningOfMonth).BeginningOfQuarter(), "2017-10-01 00:00:00", "BeginningOfQuarter DST")
    dstBeginningOfQuarter := time.Date(2017, 11, 24, 0, 0, 0, 0, locationBerlin)
    assert(With(dstBeginningOfQuarter).BeginningOfQuarter(), "2017-10-01 00:00:00", "BeginningOfQuarter DST")

    assert(With(dstBeginningOfQuarter).BeginningOfHalf(), "2017-07-01 00:00:00", "BeginningOfHalf DST")

    assert(With(n.AddDate(0, -1, 0)).BeginningOfQuarter(), "2013-10-01 00:00:00", "BeginningOfQuarter")

    assert(With(n.AddDate(0, 1, 0)).BeginningOfQuarter(), "2013-10-01 00:00:00", "BeginningOfQuarter")

    assert(With(n.AddDate(0, 1, 0)).BeginningOfHalf(), "2013-07-01 00:00:00", "BeginningOfHalf")

    // DST
    assert(With(dstBeginningOfQuarter).BeginningOfYear(), "2017-01-01 00:00:00", "BeginningOfYear DST")

    assert(With(timeCaracas).BeginningOfYear(), "2016-01-01 00:00:00", "BeginningOfYear Caracas")
}

func TestEndOf(t *testing.T) {
    assert := assertT(t)

    n := time.Date(2013, 11, 18, 17, 51, 49, 123456789, time.UTC)

    assert(With(n).EndOfMinute(), "2013-11-18 17:51:59.999999999", "EndOfMinute")

    assert(With(n).EndOfHour(), "2013-11-18 17:59:59.999999999", "EndOfHour")

    assert(With(timeCaracas).EndOfHour(), "2016-01-01 12:59:59.999999999", "EndOfHour Caracas")

    assert(With(n).EndOfDay(), "2013-11-18 23:59:59.999999999", "EndOfDay")

    dstEndOfDay := time.Date(2017, 10, 29, 1, 0, 0, 0, locationBerlin)
    assert(With(dstEndOfDay).EndOfDay(), "2017-10-29 23:59:59.999999999", "EndOfDay DST")

    WeekStartDay = time.Tuesday
    assert(With(n).EndOfWeek(), "2013-11-18 23:59:59.999999999", "EndOfWeek, FirstDayTuesday")

    WeekStartDay = time.Wednesday
    assert(With(n).EndOfWeek(), "2013-11-19 23:59:59.999999999", "EndOfWeek, FirstDayWednesday")

    WeekStartDay = time.Thursday
    assert(With(n).EndOfWeek(), "2013-11-20 23:59:59.999999999", "EndOfWeek, FirstDayThursday")

    WeekStartDay = time.Friday
    assert(With(n).EndOfWeek(), "2013-11-21 23:59:59.999999999", "EndOfWeek, FirstDayFriday")

    WeekStartDay = time.Saturday
    assert(With(n).EndOfWeek(), "2013-11-22 23:59:59.999999999", "EndOfWeek, FirstDaySaturday")

    WeekStartDay = time.Sunday
    assert(With(n).EndOfWeek(), "2013-11-23 23:59:59.999999999", "EndOfWeek, FirstDaySunday")

    WeekStartDay = time.Monday
    assert(With(n).EndOfWeek(), "2013-11-24 23:59:59.999999999", "EndOfWeek, FirstDayMonday")

    dstEndOfWeek := time.Date(2017, 10, 24, 12, 0, 0, 0, locationBerlin)
    assert(With(dstEndOfWeek).EndOfWeek(), "2017-10-29 23:59:59.999999999", "EndOfWeek, FirstDayMonday")

    dstEndOfWeek = time.Date(2017, 10, 29, 12, 0, 0, 0, locationBerlin)
    assert(With(dstEndOfWeek).EndOfWeek(), "2017-10-29 23:59:59.999999999", "EndOfWeek, FirstDayMonday")

    WeekStartDay = time.Sunday
    assert(With(n).EndOfWeek(), "2013-11-23 23:59:59.999999999", "EndOfWeek")

    dstEndOfWeek = time.Date(2017, 10, 29, 0, 0, 0, 0, locationBerlin)
    assert(With(dstEndOfWeek).EndOfWeek(), "2017-11-04 23:59:59.999999999", "EndOfWeek")

    dstEndOfWeek = time.Date(2017, 10, 29, 12, 0, 0, 0, locationBerlin)
    assert(With(dstEndOfWeek).EndOfWeek(), "2017-11-04 23:59:59.999999999", "EndOfWeek")

    assert(With(n).EndOfMonth(), "2013-11-30 23:59:59.999999999", "EndOfMonth")

    assert(With(n).EndOfQuarter(), "2013-12-31 23:59:59.999999999", "EndOfQuarter")

    assert(With(n).EndOfHalf(), "2013-12-31 23:59:59.999999999", "EndOfHalf")

    assert(With(n.AddDate(0, -1, 0)).EndOfQuarter(), "2013-12-31 23:59:59.999999999", "EndOfQuarter")

    assert(With(n.AddDate(0, 1, 0)).EndOfQuarter(), "2013-12-31 23:59:59.999999999", "EndOfQuarter")

    assert(With(n.AddDate(0, 1, 0)).EndOfHalf(), "2013-12-31 23:59:59.999999999", "EndOfHalf")

    assert(With(n).EndOfYear(), "2013-12-31 23:59:59.999999999", "EndOfYear")

    n1 := time.Date(2013, 02, 18, 17, 51, 49, 123456789, time.UTC)
    assert(With(n1).EndOfMonth(), "2013-02-28 23:59:59.999999999", "EndOfMonth for 2013/02")

    n2 := time.Date(1900, 02, 18, 17, 51, 49, 123456789, time.UTC)
    assert(With(n2).EndOfMonth(), "1900-02-28 23:59:59.999999999", "EndOfMonth")
}

func TestMondayAndSunday(t *testing.T) {
    assert := assertT(t)

    n := time.Date(2013, 11, 19, 17, 51, 49, 123456789, time.UTC)
    n2 := time.Date(2013, 11, 24, 17, 51, 49, 123456789, time.UTC)
    nDst := time.Date(2017, 10, 29, 10, 0, 0, 0, locationBerlin)

    assert(With(n).Monday(), "2013-11-18 00:00:00", "Monday")

    assert(With(n2).Monday(), "2013-11-18 00:00:00", "Monday")

    assert(With(timeCaracas).Monday(), "2015-12-28 00:00:00", "Monday Caracas")

    assert(With(nDst).Monday(), "2017-10-23 00:00:00", "Monday DST")

    assert(With(n).Sunday(), "2013-11-24 00:00:00", "Sunday")

    assert(With(n2).Sunday(), "2013-11-24 00:00:00", "Sunday")

    assert(With(timeCaracas).Sunday(), "2016-01-03 00:00:00", "Sunday Caracas")

    assert(With(nDst).Sunday(), "2017-10-29 00:00:00", "Sunday DST")

    assert(With(n).EndOfSunday(), "2013-11-24 23:59:59.999999999", "EndOfSunday")

    assert(With(timeCaracas).EndOfSunday(), "2016-01-03 23:59:59.999999999", "EndOfSunday Caracas")

    assert(With(nDst).EndOfSunday(), "2017-10-29 23:59:59.999999999", "EndOfSunday DST")

    assert(With(n).BeginningOfWeek(), "2013-11-17 00:00:00", "BeginningOfWeek, FirstDayMonday")

    WeekStartDay = time.Monday
    assert(With(n).BeginningOfWeek(), "2013-11-18 00:00:00", "BeginningOfWeek, FirstDayMonday")
}

func TestParse(t *testing.T) {
    assert := assertT(t)

    n := time.Date(2013, 11, 18, 17, 51, 49, 123456789, time.UTC)

    assert(With(n).MustParse("2002"), "2002-01-01 00:00:00", "Parse 2002")

    assert(With(n).MustParse("2002-10"), "2002-10-01 00:00:00", "Parse 2002-10")

    assert(With(n).MustParse("2002-10-12"), "2002-10-12 00:00:00", "Parse 2002-10-12")

    assert(With(n).MustParse("2002-10-12 22"), "2002-10-12 22:00:00", "Parse 2002-10-12 22")

    assert(With(n).MustParse("2002-10-12 22:14"), "2002-10-12 22:14:00", "Parse 2002-10-12 22:14")

    assert(With(n).MustParse("2002-10-12 2:4"), "2002-10-12 02:04:00", "Parse 2002-10-12 2:4")

    assert(With(n).MustParse("2002-10-12 02:04"), "2002-10-12 02:04:00", "Parse 2002-10-12 02:04")

    assert(With(n).MustParse("2002-10-12 22:14:56"), "2002-10-12 22:14:56", "Parse 2002-10-12 22:14:56")

    assert(With(n).MustParse("2002-10-12 00:14:56"), "2002-10-12 00:14:56", "Parse 2002-10-12 00:14:56")

    assert(With(n).MustParse("2013-12-19 23:28:09.999999999 +0800 CST"), "2013-12-19 23:28:09.999999999", "Parse two strings 2013-12-19 23:28:09.999999999 +0800 CST")

    assert(With(n).MustParse("10-12"), "2013-10-12 00:00:00", "Parse 10-12")

    assert(With(n).MustParse("18"), "2013-11-18 18:00:00", "Parse 18 as hour")

    assert(With(n).MustParse("18:20"), "2013-11-18 18:20:00", "Parse 18:20")

    assert(With(n).MustParse("00:01"), "2013-11-18 00:01:00", "Parse 00:01")

    assert(With(n).MustParse("00:00:00"), "2013-11-18 00:00:00", "Parse 00:00:00")

    assert(With(n).MustParse("18:20:39"), "2013-11-18 18:20:39", "Parse 18:20:39")

    assert(With(n).MustParse("18:20:39", "2011-01-01"), "2011-01-01 18:20:39", "Parse two strings 18:20:39, 2011-01-01")

    assert(With(n).MustParse("2011-1-1", "18:20:39"), "2011-01-01 18:20:39", "Parse two strings 2011-01-01, 18:20:39")

    assert(With(n).MustParse("2011-01-01", "18"), "2011-01-01 18:00:00", "Parse two strings 2011-01-01, 18")

    TimeFormats = append(TimeFormats, "02 Jan 15:04")
    assert(With(n).MustParse("04 Feb 12:09"), "2013-02-04 12:09:00", "Parse 04 Feb 12:09 with specified format")

    assert(With(n).MustParse("23:28:9 Dec 19, 2013 PST"), "2013-12-19 23:28:09", "Parse 23:28:9 Dec 19, 2013 PST")

    if With(n).MustParse("23:28:9 Dec 19, 2013 PST").Location().String() != "PST" {
        t.Errorf("Parse 23:28:9 Dec 19, 2013 PST shouldn't lose time zone")
    }

    n2 := With(n).MustParse("23:28:9 Dec 19, 2013 PST")
    if With(n2).MustParse("10:20").Location().String() != "PST" {
        t.Errorf("Parse 10:20 shouldn't change time zone")
    }

    TimeFormats = append(TimeFormats, "2006-01-02T15:04:05.0")
    if MustParseInLocation(time.UTC, "2018-02-13T15:17:06.0").String() != "2018-02-13 15:17:06 +0000 UTC" {
        t.Errorf("ParseInLocation 2018-02-13T15:17:06.0")
    }

    TimeFormats = append(TimeFormats, "2006-01-02 15:04:05.000")
    assert(With(n).MustParse("2018-04-20 21:22:23.473"), "2018-04-20 21:22:23.473", "Parse 2018/04/20 21:22:23.473")

    TimeFormats = append(TimeFormats, "15:04:05.000")
    assert(With(n).MustParse("13:00:01.365"), "2013-11-18 13:00:01.365", "Parse 13:00:01.365")

    TimeFormats = append(TimeFormats, "2006-01-02 15:04:05.000000")
    assert(With(n).MustParse("2010-01-01 07:24:23.131384"), "2010-01-01 07:24:23.131384", "Parse 2010-01-01 07:24:23.131384")
    assert(With(n).MustParse("00:00:00.182736"), "2013-11-18 00:00:00.182736", "Parse 00:00:00.182736")

    n3 := MustParse("2017-12-11T10:25:49Z")
    if n3.Location() != time.UTC {
        t.Errorf("time location should be UTC, but got %v", n3.Location())
    }
}

func TestBetween(t *testing.T) {
    tm := time.Date(2015, 06, 30, 17, 51, 49, 123456789, time.Now().Location())
    if !With(tm).Between("23:28:9 Dec 19, 2013 PST", "23:28:9 Dec 19, 2015 PST") {
        t.Errorf("Between")
    }

    if !With(tm).Between("2015-05-12 12:20", "2015-06-30 17:51:50") {
        t.Errorf("Between")
    }
}

func TestConfig(t *testing.T) {
    assert := assertT(t)

    location, err := time.LoadLocation("Asia/Shanghai")
    if err != nil {
        t.Errorf("load location for Asia/Shanghai should returns no error, but got %v", err)
    }

    myConfig := Config{
        WeekStartDay: time.Monday,
        TimeLocation: location,
        TimeFormats:  []string{"2006-01-02 15:04:05"},
    }

    n := time.Date(2013, 11, 18, 17, 51, 49, 123456789, time.Now().Location()) // // 2013-11-18 17:51:49.123456789 Mon
    assert(myConfig.With(n).BeginningOfWeek(), "2013-11-18 00:00:00", "BeginningOfWeek, FirstDayMonday")

    if result, _ := myConfig.Parse("2018-02-13 15:17:06"); result.String() != "2018-02-13 15:17:06 +0800 CST" {
        t.Errorf("ParseInLocation 2018-02-13T15:17:06.0, got %v", result)
    }

    if result := myConfig.MustParse("2018-02-13 15:17:06"); result.String() != "2018-02-13 15:17:06 +0800 CST" {
        t.Errorf("ParseInLocation 2018-02-13T15:17:06.0, got %v", result)
    }
}

func main() {
    time.Now() // 2013-11-18 17:51:49.123456789 Mon

    BeginningOfMinute() // 2013-11-18 17:51:00 Mon
    BeginningOfHour()   // 2013-11-18 17:00:00 Mon
    BeginningOfDay()    // 2013-11-18 00:00:00 Mon
    BeginningOfWeek()   // 2013-11-17 00:00:00 Sun

    WeekStartDay = time.Monday // Set Monday as first day
    BeginningOfWeek()          // 2013-11-18 00:00:00 Mon
    BeginningOfMonth()         // 2013-11-01 00:00:00 Fri
    BeginningOfQuarter()       // 2013-10-01 00:00:00 Tue
    BeginningOfYear()          // 2013-01-01 00:00:00 Tue

    EndOfMinute() // 2013-11-18 17:51:59.999999999 Mon
    EndOfHour()   // 2013-11-18 17:59:59.999999999 Mon
    EndOfDay()    // 2013-11-18 23:59:59.999999999 Mon
    EndOfWeek()   // 2013-11-23 23:59:59.999999999 Sat

    WeekStartDay = time.Monday // Set Monday as first day
    EndOfWeek()                // 2013-11-24 23:59:59.999999999 Sun
    EndOfMonth()               // 2013-11-30 23:59:59.999999999 Sat
    EndOfQuarter()             // 2013-12-31 23:59:59.999999999 Tue
    EndOfYear()                // 2013-12-31 23:59:59.999999999 Tue

    // Use another time
    t := time.Date(2013, 02, 18, 17, 51, 49, 123456789, time.UTC)
    With(t).EndOfMonth() // 2013-02-28 23:59:59.999999999 Thu

    Monday()      // 2013-11-18 00:00:00 Mon
    Sunday()      // 2013-11-24 00:00:00 Sun
    EndOfSunday() // 2013-11-24 23:59:59.999999999 Sun
}

Index

Examples

Package Files

main.go now.go

Variables

var TimeFormats = []string{
    "2006", "2006-1", "2006-1-2", "2006-1-2 15", "2006-1-2 15:4", "2006-1-2 15:4:5", "1-2",
    "15:4:5", "15:4", "15",
    "15:4:5 Jan 2, 2006 MST", "2006-01-02 15:04:05.999999999 -0700 MST", "2006-01-02T15:04:05-07:00",
    "2006.1.2", "2006.1.2 15:04:05", "2006.01.02", "2006.01.02 15:04:05",
    "1/2/2006", "1/2/2006 15:4:5", "2006/01/02", "2006/01/02 15:04:05",
    time.ANSIC, time.UnixDate, time.RubyDate, time.RFC822, time.RFC822Z, time.RFC850,
    time.RFC1123, time.RFC1123Z, time.RFC3339, time.RFC3339Nano,
    time.Kitchen, time.Stamp, time.StampMilli, time.StampMicro, time.StampNano,
}

TimeFormats default time formats will be parsed as

var WeekStartDay = time.Sunday

WeekStartDay set week start day, default is sunday

func BeginningOfDay Uses

func BeginningOfDay() time.Time

BeginningOfDay beginning of day

func BeginningOfHour Uses

func BeginningOfHour() time.Time

BeginningOfHour beginning of hour

func BeginningOfMinute Uses

func BeginningOfMinute() time.Time

BeginningOfMinute beginning of minute

func BeginningOfMonth Uses

func BeginningOfMonth() time.Time

BeginningOfMonth beginning of month

func BeginningOfQuarter Uses

func BeginningOfQuarter() time.Time

BeginningOfQuarter beginning of quarter

func BeginningOfWeek Uses

func BeginningOfWeek() time.Time

BeginningOfWeek beginning of week

func BeginningOfYear Uses

func BeginningOfYear() time.Time

BeginningOfYear beginning of year

func Between Uses

func Between(time1, time2 string) bool

Between check now between the begin, end time or not

func EndOfDay Uses

func EndOfDay() time.Time

EndOfDay end of day

func EndOfHour Uses

func EndOfHour() time.Time

EndOfHour end of hour

func EndOfMinute Uses

func EndOfMinute() time.Time

EndOfMinute end of minute

func EndOfMonth Uses

func EndOfMonth() time.Time

EndOfMonth end of month

func EndOfQuarter Uses

func EndOfQuarter() time.Time

EndOfQuarter end of quarter

func EndOfSunday Uses

func EndOfSunday() time.Time

EndOfSunday end of sunday

func EndOfWeek Uses

func EndOfWeek() time.Time

EndOfWeek end of week

func EndOfYear Uses

func EndOfYear() time.Time

EndOfYear end of year

func Monday Uses

func Monday() time.Time

Monday monday

func MustParse Uses

func MustParse(strs ...string) time.Time

MustParse must parse string to time or will panic

func MustParseInLocation Uses

func MustParseInLocation(loc *time.Location, strs ...string) time.Time

MustParseInLocation must parse string to time in location or will panic

func Parse Uses

func Parse(strs ...string) (time.Time, error)

Parse parse string to time

func ParseInLocation Uses

func ParseInLocation(loc *time.Location, strs ...string) (time.Time, error)

ParseInLocation parse string to time in location

func Sunday Uses

func Sunday() time.Time

Sunday sunday

type Config Uses

type Config struct {
    WeekStartDay time.Weekday
    TimeLocation *time.Location
    TimeFormats  []string
}

Config configuration for now package

var DefaultConfig *Config

DefaultConfig default config

func (*Config) MustParse Uses

func (config *Config) MustParse(strs ...string) time.Time

MustParse must parse string to time or will panic

func (*Config) Parse Uses

func (config *Config) Parse(strs ...string) (time.Time, error)

Parse parse string to time based on configuration

func (*Config) With Uses

func (config *Config) With(t time.Time) *Now

New initialize Now based on configuration

type Now Uses

type Now struct {
    time.Time
    *Config
}

Now now struct

func New Uses

func New(t time.Time) *Now

New initialize Now with time

func With Uses

func With(t time.Time) *Now

With initialize Now with time

func (*Now) BeginningOfDay Uses

func (now *Now) BeginningOfDay() time.Time

BeginningOfDay beginning of day

func (*Now) BeginningOfHalf Uses

func (now *Now) BeginningOfHalf() time.Time

BeginningOfHalf beginning of half year

func (*Now) BeginningOfHour Uses

func (now *Now) BeginningOfHour() time.Time

BeginningOfHour beginning of hour

func (*Now) BeginningOfMinute Uses

func (now *Now) BeginningOfMinute() time.Time

BeginningOfMinute beginning of minute

func (*Now) BeginningOfMonth Uses

func (now *Now) BeginningOfMonth() time.Time

BeginningOfMonth beginning of month

func (*Now) BeginningOfQuarter Uses

func (now *Now) BeginningOfQuarter() time.Time

BeginningOfQuarter beginning of quarter

func (*Now) BeginningOfWeek Uses

func (now *Now) BeginningOfWeek() time.Time

BeginningOfWeek beginning of week

func (*Now) BeginningOfYear Uses

func (now *Now) BeginningOfYear() time.Time

BeginningOfYear BeginningOfYear beginning of year

func (*Now) Between Uses

func (now *Now) Between(begin, end string) bool

Between check time between the begin, end time or not

func (*Now) EndOfDay Uses

func (now *Now) EndOfDay() time.Time

EndOfDay end of day

func (*Now) EndOfHalf Uses

func (now *Now) EndOfHalf() time.Time

EndOfHalf end of half year

func (*Now) EndOfHour Uses

func (now *Now) EndOfHour() time.Time

EndOfHour end of hour

func (*Now) EndOfMinute Uses

func (now *Now) EndOfMinute() time.Time

EndOfMinute end of minute

func (*Now) EndOfMonth Uses

func (now *Now) EndOfMonth() time.Time

EndOfMonth end of month

func (*Now) EndOfQuarter Uses

func (now *Now) EndOfQuarter() time.Time

EndOfQuarter end of quarter

func (*Now) EndOfSunday Uses

func (now *Now) EndOfSunday() time.Time

EndOfSunday end of sunday

func (*Now) EndOfWeek Uses

func (now *Now) EndOfWeek() time.Time

EndOfWeek end of week

func (*Now) EndOfYear Uses

func (now *Now) EndOfYear() time.Time

EndOfYear end of year

func (*Now) Monday Uses

func (now *Now) Monday() time.Time

Monday monday

func (*Now) MustParse Uses

func (now *Now) MustParse(strs ...string) (t time.Time)

MustParse must parse string to time or it will panic

func (*Now) Parse Uses

func (now *Now) Parse(strs ...string) (t time.Time, err error)

Parse parse string to time

func (*Now) Sunday Uses

func (now *Now) Sunday() time.Time

Sunday sunday

Package now imports 3 packages (graph) and is imported by 150 packages. Updated 2020-03-09. Refresh now. Tools for package owners.