[go: up one dir, main page]
Skip to content

Latest commit

 

History

History
1669 lines (1171 loc) · 30.7 KB

datetime.md

File metadata and controls

1669 lines (1171 loc) · 30.7 KB
Raw

Datetime

Package datetime supports date and time format and compare.

Source:

Usage:

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

Index

Documentation

Note:

  1. 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>
}

Min

Returns the earliest time among the given times.

Signature:

func Min(t1 time.Time, times ...time.Time) time.Time

Example:Run

package main

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

func main() {
    minTime := datetime.Min(time.Date(2024, time.September, 1, 0, 0, 0, 0, time.UTC), time.Date(2024, time.September, 2, 0, 0, 0, 0, time.UTC))

    fmt.Println(minTime)

    // Output:
    // 2024-09-01 00:00:00 +0000 UTC
}

Max

Returns the latest time among the given times.

Signature:

func Max(t1 time.Time, times ...time.Time) time.Time

Example:Run

package main

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

func main() {
    maxTime := datetime.Min(time.Date(2024, time.September, 1, 0, 0, 0, 0, time.UTC), time.Date(2024, time.September, 2, 0, 0, 0, 0, time.UTC))

    fmt.Println(maxTime)

    // Output:
    // 2024-09-02 00:00:00 +0000 UTC
}

MaxMin

Returns the latest and earliest time among the given times.

Signature:

func MaxMin(t1 time.Time, times ...time.Time) (maxTime time.Time, minTime time.Time)

Example:Run

package main

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

func main() {
    max, min := datetime.MaxMin(time.Date(2024, time.September, 1, 0, 0, 0, 0, time.UTC), time.Date(2024, time.September, 2, 0, 0, 0, 0, time.UTC), time.Date(2024, time.September, 3, 0, 0, 0, 0, time.UTC))

    fmt.Println(max)
    fmt.Println(min)

    // Output:
    // 2024-09-03 00:00:00 +0000 UTC
    // 2024-09-01 00:00:00 +0000 UTC
}