Datetime

Package datetime supports date and time format and compare.

Source:

Usage:

import (
    "github.com/duke-git/lancet/v2/datetime"
)

Index

AddDay
AddHour
AddMinute
AddYear
BeginOfMinute
BeginOfHour
BeginOfDay
BeginOfWeek
BeginOfMonth
BeginOfYear
EndOfMinute
EndOfHour
EndOfDay
EndOfWeek
EndOfMonth
EndOfYear
GetNowDate
GetNowTime
GetNowDateTime
GetTodayStartTime
GetTodayEndTime
GetZeroHourTimestamp
GetNightTimestamp
FormatTimeToStr
FormatStrToTime
NewUnixNow
NewUnix
NewFormat
NewISO8601
ToUnix
ToFormat
ToFormatForTpl
ToIso8601
IsLeapYear
BetweenSeconds
DayOfYear
IsWeekend^deprecated
NowDateOrTime
Timestamp
TimestampMilli
TimestampMicro
TimestampNano
TrackFuncTime
DaysBetween
GenerateDatetimesBetween

Documentation

Note:

In below functions, the format string param should be one of flows value (case no sensitive):

yyyy-mm-dd hh:mm:ss
yyyy-mm-dd hh:mm
yyyy-mm-dd hh
yyyy-mm-dd
yyyy-mm
mm-dd
dd-mm-yy hh:mm:ss
yyyy/mm/dd hh:mm:ss
yyyy/mm/dd hh:mm
yyyy/mm/dd hh
yyyy/mm/dd
yyyy/mm
mm/dd
dd/mm/yy hh:mm:ss
yyyymmdd
mmddyy
yyyy
yy
mm
hh:mm:ss
hh:mm
mm:ss

AddDay

Add or sub days to time.

Signature:

func AddDay(t time.Time, day int64) time.Time

Example:Run

package main

import (
    "fmt"
    "time"
    "github.com/duke-git/lancet/v2/datetime"
)

func main() {
    now := time.Now()

    tomorrow := datetime.AddDay(now, 1)
    diff1 := tomorrow.Sub(now)

    yesterday := datetime.AddDay(now, -1)
    diff2 := yesterday.Sub(now)

    fmt.Println(diff1)
    fmt.Println(diff2)

    // Output:
    // 24h0m0s
    // -24h0m0s
}

AddHour

Add or sub hours to time.

Signature:

func AddHour(t time.Time, hour int64) time.Time

Example:Run

package main

import (
    "fmt"
    "time"
    "github.com/duke-git/lancet/v2/datetime"
)

func main() {
    now := time.Now()

    after2Hours := datetime.AddHour(now, 2)
    diff1 := after2Hours.Sub(now)

    before2Hours := datetime.AddHour(now, -2)
    diff2 := before2Hours.Sub(now)

    fmt.Println(diff1)
    fmt.Println(diff2)

    // Output:
    // 2h0m0s
    // -2h0m0s
}

AddMinute

Add or sub minutes to time.

Signature:

func AddMinute(t time.Time, minute int64) time.Time

Example:Run

package main

import (
    "fmt"
    "time"
    "github.com/duke-git/lancet/v2/datetime"
)

func main() {
    now := time.Now()

    after2Minutes := datetime.AddMinute(now, 2)
    diff1 := after2Minutes.Sub(now)

    before2Minutes := datetime.AddMinute(now, -2)
    diff2 := before2Minutes.Sub(now)

    fmt.Println(diff1)
    fmt.Println(diff2)

    // Output:
    // 2m0s
    // -2m0s
}

AddYear

Add or sub year to the time.

Signature:

func AddYear(t time.Time, year int64) time.Time

Example:Run

package main

import (
    "fmt"
    "time"
    "github.com/duke-git/lancet/v2/datetime"
)

func main() {
    now := time.Now()

    after1Year := datetime.AddYear(now, 1)
    diff1 := after1Year.Sub(now)

    before1Year := datetime.AddYear(now, -1)
    diff2 := before1Year.Sub(now)

    fmt.Println(diff1)
    fmt.Println(diff2)

    // Output:
    // 8760h0m0s
    // -8760h0m0s
}

BeginOfMinute

Return beginning minute time of day.

Signature:

func BeginOfMinute(t time.Time) time.Time

Example:Run

package main

import (
    "fmt"
    "time"
    "github.com/duke-git/lancet/v2/datetime"
)

func main() {
    input := time.Date(2023, 1, 8, 18, 50, 10, 100, time.UTC)
    result := datetime.BeginOfMinute(input)

    fmt.Println(result)

    // Output:
    // 2023-01-08 18:50:00 +0000 UTC
}

BeginOfHour

Return zero time of day.

Signature:

func BeginOfHour(t time.Time) time.Time

Example:Run

package main

import (
    "fmt"
    "time"
    "github.com/duke-git/lancet/v2/datetime"
)

func main() {
    input := time.Date(2023, 1, 8, 18, 50, 10, 100, time.UTC)
    result := datetime.BeginOfHour(input)

    fmt.Println(result)

    // Output:
    // 2023-01-08 18:00:00 +0000 UTC
}

BeginOfDay

Return begin time of day.

Signature:

func BeginOfDay(t time.Time) time.Time

Example:Run

package main

import (
    "fmt"
    "time"
    "github.com/duke-git/lancet/v2/datetime"
)

func main() {
    input := time.Date(2023, 1, 8, 18, 50, 10, 100, time.UTC)
    result := datetime.BeginOfDay(input)

    fmt.Println(result)

    // Output:
    // 2023-01-08 00:00:00 +0000 UTC
}

BeginOfWeek

Return beginning time of week, week begin from Sunday.

Signature:

func BeginOfWeek(t time.Time, beginFrom ...time.Weekday) time.Time

Example:Run

package main

import (
    "fmt"
    "time"
    "github.com/duke-git/lancet/v2/datetime"
)

func main() {
    input := time.Date(2023, 1, 8, 18, 50, 10, 100, time.UTC)
    result := datetime.BeginOfWeek(input)

    fmt.Println(result)

    // Output:
    // 2023-01-08 00:00:00 +0000 UTC
}

BeginOfMonth

Return beginning time of month

Signature:

func BeginOfMonth(t time.Time) time.Time

Example:Run

package main

import (
    "fmt"
    "time"
    "github.com/duke-git/lancet/v2/datetime"
)

func main() {
    input := time.Date(2023, 1, 8, 18, 50, 10, 100, time.UTC)
    result := datetime.BeginOfMonth(input)

    fmt.Println(result)

    // Output:
    // 2023-01-01 00:00:00 +0000 UTC
}

BeginOfYear

Return beginning time of year.

Signature:

func BeginOfYear(t time.Time) time.Time

Example:Run

package main

import (
    "fmt"
    "time"
    "github.com/duke-git/lancet/v2/datetime"
)

func main() {
    input := time.Date(2023, 1, 8, 18, 50, 10, 100, time.UTC)
    result := datetime.BeginOfYear(input)

    fmt.Println(result)

    // Output:
    // 2023-01-01 00:00:00 +0000 UTC
}

EndOfMinute

Return end time minute of day.

Signature:

func EndOfMinute(t time.Time) time.Time

Example:Run

package main

import (
    "fmt"
    "time"
    "github.com/duke-git/lancet/v2/datetime"
)

func main() {
    input := time.Date(2023, 1, 8, 18, 50, 10, 100, time.UTC)
    result := datetime.EndOfMinute(input)

    fmt.Println(result)

    // Output:
    // 2023-01-08 18:50:59.999999999 +0000 UTC
}

EndOfHour

Return end time hour of day.

Signature:

func EndOfHour(t time.Time) time.Time

Example:Run

package main

import (
    "fmt"
    "time"
    "github.com/duke-git/lancet/v2/datetime"
)

func main() {
    input := time.Date(2023, 1, 8, 18, 50, 10, 100, time.UTC)
    result := datetime.EndOfHour(input)

    fmt.Println(result)

    // Output:
    // 2023-01-08 18:59:59.999999999 +0000 UTC
}

EndOfDay

Return end time hour of day.

Signature:

func EndOfDay(t time.Time) time.Time

Example:Run

package main

import (
    "fmt"
    "time"
    "github.com/duke-git/lancet/v2/datetime"
)

func main() {
    input := time.Date(2023, 1, 8, 18, 50, 10, 100, time.UTC)
    result := datetime.EndOfDay(input)

    fmt.Println(result)

    // Output:
    // 2023-01-08 23:59:59.999999999 +0000 UTC
}

EndOfWeek

Return end time of week, week end with Saturday.

Signature:

func EndOfWeek(t time.Time, endWith ...time.Weekday) time.Time

Example:Run

package main

import (
    "fmt"
    "time"
    "github.com/duke-git/lancet/v2/datetime"
)

func main() {
    input := time.Date(2023, 1, 8, 18, 50, 10, 100, time.UTC)
    result := datetime.EndOfWeek(input)

    fmt.Println(result)

    // Output:
    // 2023-01-14 23:59:59.999999999 +0000 UTC
}

EndOfMonth

Return end time of month

Signature:

func EndOfMonth(t time.Time) time.Time

Example:Run

package main

import (
    "fmt"
    "time"
    "github.com/duke-git/lancet/v2/datetime"
)

func main() {
    input := time.Date(2023, 1, 8, 18, 50, 10, 100, time.UTC)
    result := datetime.EndOfMonth(input)

    fmt.Println(result)

    // Output:
    // 2023-01-31 23:59:59.999999999 +0000 UTC
}

EndOfYear

Return beginning time of year.

Signature:

func EndOfYear(t time.Time) time.Time

Example:Run

package main

import (
    "fmt"
    "time"
    "github.com/duke-git/lancet/v2/datetime"
)

func main() {
    input := time.Date(2023, 1, 8, 18, 50, 10, 100, time.UTC)
    result := datetime.EndOfYear(input)

    fmt.Println(result)

    // Output:
    // 2023-12-31 23:59:59.999999999 +0000 UTC
}

GetNowDate

Get current date string, format is yyyy-mm-dd.

Signature:

func GetNowDate() string

Example:Run

package main

import (
    "fmt"
    "github.com/duke-git/lancet/v2/datetime"
)

func main() {
    currentDate := datetime.GetNowDate()
    fmt.Println(currentDate)

    // Output:
    // 2022-01-28
}

GetNowTime

Get current time string, format is hh:mm:ss.

Signature:

func GetNowTime() string

Example:Run

package main

import (
    "fmt"
    "github.com/duke-git/lancet/v2/datetime"
)

func main() {
    currentTime := datetime.GetNowTime()
    fmt.Println(currentTime) // 15:57:33

    // Output:
    // 15:57:33
}

GetNowDateTime

Get current date time string, format is yyyy-mm-dd hh:mm:ss.

Signature:

func GetNowDateTime() string

Example:Run

package main

import (
    "fmt"
    "github.com/duke-git/lancet/v2/datetime"
)

func main() {
    current := datetime.GetNowDateTime()
    fmt.Println(current)

    // Output:
    // 2022-01-28 15:59:33
}

GetTodayStartTime

Return the start time of today, format: yyyy-mm-dd 00:00:00.

Signature:

func GetTodayStartTime() string

Example:Run

package main

import (
    "fmt"
    "github.com/duke-git/lancet/v2/datetime"
)

func main() {
    startTime := datetime.GetTodayStartTime()
    fmt.Println(startTime)

    // Output:
    // 2023-06-29 00:00:00
}

GetTodayEndTime

Return the end time of today, format: yyyy-mm-dd 23:59:59.

Signature:

func GetTodayEndTime() string

Example:Run

package main

import (
    "fmt"
    "github.com/duke-git/lancet/v2/datetime"
)

func main() {
    endTime := datetime.GetTodayEndTime()
    fmt.Println(endTime)

    // Output:
    // 2023-06-29 23:59:59
}

GetZeroHourTimestamp

Return timestamp of zero hour (timestamp of 00:00).

Signature:

func GetZeroHourTimestamp() int64

Example:Run

package main

import (
    "fmt"
    "github.com/duke-git/lancet/v2/datetime"
)

func main() {
    zeroTime := datetime.GetZeroHourTimestamp()
    fmt.Println(zeroTime)

    // Output:
    // 1643299200
}

GetNightTimestamp

Return timestamp of zero hour (timestamp of 23:59).

Signature:

func GetNightTimestamp() int64

Example:Run

package main

import (
    "fmt"
    "github.com/duke-git/lancet/v2/datetime"
)

func main() {
    nightTime := datetime.GetNightTimestamp()
    fmt.Println(nightTime)

    // Output:
    // 1643385599
}

FormatTimeToStr

Format time to string, `format` param specification see note 1.

Signature:

func FormatTimeToStr(t time.Time, format string, timezone ...string) string

Example:Run

package main

import (
    "fmt"
    "time"
    "github.com/duke-git/lancet/v2/datetime"
)

func main() {
    t, _ := time.Parse("2006-01-02 15:04:05", "2021-01-02 16:04:08")

    result1 := datetime.FormatTimeToStr(t, "yyyy-mm-dd hh:mm:ss")
    result2 := datetime.FormatTimeToStr(t, "yyyy-mm-dd")
    result3 := datetime.FormatTimeToStr(t, "dd-mm-yy hh:mm:ss")

    fmt.Println(result1)
    fmt.Println(result2)
    fmt.Println(result3)

    // Output:
    // 2021-01-02 16:04:08
    // 2021-01-02
    // 02-01-21 16:04:08
}

FormatStrToTime

Format string to time, `format` param specification see note 1.

Signature:

func FormatStrToTime(str, format string, timezone ...string) (time.Time, error)

Example:Run

package main

import (
    "fmt"
    "github.com/duke-git/lancet/v2/datetime"
)

func main() {
    result1, _ := datetime.FormatStrToTime("2021-01-02 16:04:08", "yyyy-mm-dd hh:mm:ss")
    result2, _ := datetime.FormatStrToTime("2021-01-02", "yyyy-mm-dd")
    result3, _ := datetime.FormatStrToTime("02-01-21 16:04:08", "dd-mm-yy hh:mm:ss")

    fmt.Println(result1)
    fmt.Println(result2)
    fmt.Println(result3)

    // Output:
    // 2021-01-02 16:04:08 +0000 UTC
    // 2021-01-02 00:00:00 +0000 UTC
    // 2021-01-02 16:04:08 +0000 UTC
}

NewUnixNow

Return unix timestamp of current time

Signature:

type theTime struct {
    unix int64
}
func NewUnixNow() *theTime

Example:Run

package main

import (
    "fmt"
    "github.com/duke-git/lancet/v2/datetime"
)

func main() {
    tm := datetime.NewUnixNow()
    fmt.Println(tm)

    // Output:
    // &{1647597438}
}

NewUnix

Return unix timestamp of specified int64 value.

Signature:

type theTime struct {
    unix int64
}
func NewUnix(unix int64) *theTime

Example:Run

package main

import (
    "fmt"
    "github.com/duke-git/lancet/v2/datetime"
)

func main() {
    tm := datetime.NewUnix(1647597438)
    fmt.Println(tm)

    // Output:
    // &{1647597438}
}

NewFormat

Return unix timestamp of specified time string, t should be "yyyy-mm-dd hh:mm:ss".

Signature:

type theTime struct {
    unix int64
}
func NewFormat(t string) (*theTime, error)

Example:Run

package main

import (
    "fmt"
    "github.com/duke-git/lancet/v2/datetime"
)

func main() {
    tm, err := datetime.NewFormat("2022-03-18 17:04:05")
    fmt.Println(tm)

    // Output:
    // &{1647594245}
}

NewISO8601

Return unix timestamp of specified iso8601 time string.

Signature:

type theTime struct {
    unix int64
}
func NewISO8601(iso8601 string) (*theTime, error)

Example:Run

package main

import (
    "fmt"
    "github.com/duke-git/lancet/v2/datetime"
)

func main() {
    tm, err := datetime.NewISO8601("2006-01-02T15:04:05.999Z")
    fmt.Println(tm)

    // Output:
    // &{1136214245}
}

ToUnix

Return unix timestamp.

Signature:

func (t *theTime) ToUnix() int64

Example:Run

package main

import (
    "fmt"
    "github.com/duke-git/lancet/v2/datetime"
)

func main() {
    tm := datetime.NewUnixNow()
    fmt.Println(tm.ToUnix())

    // Output:
    // 1647597438
}

ToFormat

Return time string 'yyyy-mm-dd hh:mm:ss'.

Signature:

func (t *theTime) ToFormat() string

Example:Run

package main

import (
    "fmt"
    "github.com/duke-git/lancet/v2/datetime"
)

func main() {
    tm, _ := datetime.NewFormat("2022-03-18 17:04:05")
    fmt.Println(tm.ToFormat())

    // Output:
    // 2022-03-18 17:04:05
}

ToFormatForTpl

Return the time string which format is specified tpl.

Signature:

func (t *theTime) ToFormatForTpl(tpl string) string

Example:Run

package main

import (
    "fmt"
    "github.com/duke-git/lancet/v2/datetime"
)

func main() {
    tm, _ := datetime.NewFormat("2022-03-18 17:04:05")
    ts := tm.ToFormatForTpl("2006/01/02 15:04:05")
    fmt.Println(ts)

    // Output:
    // 2022/03/18 17:04:05
}

ToIso8601

Return iso8601 time string.

Signature:

func (t *theTime) ToIso8601() string

Example:Run

package main

import (
    "fmt"
    "github.com/duke-git/lancet/v2/datetime"
)

func main() {
    tm, _ := datetime.NewISO8601("2006-01-02T15:04:05.999Z")
    ts := tm.ToIso8601()
    fmt.Println(ts)

    // Output:
    // 2006-01-02T23:04:05+08:00
}

IsLeapYear

check if param `year` is leap year or not.

Signature:

func IsLeapYear(year int) bool

Example:Run

package main

import (
    "fmt"
    "github.com/duke-git/lancet/v2/datetime"
)

func main() {
    result1 := datetime.IsLeapYear(2000)
    result2 := datetime.IsLeapYear(2001)

    fmt.Println(result1)
    fmt.Println(result2)

    // Output:
    // true
    // false
}

BetweenSeconds

Return the number of seconds between two times.

Signature:

func BetweenSeconds(t1 time.Time, t2 time.Time) int64

Example:Run

package main

import (
    "fmt"
    "github.com/duke-git/lancet/v2/datetime"
)

func main() {
    today := time.Now()
    tomorrow := datetime.AddDay(today, 1)
    yesterday := datetime.AddDay(today, -1)

    result1 := datetime.BetweenSeconds(today, tomorrow)
    result2 := datetime.BetweenSeconds(today, yesterday)

    fmt.Println(result1)
    fmt.Println(result2)

    // Output:
    // 86400
    // -86400
}

DayOfYear

Returns which day of the year the parameter date `t` is.

Signature:

func DayOfYear(t time.Time) int

Example:Run

package main

import (
    "fmt"
    "github.com/duke-git/lancet/v2/datetime"
)

func main() {
    date1 := time.Date(2023, 02, 01, 1, 1, 1, 0, time.Local)
    result1 := datetime.DayOfYear(date1)

    date2 := time.Date(2023, 01, 02, 1, 1, 1, 0, time.Local)
    result2 := datetime.DayOfYear(date2)

    date3 := time.Date(2023, 01, 01, 1, 1, 1, 0, time.Local)
    result3 := datetime.DayOfYear(date3)

    fmt.Println(result1)
    fmt.Println(result2)
    fmt.Println(result3)

    // Output:
    // 31
    // 1
    // 0
}

IsWeekend(Deprecated, Use '== Weekday' instead)

Checks if passed time is weekend or not.

Signature:

func IsWeekend(t time.Time) bool

Example:Run

package main

import (
    "fmt"
    "github.com/duke-git/lancet/v2/datetime"
)

func main() {
    date1 := time.Date(2023, 06, 03, 0, 0, 0, 0, time.Local)
    date2 := time.Date(2023, 06, 04, 0, 0, 0, 0, time.Local)
    date3 := time.Date(2023, 06, 02, 0, 0, 0, 0, time.Local)

    result1 := datetime.IsWeekend(date1)
    result2 := datetime.IsWeekend(date2)
    result3 := datetime.IsWeekend(date3)

    fmt.Println(result1)
    fmt.Println(result2)
    fmt.Println(result3)

    // Output:
    // true
    // true
    // false
}

NowDateOrTime

Return current datetime with specific format and timezone.

Signature:

func NowDateOrTime(format string, timezone ...string) string

Example:Run

package main

import (
    "fmt"
    "github.com/duke-git/lancet/v2/datetime"
)

func main() {
    result1 := datetime.NowDateOrTime("yyyy-mm-dd hh:mm:ss")

	result2 := datetime.NowDateOrTime("yyyy-mm-dd hh:mm:ss", "EST")

    fmt.Println(result1)
    fmt.Println(result2)

    // Output:
    // 2023-07-26 15:01:30
    // 2023-07-26 02:01:30
}

Timestamp

Return current second timestamp.

Signature:

func Timestamp(timezone ...string) int64

Example:Run

package main

import (
    "fmt"
    "github.com/duke-git/lancet/v2/datetime"
)

func main() {
    ts := datetime.Timestamp()

    fmt.Println(ts)

    // Output:
    // 1690363051
}

TimestampMilli

Return current mill second timestamp.

Signature:

func TimestampMilli(timezone ...string) int64

Example:Run

package main

import (
    "fmt"
    "github.com/duke-git/lancet/v2/datetime"
)

func main() {
    ts := datetime.TimestampMilli()

    fmt.Println(ts)

    // Output:
    // 1690363051331
}

TimestampMicro

Return current micro second timestamp.

Signature:

func TimestampMicro(timezone ...string) int64

Example:Run

package main

import (
    "fmt"
    "github.com/duke-git/lancet/v2/datetime"
)

func main() {
    ts := datetime.TimestampMicro()

    fmt.Println(ts)

    // Output:
    // 1690363051331784
}

TimestampNano

Return current nano second timestamp.

Signature:

func TimestampNano(timezone ...string) int64

Example:Run

package main

import (
    "fmt"
    "github.com/duke-git/lancet/v2/datetime"
)

func main() {
    ts := datetime.TimestampNano()

    fmt.Println(ts)

    // Output:
    // 1690363051331788000
}

TrackFuncTime

Tracks function execution time.

Signature:

func TrackFuncTime(pre time.Time) func()

Example:Run

package main

import (
    "fmt"
    "github.com/duke-git/lancet/v2/datetime"
)

func main() {
    defer datetime.TrackFuncTime(time.Now())()

    var n int
    for i := 0; i < 5000000; i++ {
        n++
    }

    fmt.Println(1) // Function main execution time:     1.460287ms
}

DaysBetween

Returns the number of days between two times.

Signature:

func DaysBetween(start, end time.Time) int

Example:Run

package main

import (
    "fmt"
    "github.com/duke-git/lancet/v2/datetime"
)

func main() {
    start := time.Date(2024, time.September, 1, 0, 0, 0, 0, time.UTC)
    end := time.Date(2024, time.September, 10, 0, 0, 0, 0, time.UTC)

    result := datetime.DaysBetween(start, end)

    fmt.Println(result)

    // Output:
    // 9
}

GenerateDatetimesBetween

Returns a slice of strings between two times. `layout`: the format of the datetime string.`interval`: the interval between two datetimes.

Signature:

func GenerateDatetimesBetween(start, end time.Time, layout string, interval string) ([]string, error)

Example:Run

package main

import (
    "fmt"
    "github.com/duke-git/lancet/v2/datetime"
)

func main() {
    start := time.Date(2024, time.September, 1, 0, 0, 0, 0, time.UTC)
    end := time.Date(2024, time.September, 1, 2, 0, 0, 0, time.UTC)

    layout := "2006-01-02 15:04:05"
    interval := "1h"

    result, err := datetime.GenerateDatetimesBetween(start, end, layout, interval)

    fmt.Println(result)
    fmt.Println(err)

    // Output:
    // [2024-09-01 00:00:00 2024-09-01 01:00:00 2024-09-01 02:00:00]
    // <nil>
}

Datetime ​

Source: ​

Usage: ​

Index ​

Documentation ​

Note: ​

AddDay ​

AddHour ​

AddMinute ​

AddYear ​

BeginOfMinute ​

BeginOfHour ​

BeginOfDay ​

BeginOfWeek ​

BeginOfMonth ​

BeginOfYear ​

EndOfMinute ​

EndOfHour ​

EndOfDay ​

EndOfWeek ​

EndOfMonth ​

EndOfYear ​

GetNowDate ​

GetNowTime ​

GetNowDateTime ​

GetTodayStartTime ​

GetTodayEndTime ​

GetZeroHourTimestamp ​

GetNightTimestamp ​

FormatTimeToStr ​

FormatStrToTime ​

NewUnixNow ​

NewUnix ​

NewFormat ​

NewISO8601 ​

ToUnix ​

ToFormat ​

ToFormatForTpl ​

ToIso8601 ​

IsLeapYear ​

BetweenSeconds ​

DayOfYear ​

IsWeekend(Deprecated, Use '== Weekday' instead) ​

NowDateOrTime ​

Timestamp ​

TimestampMilli ​

TimestampMicro ​

TimestampNano ​

TrackFuncTime ​

DaysBetween ​

GenerateDatetimesBetween ​

Datetime

Source:

Usage:

Index

Documentation

Note:

AddDay

AddHour

AddMinute

AddYear

BeginOfMinute

BeginOfHour

BeginOfDay

BeginOfWeek

BeginOfMonth

BeginOfYear

EndOfMinute

EndOfHour

EndOfDay

EndOfWeek

EndOfMonth

EndOfYear

GetNowDate

GetNowTime

GetNowDateTime

GetTodayStartTime

GetTodayEndTime

GetZeroHourTimestamp

GetNightTimestamp

FormatTimeToStr

FormatStrToTime

NewUnixNow

NewUnix

NewFormat

NewISO8601

ToUnix

ToFormat

ToFormatForTpl

ToIso8601

IsLeapYear

BetweenSeconds

DayOfYear

IsWeekend(Deprecated, Use '== Weekday' instead)

NowDateOrTime

Timestamp

TimestampMilli

TimestampMicro

TimestampNano

TrackFuncTime

DaysBetween

GenerateDatetimesBetween