jinzhu/now

Now is a time toolkit for golang

Now

Now is a time toolkit for golang

Install

go get -u github.com/jinzhu/now

Usage

Calculating time based on current time

import "github.com/jinzhu/now"

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

now.BeginningOfMinute()        // 2013-11-18 17:51:00 Mon
now.BeginningOfHour()          // 2013-11-18 17:00:00 Mon
now.BeginningOfDay()           // 2013-11-18 00:00:00 Mon
now.BeginningOfWeek()          // 2013-11-17 00:00:00 Sun
now.BeginningOfMonth()         // 2013-11-01 00:00:00 Fri
now.BeginningOfQuarter()       // 2013-10-01 00:00:00 Tue
now.BeginningOfYear()          // 2013-01-01 00:00:00 Tue

now.EndOfMinute()              // 2013-11-18 17:51:59.999999999 Mon
now.EndOfHour()                // 2013-11-18 17:59:59.999999999 Mon
now.EndOfDay()                 // 2013-11-18 23:59:59.999999999 Mon
now.EndOfWeek()                // 2013-11-23 23:59:59.999999999 Sat
now.EndOfMonth()               // 2013-11-30 23:59:59.999999999 Sat
now.EndOfQuarter()             // 2013-12-31 23:59:59.999999999 Tue
now.EndOfYear()                // 2013-12-31 23:59:59.999999999 Tue

now.WeekStartDay = time.Monday // Set Monday as first day, default is Sunday
now.EndOfWeek()                // 2013-11-24 23:59:59.999999999 Sun

Calculating time based on another time

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

Calculating time based on configuration

location, err := time.LoadLocation("Asia/Shanghai")

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

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

myConfig.Parse("2002-10-12 22:14:01")     // 2002-10-12 22:14:01
myConfig.Parse("2002-10-12 22:14")        // returns error 'can't parse string as time: 2002-10-12 22:14'

Monday/Sunday

Don't be bothered with the WeekStartDay setting, you can use Monday, Sunday

now.Monday()              // 2013-11-18 00:00:00 Mon
now.Monday("17:44")       // 2013-11-18 17:44:00 Mon
now.Sunday()              // 2013-11-24 00:00:00 Sun (Next Sunday)
now.Sunday("18:19:24")    // 2013-11-24 18:19:24 Sun (Next Sunday)
now.EndOfSunday()         // 2013-11-24 23:59:59.999999999 Sun (End of next Sunday)

t := time.Date(2013, 11, 24, 17, 51, 49, 123456789, time.Now().Location()) // 2013-11-24 17:51:49.123456789 Sun
now.With(t).Monday()              // 2013-11-18 00:00:00 Mon (Last Monday if today is Sunday)
now.With(t).Monday("17:44")       // 2013-11-18 17:44:00 Mon (Last Monday if today is Sunday)
now.With(t).Sunday()              // 2013-11-24 00:00:00 Sun (Beginning Of Today if today is Sunday)
now.With(t).Sunday("18:19:24")    // 2013-11-24 18:19:24 Sun (Beginning Of Today if today is Sunday)
now.With(t).EndOfSunday()         // 2013-11-24 23:59:59.999999999 Sun (End of Today if today is Sunday)

Parse String to Time

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

// Parse(string) (time.Time, error)
t, err := now.Parse("2017")                // 2017-01-01 00:00:00, nil
t, err := now.Parse("2017-10")             // 2017-10-01 00:00:00, nil
t, err := now.Parse("2017-10-13")          // 2017-10-13 00:00:00, nil
t, err := now.Parse("1999-12-12 12")       // 1999-12-12 12:00:00, nil
t, err := now.Parse("1999-12-12 12:20")    // 1999-12-12 12:20:00, nil
t, err := now.Parse("1999-12-12 12:20:21") // 1999-12-12 12:20:21, nil
t, err := now.Parse("10-13")               // 2013-10-13 00:00:00, nil
t, err := now.Parse("12:20")               // 2013-11-18 12:20:00, nil
t, err := now.Parse("12:20:13")            // 2013-11-18 12:20:13, nil
t, err := now.Parse("14")                  // 2013-11-18 14:00:00, nil
t, err := now.Parse("99:99")               // 2013-11-18 12:20:00, Can't parse string as time: 99:99

// MustParse must parse string to time or it will panic
now.MustParse("2013-01-13")             // 2013-01-13 00:00:00
now.MustParse("02-17")                  // 2013-02-17 00:00:00
now.MustParse("2-17")                   // 2013-02-17 00:00:00
now.MustParse("8")                      // 2013-11-18 08:00:00
now.MustParse("2002-10-12 22:14")       // 2002-10-12 22:14:00
now.MustParse("99:99")                  // panic: Can't parse string as time: 99:99

Extend now to support more formats is quite easy, just update now.TimeFormats with other time layouts, e.g:

now.TimeFormats = append(now.TimeFormats, "02 Jan 2006 15:04")

Please send me pull requests if you want a format to be supported officially

Contributing

You can help to make the project better, check out http://gorm.io/contribute.html for things you can do.

Author

jinzhu

• http://github.com/jinzhu
• [email protected]
• http://twitter.com/zhangjinzhu

License

Released under the MIT License.

now's Issues

Current quarter

Describe the feature

• If the current month is june then quarter number 2 should be returned.
• If july then 3 should be shown.

Motivation

We would like to display the quarter in one of our tools.

Related Issues

Beginning of Month error

Reproducible Example

https://play.golang.org/p/o21N9NbVLdk

Description

If you run this on the 31st of the month it won't print the beginning of the next month but the beginning of the month after
So on 03-21-2021 it'll print 05-01-201 instead of 04-01-2021

please add mysql datetime layout

Describe the feature

please add layout "2021-01-01 10:00:00.000000", which is supported by MySQL datetime data type

Motivation

Related Issues

don't allocate config inside With()

Describe the feature

We would be glad to not instanciate a pointer to a config inside every call to With() (so calls to New() by extension).

Motivation

Recently we had an "Out of memory" error on our process because the config included inside every With() ate up to 40GB of RAM.

Thank you a lot and we love your library. Kudos.

[bug] incorrectly fill up hour with current hour

reproduce test case as below:

if New(n).MustParse("2002-10-12 00:14:56").Format(format) != "2002-10-12 00:14:56" {
t.Errorf("Parse 2002-10-12 00:14:56")
}

parse output is: 2002-10-12 {current hour}:14:56

now doesn't account for DST

Hey,

I'm in central Europe, and we currently still have daylight saving time (timezone CEST instead of CET).
now doesn't seem to account for the extra hour, so now.BeginningOfYear() currently returns 2014-12-31 23:00:00 +0100 CET instead of midnight.

Greets,
Bobselp

可以考虑内置支持下这些格式吗？

这些格式还蛮常见的，加上这些 常见格式 都可以直接Parse了

now.TimeFormats = append(now.TimeFormats, "2006.1.2")
now.TimeFormats = append(now.TimeFormats, "2006.1.2 15:04:05")
now.TimeFormats = append(now.TimeFormats, "2006.01.02")
now.TimeFormats = append(now.TimeFormats, "2006.01.02 15:04:05")
now.TimeFormats = append(now.TimeFormats, "2006/01/02")
now.TimeFormats = append(now.TimeFormats, "2006/01/02 15:04:05")

Make FirstDayMonday a variable on now.Now struct or a parameter to BeginningOfWeek

FirstDayMonday is currently a package-level variable on the now package. I believe it makes more sense for this to be a variable on the now.Now struct. Mainly this is because a single application might have different use-cases for true vs false. However, there are no guarantees that your application (or a library on which you are dependent) won't change the value of the variable without you realizing it. Even setting it right before calling BeginningOfWeek() won't guarantee that it gets changed.

Alternatively, since the only use of the variable is in BeginningOfWeek, this function could be updated to take in a bool parameter to dictate behavior. Likewise, an additional function that mimics BeginningOfWeek could be written to specify the desired behavior.

Happy to take care of fixing the issue but want to get some direction before doing so.

Parse day of the week

Given the following time object:

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

How can I return the day, either as a ISOWeek (Monday) or as an int?

Also, considering the opposite:

now.Parse(1) // 2013-11-18 00:00:00.000000000 Mon
now.Parse("Monday") // 2013-11-18 00:00:00.000000000 Mon

How can I provide a day of the week (either Mon or 1) and time (Hour:Minute) to parse the full Time object? Like:

now.Parse("Monday", "12:34") // 2013-11-18 12:34:00.000000000 Mon

I tried to read the code (and the test cases) to see if there was a low hanging fruit expecting a PR but no luck... I'm happy to create a PR if given the direction of what's missing in the code.

Thanks,
Gleidson

Unable to parse time without day

The README claims the following should work, but, it fails with:

panic: Can't parse string as time: 2017-10

	t, err := now.Parse("2017-10")

	if err != nil {
		panic(err)
	}

Do you need help fixing this? I can contribute a PR.

Serious error with format "2006-01-02T15:04:05Z" (also see #22)

Reproducible Example

See this comment.

Here's a playground link with more examples demonstrating this issue.

The playground link uses now.Parse() and now.MustParse(). The return output consists of two parts.
The first part uses now.Parse(), with time.Now() as reference.
The second part uses now.MustParse(). using the n from your testcase as reference.

Actual playground output (notice the hour and minute):

2009-11-10 23:00:00 +0000 UTC m=+0.000000001
2021-07-20 23:59:10 +0000 UTC
2021-07-20 23:00:10 +0000 UTC

2013-11-18 17:51:49.123456789 +0000 UTC
2002-10-12 17:14:56 +0000 UTC
2002-10-12 17:51:56 +0000 UTC

The expected playground output should be:

2009-11-10 23:00:00 +0000 UTC m=+0.000000001
2021-07-20 00:59:10 +0000 UTC
2021-07-20 00:00:10 +0000 UTC

2013-11-18 17:51:49.123456789 +0000 UTC
2002-10-12 00:14:56 +0000 UTC
2002-10-12 00:00:56 +0000 UTC

Description

When parsing 2006-01-02T15:04:05Z (2006-01-02T15:04:05Z07:00 is also affected as tested), the resulted time is incorrect (see the playground output above).

• If the time part is 00:00:00 it works as intended.
• If hour and minute are both 00 but second is nonzero, the current hour and minute (or the hour and minute specified in n) will be used instead.
• If hour is 00 but minute is nonzero (second doesn't matter), the current hour will be used instead.

I originally posted about this in the now-closed issue #22 as follow-up, but I'm yet to see any change or fix. As a result, I have switched back to the time.Parse() method to process time strings and removed all references to this package (refactored a good amount of code in the progress). A side effect would be that users must now explicitly configure the time format the data use, as time.Parse() requires a time format whereas now.Parse() does not.

PS: Issue #22 (9003839) did fix this issue for time format 2006-01-02 15:04:05, though, as existing test cases (which covered it) are passing.

UTC exprssed time & strange conversion

Can someone please explain me 'reason' of this chunk of code that can be found inside "Parse" method?:

		location := t.Location()
		if location.String() == "UTC" {
			location = currentLocation
		}

I have cleary specified date&time in Z(ulu) time zone according to RFC3339 format, i.e. "2017-12-11T10:25:49Z" for example. Time is coverted correctly, but then (I cannot understand why??) is assigned to local timezone although it's cleary specified that is not 'local' but GMT timezone.
More, I did a small test:

func main() {
	log.Info("application started")

	zulu := "2017-12-11T10:25:49Z"
	x, _ := now.Parse(zulu)
	log.Infof("Zulu: %v, parsed: %v", zulu, x)

	y, _ := time.Parse(time.RFC3339, zulu)
	log.Infof("Zulu: %v, parsed: %v", zulu, y)

	log.Info("application completed")
}

and result is:

{"level":"info","msg":"application started","time":"2017-12-16T12:07:35+01:00"}
{"level":"info","msg":"Zulu: 2017-12-11T10:25:49Z, parsed: 2017-12-11 10:25:49 +0100 CET","time":"2017-12-16T12:07:35+01:00"}
{"level":"info","msg":"Zulu: 2017-12-11T10:25:49Z, parsed: 2017-12-11 10:25:49 +0000 UTC","time":"2017-12-16T12:07:35+01:00"}
{"level":"info","msg":"application completed","time":"2017-12-16T12:07:35+01:00"}

comapring second and third line, result time is quite different although input is the same... (and third line returns time that I've expected).

So for now, IMHO it's a bug (but would be very appriciated if someone explain me why above code construction is applied (I guess correction should be applied when timezone is not specified and UTC is added by default, my scenario is not writting in this assumption)).
Regards,

Support all common go time formats

From reading the code, it seems like TimeFormats doesn't include any of the go time formats (time. RFC3339,time. RFC1123, etc.). What are your thoughts on including them? More then willing to submit a PR if it's agreeable to you.

not support only year

i want the usage as:

now.Parse("2017")

current, i must use it like:

now.Parse("2017-01-01")

License

Hello !

Could you add the license please ?

Thank you

WeekStartDay as an attribute of Now type

When using the library we could have different scenarios where the WeekStartDay have different values. To avoid concurrence I suggest having a WeekStartDay attribute in the Now type instead of using as a global variable. For backward compatibility we could keep the global variable as a fallback if the new attribute is not defined.

// WeekStartDay set week start day, default is sunday
var WeekStartDay = time.Sunday

// Now now struct
type Now struct {
	time.Time
	WeekStartDay *time.Weekday
}

// BeginningOfWeek beginning of week
func (now *Now) BeginningOfWeek() time.Time {
	t := now.BeginningOfDay()
	weekday := int(t.Weekday())

	weekStartDay := WeekStartDay
	if now.WeekStartDay != nil {
		weekStartDay = *now.WeekStartDay
	}

	if weekStartDay != time.Sunday {
		weekStartDayInt := int(weekStartDay)

		if weekday < weekStartDayInt {
			weekday = weekday + 7 - weekStartDayInt
		} else {
			weekday = weekday - weekStartDayInt
		}
	}
	return t.AddDate(0, 0, -weekday)
}

I could work on a PR if you think this is acceptable.

🤔 The downside is that the type Now wouldn't be easy convertible to time.Time anymore. And this could break some backward compatibility:

n := now.New(time.Now())
// ...
t1 := time.Time(n) // <-- this will fail now
t2 := n.Time // <-- this will continue working

Date format support

Hi

I have seen there is a support for time. Could we add date format support as well?

BeginningOfMonth seems off

fmt.Println(now.New(now.MustParse("2013-03-31 01:59:59.999999999")).BeginningOfMonth())
prints
2013-03-01 00:00:00 +0100 CET
while
fmt.Println(now.New(now.MustParse("2013-03-31 02:00:00.000000000")).BeginningOfMonth())
prints
2013-03-01 23:00:00 +0100 CET
which seems a bit odd to me.

Also,
fmt.Println(now.New(now.MustParse("2011-03-31 02:00:00.000000000")).EndOfMonth())
prints
2011-03-28 22:59:59.999999999 +0200 CEST
and
fmt.Println(now.New(now.MustParse("2013-03-31 02:00:00.000000000")).EndOfMonth())
prints
2013-04-01 22:59:59.999999999 +0200 CEST

Support Formatting of Duration

One problem with the std library is that Duration.String() doesn't allow formatting. And you get something like "89h41m47.9036549s" which is ugly. Specially if you actually don't want to show the seconds part.

now_test issue

Hi,
When test your package now in the mac air , there seems a bug in the now_test line 83 - 86:

n2 := time.Date(1900, 02, 18, 17, 51, 49, 123456789, time.Now().Location())
if New(n2).EndOfMonth().Format(format) != "1900-02-28 23:59:59.999999999" {
    t.Errorf("EndOfMonth")
}

if the year is before 1981, I do this program in mac:

fmt.Println(New(n2).EndOfMonth().Format(format))

the result is

1980-03-01 00:29:59.999999999

But if the year is after 1981, I do this program in mac:

fmt.Println(New(n2).EndOfMonth().Format(format))

the result is

1981-02-28 23:59:59.999999999

But in other system, such as Linux, or the Go Playground, the ressult is

1980-02-29 23:59:59.999999999
1981-02-28 23:59:59.999999999

You can see it in this URL:
http://play.golang.org/p/1_kba5dUQI

And test the program in Mac, the result is

1903-03-01 00:29:59.999999999
1980-03-01 00:29:59.999999999
1981-02-28 23:59:59.999999999

My Engilsh is poor, but if you test that in Mac and Linux I think you would get my point.

I think it is because the location problem, I print my "time.Now().Location()", it is

+0830 CHAT

I think you should use the "time.UTC" instead of the "time.Now().Location()", then it will be normal.

And I apologize for my poor Engilsh.Best Wishes.

Rename License to LICENSE

LICENSE is the standard. A lot of tooling is building on this convention.
For example SBOM generation and license management tools.

Make easier to test with time.Now as a config

Describe the feature

It's difficult to test function in main like now.BeginingOf... because it use time.Now()

I suggest that the function time.Now could be set global like
var WeekStartDay = time.Sunday

We could have
var TimeNowFunction = time.Now

now.BeginingOfDay() will become return With(TimeNowFunction()).BeginningOfDay()

Then when we start our test we just need to set
now.TimeNowFunction = func() time.Time { return time.Date(2021, 1, 1, 0, 0, 0, 0, time.Local) }

Thanks to listen

Time zone support

Hi

Thanks for awesome library. I couldn't see any documentation related to time zone. Does now supports time zones. If not could we add it?

How do get the previous month's time？

example:
now = 2022-03-01 10:00:00

I want to get 2022-02-01 10:00:00

How can this be done quickly？thanks

BeginningOfHour returns incorrect time if TZ is not in a form xx00

Current usage of time.Truncate(time.Hour) will return incorrect time in, for example, America/Caracas TZ. Details: golang/go#16647

Recommend a better golang package for datetime

Carbon is a simple, semantic and developer-friendly golang package for datetime, it has been included by awesome-go

https://github.com/golang-module/carbon

Milliseconds are not parsed correctly

When parsing a timestamp with which contains milliseconds, now.Parse will always display them as zeros.

Consider the following program which compares golang time library parsing to now:

package main

import (
  "fmt"
  "time"
  "github.com/jinzhu/now"
)

func main(){
  // Get current location
  loc, err := time.LoadLocation("America/Indianapolis")
  if err!=nil{
    fmt.Println("Could not get location")
    panic(err)
  }

  timeString := "04/20/2017 23:01:54.364"
  layout := "01/02/2006 15:04:05.000"

  // Parse using golang parse function and convert to UTC
  t1, err := time.ParseInLocation(layout, timeString, loc)

  if err!=nil{
    fmt.Printf("Could not parse t1, %s", err)
  }
  t1UTC := t1.UTC().Format("01/02/2006 03:04:05.000-0700")

  // Using Now library

  // Step 1: add layout to now.Timestamps as first argument to ensure that the now
  // library will use that one
  now.TimeFormats = append([]string{layout}, now.TimeFormats...)

  // Step 2: parse using now.Parse
  t2, err := now.Parse(timeString)
  if err!=nil{
    fmt.Printf("Could not parse t2, %s", err)
  }

  // Step 3: conver to UTC
  t2UTC := t2.UTC().Format("01/02/2006 03:04:05.000-0700")

  fmt.Println("Original time (EST):\t", timeString)
  fmt.Println("Parsed time using Golang (UTC):\t", t1UTC)
  fmt.Println("Parsed time using Now (UTC):\t", t2UTC)
}

Output:

Original time (EST):	         04/20/2017 23:01:54.364
Parsed time using Golang (UTC):	 04/21/2017 03:01:54.364+0000
Parsed time using Now (UTC):	 04/21/2017 03:01:54.000+0000

The last line of the output (parsed using now) shows an incorrect timestemp

How about add a maxTime and a minTime const

Describe the feature

Provide min and max timestamp (just like math.MaxInt, math.MinInt)

Motivation

Sometimes I have to decide whether a timestamp in a valid range (after the begin time stamp and before the end time stamp).

It's convenient if I have a MaxTime so that any certainTime.Before(maxTime) is true

Related Issues

Alternative API?

Hi jinzhu,
love the methods in this library, but IMHO the usage would be way clearer if:

• the library didn't use now as the default time - instead be more explicit with now.Now() and now.With(date).EndOfDay()...
• methods would return *Now instead of time.Time, to allow chaining.
• a final call to something like AsTime() would return the time.Time object

now.Now().BeginningOfMonth().EndOfMinute().AsTime()

Just my 2 cents!
Thanks for writing this :)

Cant find variable now

Hello

Im trying to use the library but I get the error "undefined now in now.BeginningOfMinute()"
Do I have to initialize the variable? How can I remove the usage of time library it seems to replace it everytime

Beginning/End of Next Month/Year/...

i'm a golang beginner used to rails awesome date-helpers that allow you do stuff like 1.month.ago or 3.month.from_now.

in the same sense, i would like to calculate the timestamp of next month. i could not really find a great way to implement this in golang. maybe i just don't know the right tools though.
calculating it by hand is simple but has a lot of edge cases, so i would like to use it from within a library.

any feedback appreciated.

(Question) Why don't just use Truncate for BeginningOfDay()

I was trying to understand your BeginninfOfDay() code:
https://github.com/jinzhu/now/blob/master/now.go#L17

And I was wandering why don't you just use Truncate:
t.Truncate(24 * time.Hour)

Broken when clocks go back

This case does not return the correct data:

package main

import (
	"fmt"
	"time"

	"github.com/jinzhu/now"
)

func main() {
	l, _ := time.LoadLocation("Europe/London")
	t1, _ := time.ParseInLocation(time.RFC3339, "2018-10-28T01:30:00+01:00", l)
	t2, _ := time.ParseInLocation(time.RFC3339, "2018-10-28T01:30:00Z", l)

	fmt.Println(t1)
	fmt.Println(t2)

	c1 := now.New(t1).BeginningOfHour()
	c2 := now.New(t2).BeginningOfHour()

	fmt.Println(c1)
	fmt.Println(c2)
}

Actual output:

2018-10-28 01:30:00 +0100 BST
2018-10-28 01:30:00 +0000 UTC
2018-10-28 01:00:00 +0000 GMT
2018-10-28 01:00:00 +0000 UTC

Expected output:

2018-10-28 01:30:00 +0100 BST
2018-10-28 01:30:00 +0000 UTC
2018-10-28 01:00:00 +0100 BST
2018-10-28 01:00:00 +0000 UTC

I imagine quite a lot of cases would be affected by the very same problem. The key issue is that time.Date is never safe to use, as its behaviour on ambiguous times (where more than one offset could apply) is undefined.

Incorrect time parsed for 00:01

The parse uses current hour instead:
2015-06-13 15:01:00 +1000 AEST