1
0
mirror of https://github.com/duke-git/lancet.git synced 2026-02-04 12:52:28 +08:00

publish lancet

This commit is contained in:
dudaodong
2021-11-28 21:28:23 +08:00
parent 37edb0fc8f
commit 3254591ab9
38 changed files with 5163 additions and 0 deletions

117
datetime/datetime.go Normal file
View File

@@ -0,0 +1,117 @@
// Copyright 2021 dudaodong@gmail.com. All rights reserved.
// Use of this source code is governed by MIT license.
// Package datetime implements some functions to format date and time.
// Note:
// 1. `format` param in FormatTimeToStr function should be as flow:
//"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"
//"yyyy"
//"mm"
//"hh:mm:ss"
//"mm:ss"
package datetime
import (
"strconv"
"time"
)
var timeFormat map[string]string
func init() {
timeFormat = map[string]string{
"yyyy-mm-dd hh:mm:ss": "2006-01-02 15:04:05",
"yyyy-mm-dd hh:mm": "2006-01-02 15:04",
"yyyy-mm-dd hh": "2006-01-02 15:04",
"yyyy-mm-dd": "2006-01-02",
"yyyy-mm": "2006-01",
"mm-dd": "01-02",
"dd-mm-yy hh:mm:ss": "02-01-06 15:04:05",
"yyyy/mm/dd hh:mm:ss": "2006/01/02 15:04:05",
"yyyy/mm/dd hh:mm": "2006/01/02 15:04",
"yyyy/mm/dd hh": "2006/01/02 15",
"yyyy/mm/dd": "2006/01/02",
"yyyy/mm": "2006/01",
"mm/dd": "01/02",
"dd/mm/yy hh:mm:ss": "02/01/06 15:04:05",
"yyyy": "2006",
"mm": "01",
"hh:mm:ss": "15:04:05",
"mm:ss": "04:05",
}
}
// AddMinute add or sub minute to the time
func AddMinute(t time.Time, minute int64) time.Time {
s := strconv.FormatInt(minute, 10)
m, _ := time.ParseDuration(s + "m")
return t.Add(m)
}
// AddHour add or sub hour to the time
func AddHour(t time.Time, hour int64) time.Time {
s := strconv.FormatInt(hour, 10)
h, _ := time.ParseDuration(s + "h")
return t.Add(h)
}
// AddDay add or sub day to the time
func AddDay(t time.Time, day int64) time.Time {
dayHours := day * 24
d := strconv.FormatInt(dayHours, 10)
h, _ := time.ParseDuration(d + "h")
return t.Add(h)
}
// GetNowDate return format yyyy-mm-dd of current date
func GetNowDate() string {
return time.Now().Format("2006-01-02")
}
// GetNowTime return format hh-mm-ss of current time
func GetNowTime() string {
return time.Now().Format("15:04:05")
}
// GetNowDateTime return format yyyy-mm-dd hh-mm-ss of current datetime
func GetNowDateTime() string {
return time.Now().Format("2006-01-02 15:04:05")
}
// GetZeroHourTimestamp return timestamp of zero hour (timestamp of 00:00)
func GetZeroHourTimestamp() int64 {
ts := time.Now().Format("2006-01-02")
t, _ := time.Parse("2006-01-02", ts)
return t.UTC().Unix() - 8*3600
}
// GetNightTimestamp return timestamp of zero hour (timestamp of 23:59)
func GetNightTimestamp() int64 {
return GetZeroHourTimestamp() + 86400 - 1
}
// FormatTimeToStr convert time to string
func FormatTimeToStr(t time.Time, format string) string {
return t.Format(timeFormat[format])
}
// FormatStrToTime convert string to time
func FormatStrToTime(str, format string) time.Time {
t, _ := time.Parse(timeFormat[format], str)
return t
}

145
datetime/datetime_test.go Normal file
View File

@@ -0,0 +1,145 @@
package datetime
import (
"github.com/duke-git/lancet/utils"
"testing"
"time"
)
func TestAddDay(t *testing.T) {
now := time.Now()
after2Days := AddDay(now, 2)
diff1 := after2Days.Sub(now)
if diff1.Hours() != 48 {
utils.LogFailedTestInfo(t, "AddDay", now, 48, diff1.Hours())
t.FailNow()
}
before2Days := AddDay(now, -2)
diff2 := before2Days.Sub(now)
if diff2.Hours() != -48 {
utils.LogFailedTestInfo(t, "AddDay", now, -48, diff2.Hours())
t.FailNow()
}
}
func TestAddHour(t *testing.T) {
now := time.Now()
after2Hours := AddHour(now, 2)
diff1 := after2Hours.Sub(now)
if diff1.Hours() != 2 {
utils.LogFailedTestInfo(t, "AddHour", now, 2, diff1.Hours())
t.FailNow()
}
before2Hours := AddHour(now, -2)
diff2 := before2Hours.Sub(now)
if diff2.Hours() != -2 {
utils.LogFailedTestInfo(t, "AddHour", now, -2, diff2.Hours())
t.FailNow()
}
}
func TestAddMinute(t *testing.T) {
now := time.Now()
after2Minutes := AddMinute(now, 2)
diff1 := after2Minutes.Sub(now)
if diff1.Minutes() != 2 {
utils.LogFailedTestInfo(t, "AddMinute", now, 2, diff1.Minutes())
t.FailNow()
}
before2Minutes := AddMinute(now, -2)
diff2 := before2Minutes.Sub(now)
if diff2.Minutes() != -2 {
utils.LogFailedTestInfo(t, "AddMinute", now, -2, diff2.Minutes())
t.FailNow()
}
}
func TestGetNowDate(t *testing.T) {
date := GetNowDate()
expected := time.Now().Format("2006-01-02")
if date != expected {
utils.LogFailedTestInfo(t, "GetNowDate", "", expected, date)
t.FailNow()
}
}
func TestGetNotTime(t *testing.T) {
ts := GetNowTime()
expected := time.Now().Format("15:04:05")
if ts != expected {
utils.LogFailedTestInfo(t, "GetNowTime", "", expected, ts)
t.FailNow()
}
}
func TestGetNowDateTime(t *testing.T) {
ts := GetNowDateTime()
expected := time.Now().Format("2006-01-02 15:04:05")
if ts != expected {
utils.LogFailedTestInfo(t, "GetNowDateTime", "", expected, ts)
t.FailNow()
}
}
//todo
//func TestGetZeroHourTimestamp(t *testing.T) {
// ts := GetZeroHourTimestamp()
// expected := time.Now().UTC().Unix() - 8*3600
// if ts != expected {
// utils.LogFailedTestInfo(t, "GetZeroHourTimestamp", "", expected, ts)
// t.FailNow()
// }
//}
func TestFormatTimeToStr(t *testing.T) {
datetime, _ := time.Parse("2006-01-02 15:04:05", "2021-01-02 16:04:08")
cases := []string{
"yyyy-mm-dd hh:mm:ss", "yyyy-mm-dd",
"dd-mm-yy hh:mm:ss", "yyyy/mm/dd hh:mm:ss",
"hh:mm:ss", "yyyy/mm"}
expected := []string{
"2021-01-02 16:04:08", "2021-01-02",
"02-01-21 16:04:08", "2021/01/02 16:04:08",
"16:04:08", "2021/01"}
for i := 0; i < len(cases); i++ {
res := FormatTimeToStr(datetime, cases[i])
if res != expected[i] {
utils.LogFailedTestInfo(t, "FormatTimeToStr", cases[i], expected[i], res)
t.FailNow()
}
}
}
func TestFormatStrToTime(t *testing.T) {
formats := []string{
"2006-01-02 15:04:05", "2006-01-02",
"02-01-06 15:04:05", "2006/01/02 15:04:05",
"2006/01"}
cases := []string{
"yyyy-mm-dd hh:mm:ss", "yyyy-mm-dd",
"dd-mm-yy hh:mm:ss", "yyyy/mm/dd hh:mm:ss",
"yyyy/mm"}
datetimeStr := []string{
"2021-01-02 16:04:08", "2021-01-02",
"02-01-21 16:04:08", "2021/01/02 16:04:08",
"2021/01"}
for i := 0; i < len(cases); i++ {
res := FormatStrToTime(datetimeStr[i], cases[i])
expected, _ := time.Parse(formats[i], datetimeStr[i])
if res != expected {
utils.LogFailedTestInfo(t, "FormatTimeToStr", cases[i], expected, res)
t.FailNow()
}
}
}