Caculate time in nanoseconds
Use time.Duration instead of int64 value in seconds.
diff --git a/times.go b/times.go
index 9d48eea..7aa1642 100644
--- a/times.go
+++ b/times.go
@@ -25,14 +25,11 @@
return RelTime(then, time.Now(), "ago", "from now")
}
-// Seconds represents the elapsed time between two instants as an int64 second count.
-type Seconds int64
-
// Magnitude stores one magnitude and the output format for this magnitude of relative time.
type Magnitude struct {
- d int64
+ d time.Duration
format string
- divby int64
+ divby time.Duration
}
// NewMagnitude returns a Magnitude object.
@@ -42,32 +39,32 @@
// format is the expected output format string.
//
// Also refer to RelTimeMagnitudes for examples.
-func NewMagnitude(d Seconds, format string, divby Seconds) Magnitude {
+func NewMagnitude(d time.Duration, format string, divby time.Duration) Magnitude {
return Magnitude{
- d: int64(d),
+ d: d,
format: format,
- divby: int64(divby),
+ divby: divby,
}
}
var defaultMagnitudes = []Magnitude{
- NewMagnitude(1, "now", 1),
- NewMagnitude(2, "1 second %s", 1),
- NewMagnitude(Minute, "%d seconds %s", 1),
- NewMagnitude(2*Minute, "1 minute %s", 1),
- NewMagnitude(Hour, "%d minutes %s", Minute),
- NewMagnitude(2*Hour, "1 hour %s", 1),
- NewMagnitude(Day, "%d hours %s", Hour),
- NewMagnitude(2*Day, "1 day %s", 1),
- NewMagnitude(Week, "%d days %s", Day),
- NewMagnitude(2*Week, "1 week %s", 1),
- NewMagnitude(Month, "%d weeks %s", Week),
- NewMagnitude(2*Month, "1 month %s", 1),
- NewMagnitude(Year, "%d months %s", Month),
- NewMagnitude(18*Month, "1 year %s", 1),
- NewMagnitude(2*Year, "2 years %s", 1),
- NewMagnitude(LongTime, "%d years %s", Year),
- NewMagnitude(math.MaxInt64, "a long while %s", 1),
+ NewMagnitude(time.Second, "now", time.Second),
+ NewMagnitude(2*time.Second, "1 second %s", time.Second),
+ NewMagnitude(Minute*time.Second, "%d seconds %s", time.Second),
+ NewMagnitude(2*Minute*time.Second, "1 minute %s", time.Second),
+ NewMagnitude(Hour*time.Second, "%d minutes %s", Minute*time.Second),
+ NewMagnitude(2*Hour*time.Second, "1 hour %s", time.Second),
+ NewMagnitude(Day*time.Second, "%d hours %s", Hour*time.Second),
+ NewMagnitude(2*Day*time.Second, "1 day %s", time.Second),
+ NewMagnitude(Week*time.Second, "%d days %s", Day*time.Second),
+ NewMagnitude(2*Week*time.Second, "1 week %s", time.Second),
+ NewMagnitude(Month*time.Second, "%d weeks %s", Week*time.Second),
+ NewMagnitude(2*Month*time.Second, "1 month %s", time.Second),
+ NewMagnitude(Year*time.Second, "%d months %s", Month*time.Second),
+ NewMagnitude(18*Month*time.Second, "1 year %s", time.Second),
+ NewMagnitude(2*Year*time.Second, "2 years %s", time.Second),
+ NewMagnitude(LongTime*time.Second, "%d years %s", Year*time.Second),
+ NewMagnitude(math.MaxInt64, "a long while %s", time.Second),
}
// RelTime formats a time into a relative string.
@@ -86,33 +83,33 @@
// example:
// magitudes:
// {
-// NewMagnitude(1, "now", 1),
-// NewMagnitude(60, "%d seconds %s", 1),
-// NewMagnitude(120,"a minute %s", 1),
-// NewMagnitude(360, "%d minutes %s", 60),
+// NewMagnitude(time.Second, "now", time.Second),
+// NewMagnitude(60*time.Second, "%d seconds %s", time.Second),
+// NewMagnitude(120*time.Second,"a minute %s", time.Second),
+// NewMagnitude(360*time.Second, "%d minutes %s", 60*time.Second),
// }
// albl: earlier
// blbl: later
//
-// b - a output
-// -130 2 minutes later
-// 0 now
-// 30 30 seconds earlier
-// 80 a minute earlier
-// 340 5 minutes earlier
-// 400 undefined
+// b - a output
+// -130*time.Second 2 minutes later
+// 0 now
+// 30*time.Second 30 seconds earlier
+// 80*time.Second a minute earlier
+// 340*time.Second 5 minutes earlier
+// 400*time.Second undefined
func RelTimeMagnitudes(a, b time.Time, albl, blbl string, magnitudes []Magnitude) string {
lbl := albl
- diff := b.Unix() - a.Unix()
+ diff := b.Sub(a)
after := a.After(b)
if after {
lbl = blbl
- diff = a.Unix() - b.Unix()
+ diff = a.Sub(b)
}
n := sort.Search(len(magnitudes), func(i int) bool {
- return magnitudes[i].d > diff
+ return magnitudes[i].d >= diff
})
if n >= len(magnitudes) {
diff --git a/times_test.go b/times_test.go
index edcb4a2..314da59 100644
--- a/times_test.go
+++ b/times_test.go
@@ -39,25 +39,27 @@
func TestFuture(t *testing.T) {
now := time.Now().Unix()
+ // add 1 second offset for test time to balance decimal fraction of time.Now()
+ offset := int64(time.Second)
testList{
{"now", Time(time.Unix(now, 0)), "now"},
- {"1 second from now", Time(time.Unix(now+1, 0)), "1 second from now"},
- {"12 seconds from now", Time(time.Unix(now+12, 0)), "12 seconds from now"},
- {"30 seconds from now", Time(time.Unix(now+30, 0)), "30 seconds from now"},
- {"45 seconds from now", Time(time.Unix(now+45, 0)), "45 seconds from now"},
- {"15 minutes from now", Time(time.Unix(now+15*Minute, 0)), "15 minutes from now"},
- {"2 hours from now", Time(time.Unix(now+2*Hour, 0)), "2 hours from now"},
- {"21 hours from now", Time(time.Unix(now+21*Hour, 0)), "21 hours from now"},
- {"1 day from now", Time(time.Unix(now+26*Hour, 0)), "1 day from now"},
- {"2 days from now", Time(time.Unix(now+49*Hour, 0)), "2 days from now"},
- {"3 days from now", Time(time.Unix(now+3*Day, 0)), "3 days from now"},
- {"1 week from now (1)", Time(time.Unix(now+7*Day, 0)), "1 week from now"},
- {"1 week from now (2)", Time(time.Unix(now+12*Day, 0)), "1 week from now"},
- {"2 weeks from now", Time(time.Unix(now+15*Day, 0)), "2 weeks from now"},
- {"1 month from now", Time(time.Unix(now+30*Day, 0)), "1 month from now"},
- {"1 year from now", Time(time.Unix(now+365*Day, 0)), "1 year from now"},
- {"2 years from now", Time(time.Unix(now+2*Year, 0)), "2 years from now"},
- {"a while from now", Time(time.Unix(now+LongTime, 0)), "a long while from now"},
+ {"1 second from now", Time(time.Unix(now+1, offset)), "1 second from now"},
+ {"12 seconds from now", Time(time.Unix(now+12, offset)), "12 seconds from now"},
+ {"30 seconds from now", Time(time.Unix(now+30, offset)), "30 seconds from now"},
+ {"45 seconds from now", Time(time.Unix(now+45, offset)), "45 seconds from now"},
+ {"15 minutes from now", Time(time.Unix(now+15*Minute, offset)), "15 minutes from now"},
+ {"2 hours from now", Time(time.Unix(now+2*Hour, offset)), "2 hours from now"},
+ {"21 hours from now", Time(time.Unix(now+21*Hour, offset)), "21 hours from now"},
+ {"1 day from now", Time(time.Unix(now+26*Hour, offset)), "1 day from now"},
+ {"2 days from now", Time(time.Unix(now+49*Hour, offset)), "2 days from now"},
+ {"3 days from now", Time(time.Unix(now+3*Day, offset)), "3 days from now"},
+ {"1 week from now (1)", Time(time.Unix(now+7*Day, offset)), "1 week from now"},
+ {"1 week from now (2)", Time(time.Unix(now+12*Day, offset)), "1 week from now"},
+ {"2 weeks from now", Time(time.Unix(now+15*Day, offset)), "2 weeks from now"},
+ {"1 month from now", Time(time.Unix(now+30*Day, offset)), "1 month from now"},
+ {"1 year from now", Time(time.Unix(now+365*Day, offset)), "1 year from now"},
+ {"2 years from now", Time(time.Unix(now+2*Year, offset)), "2 years from now"},
+ {"a while from now", Time(time.Unix(now+LongTime, offset)), "a long while from now"},
}.validate(t)
}
@@ -72,28 +74,29 @@
func TestRelTimeMagnitudes(t *testing.T) {
magnitudes := []Magnitude{
- NewMagnitude(1, "now", 1),
- NewMagnitude(2, "1s %s", 1),
- NewMagnitude(Minute, "s %s", 1),
- NewMagnitude(2*Minute, "1m %s", 1),
- NewMagnitude(Hour, "%dm %s", Minute),
- NewMagnitude(2*Hour, "1h %s", 1),
- NewMagnitude(Day, "%dh %s", Hour),
- NewMagnitude(2*Day, "1D %s", 1),
- NewMagnitude(Month, "%dD %s", Day),
- NewMagnitude(2*Month, "1M %s", 1),
- NewMagnitude(Year, "%dM %s", Month),
- NewMagnitude(18*Month, "1Y %s", 1),
- NewMagnitude(2*Year, "2Y %s", 1),
+ NewMagnitude(1*time.Second, "now", time.Second),
+ NewMagnitude(2*time.Second, "1s %s", time.Second),
+ NewMagnitude(Minute*time.Second, "s %s", time.Second),
+ NewMagnitude(2*Minute*time.Second, "1m %s", time.Second),
+ NewMagnitude(Hour*time.Second, "%dm %s", Minute*time.Second),
+ NewMagnitude(2*Hour*time.Second, "1h %s", time.Second),
+ NewMagnitude(Day*time.Second, "%dh %s", Hour*time.Second),
+ NewMagnitude(2*Day*time.Second, "1D %s", time.Second),
+ NewMagnitude(Month*time.Second, "%dD %s", Day*time.Second),
+ NewMagnitude(2*Month*time.Second, "1M %s", time.Second),
+ NewMagnitude(Year*time.Second, "%dM %s", Month*time.Second),
+ NewMagnitude(18*Month*time.Second, "1Y %s", time.Second),
+ NewMagnitude(2*Year*time.Second, "2Y %s", time.Second),
}
now := time.Now().Unix()
+ timeNow := time.Unix(now, 0)
testList{
- {"now", RelTimeMagnitudes(time.Unix(now, 0), time.Now(), "ago", "later", magnitudes), "now"},
- {"1 second from now", RelTimeMagnitudes(time.Unix(now+1, 0), time.Now(), "ago", "later", magnitudes), "1s later"},
+ {"now", RelTimeMagnitudes(time.Unix(now, 0), timeNow, "ago", "later", magnitudes), "now"},
+ {"1 second from now", RelTimeMagnitudes(time.Unix(now+1, 1), timeNow, "ago", "later", magnitudes), "1s later"},
// Unit week has been removed from magnitudes
- {"1 week ago", RelTimeMagnitudes(time.Unix(now-12*Day, 0), time.Now(), "ago", "", magnitudes), "12D ago"},
- {"3 months ago", RelTimeMagnitudes(time.Unix(now-99*Day, 0), time.Now(), "ago", "later", magnitudes), "3M ago"},
- {"1 year ago", RelTimeMagnitudes(time.Unix(now-365*Day, 0), time.Now(), "", "later", magnitudes), "1Y "},
- {"out of defined magnitudes", RelTimeMagnitudes(time.Unix(now+LongTime, 0), time.Now(), "ago", "later", magnitudes), "undefined"},
+ {"1 week ago", RelTimeMagnitudes(time.Unix(now-12*Day, 0), timeNow, "ago", "", magnitudes), "12D ago"},
+ {"3 months ago", RelTimeMagnitudes(time.Unix(now-99*Day, 0), timeNow, "ago", "later", magnitudes), "3M ago"},
+ {"1 year ago", RelTimeMagnitudes(time.Unix(now-365*Day, 0), timeNow, "", "later", magnitudes), "1Y "},
+ {"out of defined magnitudes", RelTimeMagnitudes(time.Unix(now+LongTime, 0), timeNow, "ago", "later", magnitudes), "undefined"},
}.validate(t)
}
