bingyi/gf
1
0
Fork 0
mirror of https://gitee.com/johng/gf synced 2026-07-06 13:42:46 +08:00
Code Issues Packages Projects Releases Wiki Activity

refract(os/gtime): swap function names between Format and Layout (#4275)

Browse Source
This commit is contained in:
John Guo
2025-05-10 14:19:55 +08:00
committed by GitHub
parent 1f2fcd39b1
commit c5a90d93a7
26 changed files with 272 additions and 272 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
contrib/drivers/dm/dm_z_unit_issue_test.go
View File

@ -45,8 +45,8 @@ func Test_Issue2594(t *testing.T) {
SubPrefix: "p_",
Prefix: "m_",
HandleName: "name",
CreateTime: gtime.Now().FormatTo("Y-m-d H:i:s").Time,
UpdateTime: gtime.Now().FormatTo("Y-m-d H:i:s").Time,
CreateTime: gtime.Now().LayoutTo("Y-m-d H:i:s").Time,
UpdateTime: gtime.Now().LayoutTo("Y-m-d H:i:s").Time,
Value: []HandleValueMysql{
{
Index: 10,

6
contrib/drivers/mysql/mysql_z_unit_core_test.go
View File

@ -1616,7 +1616,7 @@ func Test_Types(t *testing.T) {
t.Assert(one["binary"].String(), data["binary"])
t.Assert(one["date"].String(), data["date"])
t.Assert(one["time"].String(), `10:00:01`)
t.Assert(one["timestamp"].GTime().Format(`Y-m-d H:i:s.u`), `2022-02-14 12:00:01.123`)
t.Assert(one["timestamp"].GTime().Layout(`Y-m-d H:i:s.u`), `2022-02-14 12:00:01.123`)
t.Assert(one["decimal"].String(), -123.46)
t.Assert(one["double"].String(), data["double"])
t.Assert(one["bit"].Int(), data["bit"])
@ -1640,9 +1640,9 @@ func Test_Types(t *testing.T) {
t.Assert(obj.Id, 1)
t.Assert(obj.Blob, data["blob"])
t.Assert(obj.Binary, data["binary"])
t.Assert(obj.Date.Format("Y-m-d"), data["date"])
t.Assert(obj.Date.Layout("Y-m-d"), data["date"])
t.Assert(obj.Time.String(), `10:00:01`)
t.Assert(obj.Timestamp.Format(`Y-m-d H:i:s.u`), `2022-02-14 12:00:01.123`)
t.Assert(obj.Timestamp.Layout(`Y-m-d H:i:s.u`), `2022-02-14 12:00:01.123`)
t.Assert(obj.Decimal, -123.46)
t.Assert(obj.Double, data["double"])
t.Assert(obj.Bit, data["bit"])

6
contrib/drivers/mysql/mysql_z_unit_model_test.go
View File

@ -3726,9 +3726,9 @@ func Test_Model_Year_Date_Time_DateTime_Timestamp(t *testing.T) {
// select.
one, err := db.Model("date_time_example").One(ctx)
t.AssertNil(err)
t.Assert(one["year"].String(), now.Format("Y"))
t.Assert(one["date"].String(), now.Format("Y-m-d"))
t.Assert(one["time"].String(), now.Format("H:i:s"))
t.Assert(one["year"].String(), now.Layout("Y"))
t.Assert(one["date"].String(), now.Layout("Y-m-d"))
t.Assert(one["time"].String(), now.Layout("H:i:s"))
t.AssertLT(one["datetime"].GTime().Sub(now).Seconds(), 5)
t.AssertLT(one["timestamp"].GTime().Sub(now).Seconds(), 5)
})

6
contrib/drivers/oracle/oracle_z_unit_model_test.go
View File

@ -1128,7 +1128,7 @@ func Test_Model_Save(t *testing.T) {
user User
count int
result sql.Result
createTime = gtime.Now().Format("Y-m-d")
createTime = gtime.Now().Layout("Y-m-d")
err error
)
@ -1150,7 +1150,7 @@ func Test_Model_Save(t *testing.T) {
t.Assert(user.Passport, "p1")
t.Assert(user.Password, "15d55ad283aa400af464c76d713c07ad")
t.Assert(user.NickName, "n1")
t.Assert(user.CreateTime.Format("Y-m-d"), createTime)
t.Assert(user.CreateTime.Layout("Y-m-d"), createTime)
_, err = db.Model(table).Data(g.Map{
"id": 1,
@ -1166,7 +1166,7 @@ func Test_Model_Save(t *testing.T) {
t.Assert(user.Passport, "p1")
t.Assert(user.Password, "25d55ad283aa400af464c76d713c07ad")
t.Assert(user.NickName, "n2")
t.Assert(user.CreateTime.Format("Y-m-d"), createTime)
t.Assert(user.CreateTime.Layout("Y-m-d"), createTime)
count, err = db.Model(table).Count(ctx)
t.AssertNil(err)

6
contrib/drivers/sqlite/sqlite_z_unit_core_test.go
View File

@ -1505,7 +1505,7 @@ func Test_Types(t *testing.T) {
t.Assert(one["binary"].String(), data["binary"])
t.Assert(one["date"].String(), data["date"])
t.Assert(one["time"].String(), `10:00:01`)
t.Assert(one["timestamp"].GTime().Format(`Y-m-d H:i:s.u`), `2022-02-14 12:00:01.123`)
t.Assert(one["timestamp"].GTime().Layout(`Y-m-d H:i:s.u`), `2022-02-14 12:00:01.123`)
t.Assert(one["decimal"].String(), data["decimal"]) // In SQLite, the datatype of a value is associated with the value itself, not with its container.
t.Assert(one["double"].String(), data["double"])
t.Assert(one["tinyint"].Bool(), data["tinyint"])
@ -1528,9 +1528,9 @@ func Test_Types(t *testing.T) {
t.Assert(obj.Id, 1)
t.Assert(obj.Blob, data["blob"])
t.Assert(obj.Binary, data["binary"])
t.Assert(obj.Date.Format("Y-m-d"), data["date"])
t.Assert(obj.Date.Layout("Y-m-d"), data["date"])
t.Assert(obj.Time.String(), `10:00:01`)
t.Assert(obj.Timestamp.Format(`Y-m-d H:i:s.u`), `2022-02-14 12:00:01.123`)
t.Assert(obj.Timestamp.Layout(`Y-m-d H:i:s.u`), `2022-02-14 12:00:01.123`)
t.Assert(obj.Decimal, data["decimal"])
t.Assert(obj.Double, data["double"])
t.Assert(obj.TinyInt, data["tinyint"])

6
contrib/drivers/sqlitecgo/sqlitecgo_z_unit_core_test.go
View File

@ -1505,7 +1505,7 @@ func Test_Types(t *testing.T) {
t.Assert(one["binary"].String(), data["binary"])
t.Assert(one["date"].String(), data["date"])
t.Assert(one["time"].String(), `10:00:01`)
t.Assert(one["timestamp"].GTime().Format(`Y-m-d H:i:s.u`), `2022-02-14 12:00:01.123`)
t.Assert(one["timestamp"].GTime().Layout(`Y-m-d H:i:s.u`), `2022-02-14 12:00:01.123`)
t.Assert(one["decimal"].String(), data["decimal"]) // In SQLite, the datatype of a value is associated with the value itself, not with its container.
t.Assert(one["double"].String(), data["double"])
t.Assert(one["tinyint"].Bool(), data["tinyint"])
@ -1528,9 +1528,9 @@ func Test_Types(t *testing.T) {
t.Assert(obj.Id, 1)
t.Assert(obj.Blob, data["blob"])
t.Assert(obj.Binary, data["binary"])
t.Assert(obj.Date.Format("Y-m-d"), data["date"])
t.Assert(obj.Date.Layout("Y-m-d"), data["date"])
t.Assert(obj.Time.String(), `10:00:01`)
t.Assert(obj.Timestamp.Format(`Y-m-d H:i:s.u`), `2022-02-14 12:00:01.123`)
t.Assert(obj.Timestamp.Layout(`Y-m-d H:i:s.u`), `2022-02-14 12:00:01.123`)
t.Assert(obj.Decimal, data["decimal"])
t.Assert(obj.Double, data["double"])
t.Assert(obj.TinyInt, data["tinyint"])

2
contrib/rpc/grpcx/grpcx_unit_z_grpc_server_config_test.go
View File

@ -90,7 +90,7 @@ func Test_Grpcx_Grpc_Server_Config_Logger(t *testing.T) {
time.Sleep(time.Millisecond * 100)
defer s.Stop()
var logFilePath = fmt.Sprintf("/tmp/log/%s.log", gtime.Now().Format("Y-m-d"))
var logFilePath = fmt.Sprintf("/tmp/log/%s.log", gtime.Now().Layout("Y-m-d"))
defer gfile.RemoveFile(logFilePath)
t.Assert(gfile.Exists(logFilePath), true)
t.Assert(s.Logger().GetConfig().Prefix, "TestLogger")

20
database/gdb/gdb_core_structure.go
View File

@ -170,11 +170,11 @@ Default:
} else {
switch fieldType {
case fieldTypeYear:
convertedValue = r.Layout("2006")
convertedValue = r.Format("2006")
case fieldTypeDate:
convertedValue = r.Layout("2006-01-02")
convertedValue = r.Format("2006-01-02")
case fieldTypeTime:
convertedValue = r.Layout("15:04:05")
convertedValue = r.Format("15:04:05")
default:
convertedValue = r.Time
}
@ -186,11 +186,11 @@ Default:
} else {
switch fieldType {
case fieldTypeYear:
convertedValue = r.Layout("2006")
convertedValue = r.Format("2006")
case fieldTypeDate:
convertedValue = r.Layout("2006-01-02")
convertedValue = r.Format("2006-01-02")
case fieldTypeTime:
convertedValue = r.Layout("15:04:05")
convertedValue = r.Format("15:04:05")
default:
convertedValue = r.Time
}
@ -422,17 +422,17 @@ func (c *Core) ConvertValueForLocal(
case LocalTypeDate:
if t, ok := fieldValue.(time.Time); ok {
return gtime.NewFromTime(t).Format("Y-m-d"), nil
return gtime.NewFromTime(t).Layout("Y-m-d"), nil
}
t, _ := gtime.StrToTime(gconv.String(fieldValue))
return t.Format("Y-m-d"), nil
return t.Layout("Y-m-d"), nil
case LocalTypeTime:
if t, ok := fieldValue.(time.Time); ok {
return gtime.NewFromTime(t).Format("H:i:s"), nil
return gtime.NewFromTime(t).Layout("H:i:s"), nil
}
t, _ := gtime.StrToTime(gconv.String(fieldValue))
return t.Format("H:i:s"), nil
return t.Layout("H:i:s"), nil
case LocalTypeDatetime:
if t, ok := fieldValue.(time.Time); ok {

2
encoding/gjson/gjson_z_unit_test.go
View File

@ -400,7 +400,7 @@ func Test_Convert2(t *testing.T) {
t.Assert(j.Get("name").IsNil(), false)
t.Assert(j.Len("name1"), -1)
t.Assert(j.Get("time").Time().Format("2006-01-02"), "2019-06-12")
t.Assert(j.Get("time").GTime().Format("Y-m-d"), "2019-06-12")
t.Assert(j.Get("time").GTime().Layout("Y-m-d"), "2019-06-12")
t.Assert(j.Get("time").Duration().String(), "0s")
err := j.Var().Scan(&name)

6
net/ghttp/ghttp_z_unit_feature_log_test.go
View File

@ -47,17 +47,17 @@ func Test_Log(t *testing.T) {
t.Assert(client.GetContent(ctx, "/error"), "exception recovered: custom error")
var (
logPath1 = gfile.Join(logDir, gtime.Now().Format("Y-m-d")+".log")
logPath1 = gfile.Join(logDir, gtime.Now().Layout("Y-m-d")+".log")
content = gfile.GetContents(logPath1)
)
t.Assert(gstr.Contains(content, "http server started listening on"), true)
t.Assert(gstr.Contains(content, "HANDLER"), true)
logPath2 := gfile.Join(logDir, "access-"+gtime.Now().Format("Ymd")+".log")
logPath2 := gfile.Join(logDir, "access-"+gtime.Now().Layout("Ymd")+".log")
// fmt.Println(gfile.GetContents(logPath2))
t.Assert(gstr.Contains(gfile.GetContents(logPath2), " /hello "), true)
logPath3 := gfile.Join(logDir, "error-"+gtime.Now().Format("Ymd")+".log")
logPath3 := gfile.Join(logDir, "error-"+gtime.Now().Layout("Ymd")+".log")
// fmt.Println(gfile.GetContents(logPath3))
t.Assert(gstr.Contains(gfile.GetContents(logPath3), "custom error"), true)
})

2
os/glog/glog_logger.go
View File

@ -87,7 +87,7 @@ func (l *Logger) Clone() *Logger {
func (l *Logger) getFilePath(now time.Time) string {
// Content containing "{}" in the file name is formatted using gtime.
file, _ := gregex.ReplaceStringFunc(`{.+?}`, l.config.File, func(s string) string {
return gtime.New(now).Format(strings.Trim(s, "{}"))
return gtime.New(now).Layout(strings.Trim(s, "{}"))
})
file = gfile.Join(l.config.Path, file)
return file

2
os/glog/glog_logger_rotate.go
View File

@ -91,7 +91,7 @@ func (l *Logger) doRotateFile(ctx context.Context, filePath string) error {
dirPath,
fmt.Sprintf(
`%s.%s%d.%s`,
fileName, now.Format("YmdHisu"), micro, fileExtName,
fileName, now.Layout("YmdHisu"), micro, fileExtName,
),
)
if !gfile.Exists(newFilePath) {

54
os/gtime/gtime.go
View File

@ -155,12 +155,12 @@ func Datetime() string {
return time.Now().Format("2006-01-02 15:04:05")
}
// ISO8601 returns current datetime in ISO8601 format like "2006-01-02T15:04:05-07:00".
// ISO8601 returns current datetime in ISO8601 layout like "2006-01-02T15:04:05-07:00".
func ISO8601() string {
return time.Now().Format("2006-01-02T15:04:05-07:00")
}
// RFC822 returns current datetime in RFC822 format like "Mon, 02 Jan 06 15:04 MST".
// RFC822 returns current datetime in RFC822 layout like "Mon, 02 Jan 06 15:04 MST".
func RFC822() string {
return time.Now().Format("Mon, 02 Jan 06 15:04 MST")
}
@ -196,16 +196,16 @@ func parseDateStr(s string) (year, month, day int) {
}
// StrToTime converts string to *Time object. It also supports timestamp string.
// The parameter `format` is unnecessary, which specifies the format for converting like "Y-m-d H:i:s".
// If `format` is given, it acts as same as function StrToTimeFormat.
// If `format` is not given, it converts string as a "standard" datetime string.
// The parameter `layout` is unnecessary, which specifies the layout for converting like "Y-m-d H:i:s".
// If `layout` is given, it acts as same as function StrToTimeLayout.
// If `layout` is not given, it converts string as a "standard" datetime string.
// Note that, it fails and returns error if there's no date string in `str`.
func StrToTime(str string, format ...string) (*Time, error) {
func StrToTime(str string, layout ...string) (*Time, error) {
if str == "" {
return &Time{wrapper{time.Time{}}}, nil
}
if len(format) > 0 {
return StrToTimeFormat(str, format[0])
if len(layout) > 0 {
return StrToTimeLayout(str, layout[0])
}
if isTimestampStr(str) {
timestamp, _ := strconv.ParseInt(str, 10, 64)
@ -255,7 +255,7 @@ func StrToTime(str string, format ...string) (*Time, error) {
nsec *= 10
}
}
// If there's zone information in the string,
// If there's zone inlayoution in the string,
// it then performs time zone conversion, which converts the time zone to UTC.
if match[4] != "" && match[6] == "" {
match[6] = "000000"
@ -318,43 +318,43 @@ func ConvertZone(strTime string, toZone string, fromZone ...string) (*Time, erro
}
}
// StrToTimeFormat parses string `str` to *Time object with given format `format`.
// The parameter `format` is like "Y-m-d H:i:s".
func StrToTimeFormat(str string, format string) (*Time, error) {
return StrToTimeLayout(str, formatToStdLayout(format))
// StrToTimeLayout parses string `str` to *Time object with given layout `layout`.
// The parameter `layout` is like "Y-m-d H:i:s".
func StrToTimeLayout(str string, layout string) (*Time, error) {
return StrToTimeFormat(str, layoutToStdFormat(layout))
}
// StrToTimeLayout parses string `str` to *Time object with given format `layout`.
// The parameter `layout` is in stdlib format like "2006-01-02 15:04:05".
func StrToTimeLayout(str string, layout string) (*Time, error) {
if t, err := time.ParseInLocation(layout, str, time.Local); err == nil {
// StrToTimeFormat parses string `str` to *Time object with given layout `format`.
// The parameter `format` is in stdlib layout like "2006-01-02 15:04:05".
func StrToTimeFormat(str string, format string) (*Time, error) {
if t, err := time.ParseInLocation(format, str, time.Local); err == nil {
return NewFromTime(t), nil
} else {
return nil, gerror.WrapCodef(
gcode.CodeInvalidParameter, err,
`time.ParseInLocation failed for layout "%s" and value "%s"`,
layout, str,
`time.ParseInLocation failed for format "%s" and value "%s"`,
format, str,
)
}
}
// ParseTimeFromContent retrieves time information for content string, it then parses and returns it
// ParseTimeFromContent retrieves time inlayoution for content string, it then parses and returns it
// as *Time object.
// It returns the first time information if there are more than one time string in the content.
// It only retrieves and parses the time information with given first matched `format` if it's passed.
func ParseTimeFromContent(content string, format ...string) *Time {
// It returns the first time inlayoution if there are more than one time string in the content.
// It only retrieves and parses the time inlayoution with given first matched `layout` if it's passed.
func ParseTimeFromContent(content string, layout ...string) *Time {
var (
err error
match []string
)
if len(format) > 0 {
for _, item := range format {
match, err = gregex.MatchString(formatToRegexPattern(item), content)
if len(layout) > 0 {
for _, item := range layout {
match, err = gregex.MatchString(layoutToRegexPattern(item), content)
if err != nil {
intlog.Errorf(context.TODO(), `%+v`, err)
}
if len(match) > 0 {
return NewFromStrFormat(match[0], item)
return NewFromStrLayout(match[0], item)
}
}
} else {

116
os/gtime/gtime_format.go
View File

@ -17,7 +17,7 @@ import (
var (
// Refer: http://php.net/manual/en/function.date.php
formats = map[byte]string{
layouts = map[byte]string{
'd': "02", // Day: Day of the month, 2 digits with leading zeros. Eg: 01 to 31.
'D': "Mon", // Day: A textual representation of a day, three letters. Eg: Mon through Sun.
'w': "Monday", // Day: Numeric representation of the day of the week. Eg: 0 (for Sunday) through 6 (for Saturday).
@ -36,10 +36,10 @@ var (
'y': "06", // Year: A two-digit representation of a year. Eg: 99 or 03.
'a': "pm", // Time: Lowercase Ante meridiem and Post meridiem. Eg: am or pm.
'A': "PM", // Time: Uppercase Ante meridiem and Post meridiem. Eg: AM or PM.
'g': "3", // Time: 12-hour format of an hour without leading zeros. Eg: 1 through 12.
'G': "=G=15", // Time: 24-hour format of an hour without leading zeros. Eg: 0 through 23.
'h': "03", // Time: 12-hour format of an hour with leading zeros. Eg: 01 through 12.
'H': "15", // Time: 24-hour format of an hour with leading zeros. Eg: 00 through 23.
'g': "3", // Time: 12-hour layout of an hour without leading zeros. Eg: 1 through 12.
'G': "=G=15", // Time: 24-hour layout of an hour without leading zeros. Eg: 0 through 23.
'h': "03", // Time: 12-hour layout of an hour with leading zeros. Eg: 01 through 12.
'H': "15", // Time: 24-hour layout of an hour with leading zeros. Eg: 00 through 23.
'i': "04", // Time: Minutes with leading zeros. Eg: 00 to 59.
's': "05", // Time: Seconds with leading zeros. Eg: 00 through 59.
'u': "=u=.000", // Time: Milliseconds. Eg: 234, 678.
@ -47,8 +47,8 @@ var (
'O': "-0700", // Zone: Difference to Greenwich time (GMT) in hours. Eg: +0200.
'P': "-07:00", // Zone: Difference to Greenwich time (GMT) with colon between hours and minutes. Eg: +02:00.
'T': "MST", // Zone: Timezone abbreviation. Eg: UTC, EST, MDT ...
'c': "2006-01-02T15:04:05-07:00", // Format: ISO 8601 date. Eg: 2004-02-12T15:19:21+00:00.
'r': "Mon, 02 Jan 06 15:04 MST", // Format: RFC 2822 formatted date. Eg: Thu, 21 Dec 2000 16:01:07 +0200.
'c': "2006-01-02T15:04:05-07:00", // Layout: ISO 8601 date. Eg: 2004-02-12T15:19:21+00:00.
'r': "Mon, 02 Jan 06 15:04 MST", // Layout: RFC 2822 layoutted date. Eg: Thu, 21 Dec 2000 16:01:07 +0200.
}
// Week to number mapping.
@ -66,13 +66,13 @@ var (
dayOfMonth = []int{0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334}
)
// Format formats and returns the formatted result with custom `format`.
// Refer method Layout if you want to follow stdlib layout.
func (t *Time) Format(format string) string {
// Layout layouts and returns the layoutted result with custom `layout`.
// Refer method Format if you want to follow stdlib format.
func (t *Time) Layout(layout string) string {
if t == nil {
return ""
}
runes := []rune(format)
runes := []rune(layout)
buffer := bytes.NewBuffer(nil)
for i := 0; i < len(runes); {
switch runes[i] {
@ -97,7 +97,7 @@ func (t *Time) Format(format string) string {
buffer.WriteRune(runes[i])
break
}
if f, ok := formats[byte(runes[i])]; ok {
if f, ok := layouts[byte(runes[i])]; ok {
result := t.Time.Format(f)
// Particular chars should be handled here.
switch runes[i] {
@ -118,7 +118,7 @@ func (t *Time) Format(format string) string {
case 'N':
buffer.WriteString(strings.ReplaceAll(weekMap[result], "0", "7"))
case 'S':
buffer.WriteString(formatMonthDaySuffixMap(result))
buffer.WriteString(layoutMonthDaySuffixMap(result))
default:
buffer.WriteString(result)
}
@ -131,49 +131,49 @@ func (t *Time) Format(format string) string {
return buffer.String()
}
// FormatNew formats and returns a new Time object with given custom `format`.
func (t *Time) FormatNew(format string) *Time {
if t == nil {
return nil
}
return NewFromStr(t.Format(format))
}
// FormatTo formats `t` with given custom `format`.
func (t *Time) FormatTo(format string) *Time {
if t == nil {
return nil
}
t.Time = NewFromStr(t.Format(format)).Time
return t
}
// Layout formats the time with stdlib layout and returns the formatted result.
func (t *Time) Layout(layout string) string {
if t == nil {
return ""
}
return t.Time.Format(layout)
}
// LayoutNew formats the time with stdlib layout and returns the new Time object.
// LayoutNew layouts and returns a new Time object with given custom `layout`.
func (t *Time) LayoutNew(layout string) *Time {
if t == nil {
return nil
}
newTime, err := StrToTimeLayout(t.Layout(layout), layout)
return NewFromStr(t.Layout(layout))
}
// LayoutTo layouts `t` with given custom `layout`.
func (t *Time) LayoutTo(layout string) *Time {
if t == nil {
return nil
}
t.Time = NewFromStr(t.Layout(layout)).Time
return t
}
// Format layouts the time with stdlib format and returns the layoutted result.
func (t *Time) Format(format string) string {
if t == nil {
return ""
}
return t.Time.Format(format)
}
// FormatNew layouts the time with stdlib format and returns the new Time object.
func (t *Time) FormatNew(format string) *Time {
if t == nil {
return nil
}
newTime, err := StrToTimeFormat(t.Format(format), format)
if err != nil {
panic(err)
}
return newTime
}
// LayoutTo formats `t` with stdlib layout.
func (t *Time) LayoutTo(layout string) *Time {
// FormatTo layouts `t` with stdlib format.
func (t *Time) FormatTo(format string) *Time {
if t == nil {
return nil
}
newTime, err := StrToTimeLayout(t.Layout(layout), layout)
newTime, err := StrToTimeFormat(t.Format(format), format)
if err != nil {
panic(err)
}
@ -225,14 +225,14 @@ func (t *Time) WeeksOfYear() int {
return week
}
// formatToStdLayout converts the custom format to stdlib layout.
func formatToStdLayout(format string) string {
// layoutToStdFormat converts the custom layout to stdlib format.
func layoutToStdFormat(layout string) string {
b := bytes.NewBuffer(nil)
for i := 0; i < len(format); {
switch format[i] {
for i := 0; i < len(layout); {
switch layout[i] {
case '\\':
if i < len(format)-1 {
b.WriteByte(format[i+1])
if i < len(layout)-1 {
b.WriteByte(layout[i+1])
i += 2
continue
} else {
@ -240,15 +240,15 @@ func formatToStdLayout(format string) string {
}
default:
if f, ok := formats[format[i]]; ok {
if f, ok := layouts[layout[i]]; ok {
// Handle particular chars.
switch format[i] {
switch layout[i] {
case 'j':
b.WriteString("2")
case 'G':
b.WriteString("15")
case 'u':
if i > 0 && format[i-1] == '.' {
if i > 0 && layout[i-1] == '.' {
b.WriteString("000")
} else {
b.WriteString(".000")
@ -258,7 +258,7 @@ func formatToStdLayout(format string) string {
b.WriteString(f)
}
} else {
b.WriteByte(format[i])
b.WriteByte(layout[i])
}
i++
}
@ -266,17 +266,17 @@ func formatToStdLayout(format string) string {
return b.String()
}
// formatToRegexPattern converts the custom format to its corresponding regular expression.
func formatToRegexPattern(format string) string {
s := regexp.QuoteMeta(formatToStdLayout(format))
// layoutToRegexPattern converts the custom layout to its corresponding regular expression.
func layoutToRegexPattern(layout string) string {
s := regexp.QuoteMeta(layoutToStdFormat(layout))
s, _ = gregex.ReplaceString(`[0-9]`, `[0-9]`, s)
s, _ = gregex.ReplaceString(`[A-Za-z]`, `[A-Za-z]`, s)
s, _ = gregex.ReplaceString(`\s+`, `\s+`, s)
return s
}
// formatMonthDaySuffixMap returns the short english word for current day.
func formatMonthDaySuffixMap(day string) string {
// layoutMonthDaySuffixMap returns the short english word for current day.
func layoutMonthDaySuffixMap(day string) string {
switch day {
case "01", "21", "31":
return "st"

4
os/gtime/gtime_sql.go
View File

@ -6,7 +6,7 @@ import (
// Scan implements interface used by Scan in package database/sql for Scanning value
// from database to local golang variable.
func (t *Time) Scan(value interface{}) error {
func (t *Time) Scan(value any) error {
if t == nil {
return nil
}
@ -27,7 +27,7 @@ func (t *Time) Value() (driver.Value, error) {
if t.Year() == 0 {
// Only time.
return t.Format("15:04:05"), nil
return t.Layout("15:04:05"), nil
}
return t.Time, nil

36
os/gtime/gtime_time.go
View File

@ -31,7 +31,7 @@ type iUnixNano interface {
// New("2024-10-29")
// New(1390876568)
// New(t) // The t is type of time.Time.
func New(param ...interface{}) *Time {
func New(param ...any) *Time {
if len(param) > 0 {
switch r := param[0].(type) {
case time.Time:
@ -49,9 +49,9 @@ func New(param ...interface{}) *Time {
if len(param) > 1 {
switch t := param[1].(type) {
case string:
return NewFromStrFormat(r, t)
return NewFromStrLayout(r, t)
case []byte:
return NewFromStrFormat(r, string(t))
return NewFromStrLayout(r, string(t))
}
}
return NewFromStr(r)
@ -60,9 +60,9 @@ func New(param ...interface{}) *Time {
if len(param) > 1 {
switch t := param[1].(type) {
case string:
return NewFromStrFormat(string(r), t)
return NewFromStrLayout(string(r), t)
case []byte:
return NewFromStrFormat(string(r), string(t))
return NewFromStrLayout(string(r), string(t))
}
}
return NewFromStr(string(r))
@ -107,21 +107,21 @@ func NewFromStr(str string) *Time {
return nil
}
// NewFromStrFormat creates and returns a Time object with given string and
// custom format like: Y-m-d H:i:s.
// NewFromStrLayout creates and returns a Time object with given string and
// custom layout like: Y-m-d H:i:s.
// Note that it returns nil if there's error occurs.
func NewFromStrFormat(str string, format string) *Time {
if t, err := StrToTimeFormat(str, format); err == nil {
func NewFromStrLayout(str string, layout string) *Time {
if t, err := StrToTimeLayout(str, layout); err == nil {
return t
}
return nil
}
// NewFromStrLayout creates and returns a Time object with given string and
// stdlib layout like: 2006-01-02 15:04:05.
// NewFromStrFormat creates and returns a Time object with given string and
// stdlib format like: 2006-01-02 15:04:05.
// Note that it returns nil if there's error occurs.
func NewFromStrLayout(str string, layout string) *Time {
if t, err := StrToTimeLayout(str, layout); err == nil {
func NewFromStrFormat(str string, format string) *Time {
if t, err := StrToTimeFormat(str, format); err == nil {
return t
}
return nil
@ -307,14 +307,14 @@ func (t *Time) UTC() *Time {
return newTime
}
// ISO8601 formats the time as ISO8601 and returns it as string.
// ISO8601 layouts the time as ISO8601 and returns it as string.
func (t *Time) ISO8601() string {
return t.Layout("2006-01-02T15:04:05-07:00")
return t.Format("2006-01-02T15:04:05-07:00")
}
// RFC822 formats the time as RFC822 and returns it as string.
// RFC822 layouts the time as RFC822 and returns it as string.
func (t *Time) RFC822() string {
return t.Layout("Mon, 02 Jan 06 15:04 MST")
return t.Format("Mon, 02 Jan 06 15:04 MST")
}
// AddDate adds year, month and day to the time.
@ -550,7 +550,7 @@ func (t *Time) UnmarshalText(data []byte) error {
func (t *Time) NoValidation() {}
// DeepCopy implements interface for deep copy of current type.
func (t *Time) DeepCopy() interface{} {
func (t *Time) DeepCopy() any {
if t == nil {
return nil
}

6
os/gtime/gtime_z_bench_test.go
View File

@ -43,15 +43,15 @@ func Benchmark_StrToTime(b *testing.B) {
}
}
func Benchmark_StrToTime_Format(b *testing.B) {
func Benchmark_StrToTime_Layout(b *testing.B) {
for i := 0; i < b.N; i++ {
gtime.StrToTime("2018-02-09 20:46:17.897", "Y-m-d H:i:su")
}
}
func Benchmark_StrToTime_Layout(b *testing.B) {
func Benchmark_StrToTime_Format(b *testing.B) {
for i := 0; i < b.N; i++ {
gtime.StrToTimeLayout("2018-02-09T20:46:17.897Z", time.RFC3339)
gtime.StrToTimeFormat("2018-02-09T20:46:17.897Z", time.RFC3339)
}
}

44
os/gtime/gtime_z_example_basic_test.go
View File

@ -100,16 +100,16 @@ func ExampleConvertZone() {
// 2006-01-02 16:04:05
}
func ExampleStrToTimeFormat() {
res, _ := gtime.StrToTimeFormat("2006-01-02 15:04:05", "Y-m-d H:i:s")
func ExampleStrToTimeLayout() {
res, _ := gtime.StrToTimeLayout("2006-01-02 15:04:05", "Y-m-d H:i:s")
fmt.Println(res)
// Output:
// 2006-01-02 15:04:05
}
func ExampleStrToTimeLayout() {
res, _ := gtime.StrToTimeLayout("2018-08-08", "2006-01-02")
func ExampleStrToTimeFormat() {
res, _ := gtime.StrToTimeFormat("2018-08-08", "2006-01-02")
fmt.Println(res)
// Output:
@ -131,15 +131,15 @@ func ExampleParseDuration() {
// 10h0m0s
}
func ExampleTime_Format() {
func ExampleTime_Layout() {
gt1 := gtime.New("2018-08-08 08:08:08")
fmt.Println(gt1.Format("Y-m-d"))
fmt.Println(gt1.Format("l"))
fmt.Println(gt1.Format("F j, Y, g:i a"))
fmt.Println(gt1.Format("j, n, Y"))
fmt.Println(gt1.Format("h-i-s, j-m-y, it is w Day z"))
fmt.Println(gt1.Format("D M j G:i:s T Y"))
fmt.Println(gt1.Layout("Y-m-d"))
fmt.Println(gt1.Layout("l"))
fmt.Println(gt1.Layout("F j, Y, g:i a"))
fmt.Println(gt1.Layout("j, n, Y"))
fmt.Println(gt1.Layout("h-i-s, j-m-y, it is w Day z"))
fmt.Println(gt1.Layout("D M j G:i:s T Y"))
// Output:
// 2018-08-08
@ -150,48 +150,48 @@ func ExampleTime_Format() {
// Wed Aug 8 8:08:08 CST 2018
}
func ExampleTime_FormatNew() {
func ExampleTime_LayoutNew() {
gt1 := gtime.New("2018-08-08 08:08:08")
fmt.Println(gt1.FormatNew("Y-m-d"))
fmt.Println(gt1.FormatNew("Y-m-d H:i"))
fmt.Println(gt1.LayoutNew("Y-m-d"))
fmt.Println(gt1.LayoutNew("Y-m-d H:i"))
// Output:
// 2018-08-08 00:00:00
// 2018-08-08 08:08:00
}
func ExampleTime_FormatTo() {
func ExampleTime_LayoutTo() {
gt1 := gtime.New("2018-08-08 08:08:08")
fmt.Println(gt1.FormatTo("Y-m-d"))
fmt.Println(gt1.LayoutTo("Y-m-d"))
// Output:
// 2018-08-08 00:00:00
}
func ExampleTime_Layout() {
func ExampleTime_Format() {
gt1 := gtime.New("2018-08-08 08:08:08")
fmt.Println(gt1.Layout("2006-01-02"))
fmt.Println(gt1.Format("2006-01-02"))
// Output:
// 2018-08-08
}
func ExampleTime_LayoutNew() {
func ExampleTime_FormatNew() {
gt1 := gtime.New("2018-08-08 08:08:08")
fmt.Println(gt1.LayoutNew("2006-01-02"))
fmt.Println(gt1.FormatNew("2006-01-02"))
// Output:
// 2018-08-08 00:00:00
}
func ExampleTime_LayoutTo() {
func ExampleTime_FormatTo() {
gt1 := gtime.New("2018-08-08 08:08:08")
fmt.Println(gt1.LayoutTo("2006-01-02"))
fmt.Println(gt1.FormatTo("2006-01-02"))
// Output:
// 2018-08-08 00:00:00

20
os/gtime/gtime_z_example_time_test.go
View File

@ -41,8 +41,8 @@ func ExampleNew_Basic() {
// 08:08:08
}
func ExampleNew_WithFormat() {
fmt.Println(gtime.New("20220629133225", "YmdHis").Format("Y-m-d H:i:s"))
func ExampleNew_WithLayout() {
fmt.Println(gtime.New("20220629133225", "YmdHis").Layout("Y-m-d H:i:s"))
// Output:
// 2022-06-29 13:32:25
@ -82,22 +82,22 @@ func ExampleNewFromStr() {
// 08:08:08
}
// NewFromStrFormat creates and returns a Time object with given string and
// custom format like: Y-m-d H:i:s.
// NewFromStrLayout creates and returns a Time object with given string and
// custom layout like: Y-m-d H:i:s.
// Note that it returns nil if there's error occurs.
func ExampleNewFromStrFormat() {
t := gtime.NewFromStrFormat("2018-08-08 08:08:08", "Y-m-d H:i:s")
func ExampleNewFromStrLayout() {
t := gtime.NewFromStrLayout("2018-08-08 08:08:08", "Y-m-d H:i:s")
fmt.Println(t)
// Output:
// 2018-08-08 08:08:08
}
// NewFromStrLayout creates and returns a Time object with given string and
// stdlib layout like: 2006-01-02 15:04:05.
// NewFromStrFormat creates and returns a Time object with given string and
// stdlib format like: 2006-01-02 15:04:05.
// Note that it returns nil if there's error occurs.
func ExampleNewFromStrLayout() {
t := gtime.NewFromStrLayout("2018-08-08 08:08:08", "2006-01-02 15:04:05")
func ExampleNewFromStrFormat() {
t := gtime.NewFromStrFormat("2018-08-08 08:08:08", "2006-01-02 15:04:05")
fmt.Println(t)
// Output:

64
os/gtime/gtime_z_unit_format_test.go
View File

@ -13,43 +13,43 @@ import (
"github.com/gogf/gf/v3/test/gtest"
)
func Test_Format(t *testing.T) {
func Test_Layout(t *testing.T) {
gtest.C(t, func(t *gtest.T) {
timeTemp, err := gtime.StrToTime("2006-01-11 15:04:05", "Y-m-d H:i:s")
timeTemp.ToZone("Asia/Shanghai")
if err != nil {
t.Error("test fail")
}
t.Assert(timeTemp.Format("\\T\\i\\m\\e中文Y-m-j G:i:s.u\\"), "Time中文2006-01-11 15:04:05.000")
t.Assert(timeTemp.Layout("\\T\\i\\m\\e中文Y-m-j G:i:s.u\\"), "Time中文2006-01-11 15:04:05.000")
t.Assert(timeTemp.Format("d D j l"), "11 Wed 11 Wednesday")
t.Assert(timeTemp.Layout("d D j l"), "11 Wed 11 Wednesday")
t.Assert(timeTemp.Format("F m M n"), "January 01 Jan 1")
t.Assert(timeTemp.Layout("F m M n"), "January 01 Jan 1")
t.Assert(timeTemp.Format("Y y"), "2006 06")
t.Assert(timeTemp.Layout("Y y"), "2006 06")
t.Assert(timeTemp.Format("a A g G h H i s u .u"), "pm PM 3 15 03 15 04 05 000 .000")
t.Assert(timeTemp.Layout("a A g G h H i s u .u"), "pm PM 3 15 03 15 04 05 000 .000")
t.Assert(timeTemp.Format("O P T"), "+0800 +08:00 CST")
t.Assert(timeTemp.Layout("O P T"), "+0800 +08:00 CST")
t.Assert(timeTemp.Format("r"), "Wed, 11 Jan 06 15:04 CST")
t.Assert(timeTemp.Layout("r"), "Wed, 11 Jan 06 15:04 CST")
t.Assert(timeTemp.Format("c"), "2006-01-11T15:04:05+08:00")
t.Assert(timeTemp.Layout("c"), "2006-01-11T15:04:05+08:00")
//补零
timeTemp1, err := gtime.StrToTime("2006-01-02 03:04:05", "Y-m-d H:i:s")
if err != nil {
t.Error("test fail")
}
t.Assert(timeTemp1.Format("Y-m-d h:i:s"), "2006-01-02 03:04:05")
t.Assert(timeTemp1.Layout("Y-m-d h:i:s"), "2006-01-02 03:04:05")
//不补零
timeTemp2, err := gtime.StrToTime("2006-01-02 03:04:05", "Y-m-d H:i:s")
if err != nil {
t.Error("test fail")
}
t.Assert(timeTemp2.Format("Y-n-j G:i:s"), "2006-1-2 3:04:05")
t.Assert(timeTemp2.Layout("Y-n-j G:i:s"), "2006-1-2 3:04:05")
t.Assert(timeTemp2.Format("U"), "1136142245")
t.Assert(timeTemp2.Layout("U"), "1136142245")
// 测试数字型的星期
times := []map[string]string{
@ -88,22 +88,22 @@ func Test_Format(t *testing.T) {
for _, v := range times {
t1, err1 := gtime.StrToTime(v["k"], "Y-m-d")
t.Assert(err1, nil)
t.Assert(t1.Format(v["f"]), v["r"])
t.Assert(t1.Layout(v["f"]), v["r"])
}
})
gtest.C(t, func(t *gtest.T) {
var ti *gtime.Time = nil
t.Assert(ti.Format("Y-m-d h:i:s"), "")
t.Assert(ti.FormatNew("Y-m-d h:i:s"), nil)
t.Assert(ti.FormatTo("Y-m-d h:i:s"), nil)
t.Assert(ti.Layout("Y-m-d h:i:s"), "")
t.Assert(ti.LayoutNew("Y-m-d h:i:s"), nil)
t.Assert(ti.LayoutTo("Y-m-d h:i:s"), nil)
t.Assert(ti.Format("Y-m-d h:i:s"), "")
t.Assert(ti.FormatNew("Y-m-d h:i:s"), nil)
t.Assert(ti.LayoutTo("Y-m-d h:i:s"), nil)
})
}
func Test_Format_ZeroString(t *testing.T) {
func Test_Layout_ZeroString(t *testing.T) {
gtest.C(t, func(t *gtest.T) {
timeTemp, err := gtime.StrToTime("0000-00-00 00:00:00")
t.AssertNE(err, nil)
@ -111,23 +111,23 @@ func Test_Format_ZeroString(t *testing.T) {
})
}
func Test_FormatTo(t *testing.T) {
gtest.C(t, func(t *gtest.T) {
timeTemp := gtime.Now()
t.Assert(timeTemp.FormatTo("Y-m-01 00:00:01"), timeTemp.Time.Format("2006-01")+"-01 00:00:01")
})
}
func Test_Layout(t *testing.T) {
gtest.C(t, func(t *gtest.T) {
timeTemp := gtime.Now()
t.Assert(timeTemp.Layout("2006-01-02 15:04:05"), timeTemp.Time.Format("2006-01-02 15:04:05"))
})
}
func Test_LayoutTo(t *testing.T) {
gtest.C(t, func(t *gtest.T) {
timeTemp := gtime.Now()
t.Assert(timeTemp.LayoutTo("2006-01-02 00:00:00"), timeTemp.Time.Format("2006-01-02 00:00:00"))
t.Assert(timeTemp.LayoutTo("Y-m-01 00:00:01"), timeTemp.Time.Format("2006-01")+"-01 00:00:01")
})
}
func Test_Format(t *testing.T) {
gtest.C(t, func(t *gtest.T) {
timeTemp := gtime.Now()
t.Assert(timeTemp.Format("2006-01-02 15:04:05"), timeTemp.Time.Format("2006-01-02 15:04:05"))
})
}
func Test_FormatTo(t *testing.T) {
gtest.C(t, func(t *gtest.T) {
timeTemp := gtime.Now()
t.Assert(timeTemp.FormatTo("2006-01-02 00:00:00"), timeTemp.Time.Format("2006-01-02 00:00:00"))
})
}

14
os/gtime/gtime_z_unit_issue_test.go
View File

@ -27,7 +27,7 @@ func Test_Issue1681(t *testing.T) {
// https://github.com/gogf/gf/issues/2803
func Test_Issue2803(t *testing.T) {
gtest.C(t, func(t *gtest.T) {
newTime := gtime.New("2023-07-26").LayoutTo("2006-01")
newTime := gtime.New("2023-07-26").FormatTo("2006-01")
t.Assert(newTime.Year(), 2023)
t.Assert(newTime.Month(), 7)
t.Assert(newTime.Day(), 1)
@ -51,9 +51,9 @@ func Test_Issue3558(t *testing.T) {
stdTime, err := time.Parse(time.RFC3339, timeStr)
t.AssertNil(err)
stdTimeFormat := stdTime.Format("2006-01-02 15:04:05")
gfTimeFormat := gfTime.Format("Y-m-d H:i:s")
t.Assert(gfTimeFormat, stdTimeFormat)
stdTimeLayout := stdTime.Format("2006-01-02 15:04:05")
gfTimeLayout := gfTime.Layout("Y-m-d H:i:s")
t.Assert(gfTimeLayout, stdTimeLayout)
})
gtest.C(t, func(t *gtest.T) {
timeStr := "1880-10-24T00:00:00-08:05"
@ -66,8 +66,8 @@ func Test_Issue3558(t *testing.T) {
t.Assert(gfTime.Second(), 0)
stdTime, err := time.Parse(time.RFC3339, timeStr)
t.AssertNil(err)
stdTimeFormat := stdTime.Format("2006-01-02 15:04:05")
gfTimeFormat := gfTime.Format("Y-m-d H:i:s")
t.Assert(gfTimeFormat, stdTimeFormat)
stdTimeLayout := stdTime.Format("2006-01-02 15:04:05")
gfTimeLayout := gfTime.Layout("Y-m-d H:i:s")
t.Assert(gfTimeLayout, stdTimeLayout)
})
}

14
os/gtime/gtime_z_unit_test.go
View File

@ -83,14 +83,14 @@ func Test_Datetime(t *testing.T) {
func Test_ISO8601(t *testing.T) {
gtest.C(t, func(t *gtest.T) {
iso8601 := gtime.ISO8601()
t.Assert(iso8601, gtime.Now().Format("c"))
t.Assert(iso8601, gtime.Now().Layout("c"))
})
}
func Test_RFC822(t *testing.T) {
gtest.C(t, func(t *gtest.T) {
rfc822 := gtime.RFC822()
t.Assert(rfc822, gtime.Now().Format("r"))
t.Assert(rfc822, gtime.Now().Layout("r"))
})
}
@ -145,8 +145,8 @@ func Test_StrToTime(t *testing.T) {
t.Assert(time1.Time, time2)
}
// formatToStdLayout
var testDateFormats = []string{
// layoutToStdFormat
var testDateLayouts = []string{
"Y-m-d H:i:s",
"\\T\\i\\m\\e Y-m-d H:i:s",
"Y-m-d H:i:s\\",
@ -154,7 +154,7 @@ func Test_StrToTime(t *testing.T) {
"Y-m-j G:i:su",
}
var testDateFormatsResult = []string{
var testDateLayoutsResult = []string{
"2007-01-02 15:04:05",
"Time 2007-01-02 15:04:05",
"2007-01-02 15:04:05",
@ -162,8 +162,8 @@ func Test_StrToTime(t *testing.T) {
"2007-01-02 15:04:05.000",
}
for index, item := range testDateFormats {
timeTemp, err := gtime.StrToTime(testDateFormatsResult[index], item)
for index, item := range testDateLayouts {
timeTemp, err := gtime.StrToTime(testDateLayoutsResult[index], item)
if err != nil {
t.Error("test fail")
}

98
os/gtime/gtime_z_unit_time_test.go
View File

@ -47,23 +47,23 @@ func Test_New(t *testing.T) {
// short datetime.
gtest.C(t, func(t *gtest.T) {
timeTemp := gtime.New("2021-2-9 08:01:21")
t.Assert(timeTemp.Format("Y-m-d H:i:s"), "2021-02-09 08:01:21")
t.Assert(timeTemp.Layout("Y-m-d H:i:s"), "2021-02-09 08:01:21")
t.Assert(timeTemp.Time.Format("2006-01-02 15:04:05"), "2021-02-09 08:01:21")
timeTemp = gtime.New("2021-02-09 08:01:21", []byte("Y-m-d H:i:s"))
t.Assert(timeTemp.Format("Y-m-d H:i:s"), "2021-02-09 08:01:21")
t.Assert(timeTemp.Layout("Y-m-d H:i:s"), "2021-02-09 08:01:21")
t.Assert(timeTemp.Time.Format("2006-01-02 15:04:05"), "2021-02-09 08:01:21")
timeTemp = gtime.New([]byte("2021-02-09 08:01:21"))
t.Assert(timeTemp.Format("Y-m-d H:i:s"), "2021-02-09 08:01:21")
t.Assert(timeTemp.Layout("Y-m-d H:i:s"), "2021-02-09 08:01:21")
t.Assert(timeTemp.Time.Format("2006-01-02 15:04:05"), "2021-02-09 08:01:21")
timeTemp = gtime.New([]byte("2021-02-09 08:01:21"), "Y-m-d H:i:s")
t.Assert(timeTemp.Format("Y-m-d H:i:s"), "2021-02-09 08:01:21")
t.Assert(timeTemp.Layout("Y-m-d H:i:s"), "2021-02-09 08:01:21")
t.Assert(timeTemp.Time.Format("2006-01-02 15:04:05"), "2021-02-09 08:01:21")
timeTemp = gtime.New([]byte("2021-02-09 08:01:21"), []byte("Y-m-d H:i:s"))
t.Assert(timeTemp.Format("Y-m-d H:i:s"), "2021-02-09 08:01:21")
t.Assert(timeTemp.Layout("Y-m-d H:i:s"), "2021-02-09 08:01:21")
t.Assert(timeTemp.Time.Format("2006-01-02 15:04:05"), "2021-02-09 08:01:21")
})
//
@ -103,7 +103,7 @@ func Test_Nil(t *testing.T) {
func Test_NewFromStr(t *testing.T) {
gtest.C(t, func(t *gtest.T) {
timeTemp := gtime.NewFromStr("2006-01-02 15:04:05")
t.Assert(timeTemp.Format("Y-m-d H:i:s"), "2006-01-02 15:04:05")
t.Assert(timeTemp.Layout("Y-m-d H:i:s"), "2006-01-02 15:04:05")
timeTemp1 := gtime.NewFromStr("2006.0102")
if timeTemp1 != nil {
@ -124,32 +124,32 @@ func Test_String(t *testing.T) {
})
}
func Test_NewFromStrFormat(t *testing.T) {
func Test_NewFromStrLayout(t *testing.T) {
gtest.C(t, func(t *gtest.T) {
timeTemp := gtime.NewFromStrFormat("2006-01-02 15:04:05", "Y-m-d H:i:s")
t.Assert(timeTemp.Format("Y-m-d H:i:s"), "2006-01-02 15:04:05")
timeTemp := gtime.NewFromStrLayout("2006-01-02 15:04:05", "Y-m-d H:i:s")
t.Assert(timeTemp.Layout("Y-m-d H:i:s"), "2006-01-02 15:04:05")
timeTemp1 := gtime.NewFromStrFormat("2006-01-02 15:04:05", "aabbcc")
timeTemp1 := gtime.NewFromStrLayout("2006-01-02 15:04:05", "aabbcc")
if timeTemp1 != nil {
t.Error("test fail")
}
})
gtest.C(t, func(t *gtest.T) {
t1 := gtime.NewFromStrFormat("2019/2/1", "Y/n/j")
t.Assert(t1.Format("Y-m-d"), "2019-02-01")
t1 := gtime.NewFromStrLayout("2019/2/1", "Y/n/j")
t.Assert(t1.Layout("Y-m-d"), "2019-02-01")
t2 := gtime.NewFromStrFormat("2019/10/12", "Y/n/j")
t.Assert(t2.Format("Y-m-d"), "2019-10-12")
t2 := gtime.NewFromStrLayout("2019/10/12", "Y/n/j")
t.Assert(t2.Layout("Y-m-d"), "2019-10-12")
})
}
func Test_NewFromStrLayout(t *testing.T) {
func Test_NewFromStrFormat(t *testing.T) {
gtest.C(t, func(t *gtest.T) {
timeTemp := gtime.NewFromStrLayout("2006-01-02 15:04:05", "2006-01-02 15:04:05")
t.Assert(timeTemp.Format("Y-m-d H:i:s"), "2006-01-02 15:04:05")
timeTemp := gtime.NewFromStrFormat("2006-01-02 15:04:05", "2006-01-02 15:04:05")
t.Assert(timeTemp.Layout("Y-m-d H:i:s"), "2006-01-02 15:04:05")
timeTemp1 := gtime.NewFromStrLayout("2006-01-02 15:04:05", "aabbcc")
timeTemp1 := gtime.NewFromStrFormat("2006-01-02 15:04:05", "aabbcc")
if timeTemp1 != nil {
t.Error("test fail")
}
@ -159,11 +159,11 @@ func Test_NewFromStrLayout(t *testing.T) {
func Test_NewFromTimeStamp(t *testing.T) {
gtest.C(t, func(t *gtest.T) {
timeTemp := gtime.NewFromTimeStamp(1554459846000)
t.Assert(timeTemp.Format("Y-m-d H:i:s"), "2019-04-05 18:24:06")
t.Assert(timeTemp.Layout("Y-m-d H:i:s"), "2019-04-05 18:24:06")
timeTemp1 := gtime.NewFromTimeStamp(0)
t.Assert(timeTemp1.Format("Y-m-d H:i:s"), "0001-01-01 00:00:00")
t.Assert(timeTemp1.Layout("Y-m-d H:i:s"), "0001-01-01 00:00:00")
timeTemp2 := gtime.NewFromTimeStamp(155445984)
t.Assert(timeTemp2.Format("Y-m-d H:i:s"), "1974-12-05 11:26:24")
t.Assert(timeTemp2.Layout("Y-m-d H:i:s"), "1974-12-05 11:26:24")
})
}
@ -249,14 +249,14 @@ func Test_Time_String(t *testing.T) {
func Test_Time_ISO8601(t *testing.T) {
gtest.C(t, func(t *gtest.T) {
now := gtime.Now()
t.Assert(now.ISO8601(), now.Format("c"))
t.Assert(now.ISO8601(), now.Layout("c"))
})
}
func Test_Time_RFC822(t *testing.T) {
gtest.C(t, func(t *gtest.T) {
now := gtime.Now()
t.Assert(now.RFC822(), now.Format("r"))
t.Assert(now.RFC822(), now.Layout("r"))
})
}
@ -280,7 +280,7 @@ func Test_Add(t *testing.T) {
gtest.C(t, func(t *gtest.T) {
timeTemp := gtime.NewFromStr("2006-01-02 15:04:05")
timeTemp = timeTemp.Add(time.Second)
t.Assert(timeTemp.Format("Y-m-d H:i:s"), "2006-01-02 15:04:06")
t.Assert(timeTemp.Layout("Y-m-d H:i:s"), "2006-01-02 15:04:06")
})
}
@ -308,7 +308,7 @@ func Test_AddDate(t *testing.T) {
gtest.C(t, func(t *gtest.T) {
timeTemp := gtime.NewFromStr("2006-01-02 15:04:05")
timeTemp = timeTemp.AddDate(1, 2, 3)
t.Assert(timeTemp.Format("Y-m-d H:i:s"), "2007-03-05 15:04:05")
t.Assert(timeTemp.Layout("Y-m-d H:i:s"), "2007-03-05 15:04:05")
})
}
@ -352,7 +352,7 @@ func Test_StartOfMinute(t *testing.T) {
gtest.C(t, func(t *gtest.T) {
timeTemp := gtime.NewFromStr("2020-12-12 18:24:06")
timeTemp1 := timeTemp.StartOfMinute()
t.Assert(timeTemp1.Format("Y-m-d H:i:s"), "2020-12-12 18:24:00")
t.Assert(timeTemp1.Layout("Y-m-d H:i:s"), "2020-12-12 18:24:00")
})
}
@ -360,12 +360,12 @@ func Test_EndOfMinute(t *testing.T) {
gtest.C(t, func(t *gtest.T) {
timeTemp := gtime.NewFromStr("2020-12-12 18:24:06")
timeTemp1 := timeTemp.EndOfMinute()
t.Assert(timeTemp1.Format("Y-m-d H:i:s.u"), "2020-12-12 18:24:59.000")
t.Assert(timeTemp1.Layout("Y-m-d H:i:s.u"), "2020-12-12 18:24:59.000")
})
gtest.C(t, func(t *gtest.T) {
timeTemp := gtime.NewFromStr("2020-12-12 18:24:06")
timeTemp1 := timeTemp.EndOfMinute(true)
t.Assert(timeTemp1.Format("Y-m-d H:i:s.u"), "2020-12-12 18:24:59.999")
t.Assert(timeTemp1.Layout("Y-m-d H:i:s.u"), "2020-12-12 18:24:59.999")
})
}
@ -373,7 +373,7 @@ func Test_StartOfHour(t *testing.T) {
gtest.C(t, func(t *gtest.T) {
timeTemp := gtime.NewFromStr("2020-12-12 18:24:06")
timeTemp1 := timeTemp.StartOfHour()
t.Assert(timeTemp1.Format("Y-m-d H:i:s"), "2020-12-12 18:00:00")
t.Assert(timeTemp1.Layout("Y-m-d H:i:s"), "2020-12-12 18:00:00")
})
}
@ -381,12 +381,12 @@ func Test_EndOfHour(t *testing.T) {
gtest.C(t, func(t *gtest.T) {
timeTemp := gtime.NewFromStr("2020-12-12 18:24:06")
timeTemp1 := timeTemp.EndOfHour()
t.Assert(timeTemp1.Format("Y-m-d H:i:s.u"), "2020-12-12 18:59:59.000")
t.Assert(timeTemp1.Layout("Y-m-d H:i:s.u"), "2020-12-12 18:59:59.000")
})
gtest.C(t, func(t *gtest.T) {
timeTemp := gtime.NewFromStr("2020-12-12 18:24:06")
timeTemp1 := timeTemp.EndOfHour(true)
t.Assert(timeTemp1.Format("Y-m-d H:i:s.u"), "2020-12-12 18:59:59.999")
t.Assert(timeTemp1.Layout("Y-m-d H:i:s.u"), "2020-12-12 18:59:59.999")
})
}
@ -394,7 +394,7 @@ func Test_StartOfDay(t *testing.T) {
gtest.C(t, func(t *gtest.T) {
timeTemp := gtime.NewFromStr("2020-12-12 18:24:06")
timeTemp1 := timeTemp.StartOfDay()
t.Assert(timeTemp1.Format("Y-m-d H:i:s"), "2020-12-12 00:00:00")
t.Assert(timeTemp1.Layout("Y-m-d H:i:s"), "2020-12-12 00:00:00")
})
}
@ -402,12 +402,12 @@ func Test_EndOfDay(t *testing.T) {
gtest.C(t, func(t *gtest.T) {
timeTemp := gtime.NewFromStr("2020-12-12 18:24:06")
timeTemp1 := timeTemp.EndOfDay()
t.Assert(timeTemp1.Format("Y-m-d H:i:s.u"), "2020-12-12 23:59:59.000")
t.Assert(timeTemp1.Layout("Y-m-d H:i:s.u"), "2020-12-12 23:59:59.000")
})
gtest.C(t, func(t *gtest.T) {
timeTemp := gtime.NewFromStr("2020-12-12 18:24:06")
timeTemp1 := timeTemp.EndOfDay(true)
t.Assert(timeTemp1.Format("Y-m-d H:i:s.u"), "2020-12-12 23:59:59.999")
t.Assert(timeTemp1.Layout("Y-m-d H:i:s.u"), "2020-12-12 23:59:59.999")
})
}
@ -415,7 +415,7 @@ func Test_StartOfWeek(t *testing.T) {
gtest.C(t, func(t *gtest.T) {
timeTemp := gtime.NewFromStr("2020-12-12 18:24:06")
timeTemp1 := timeTemp.StartOfWeek()
t.Assert(timeTemp1.Format("Y-m-d H:i:s"), "2020-12-06 00:00:00")
t.Assert(timeTemp1.Layout("Y-m-d H:i:s"), "2020-12-06 00:00:00")
})
}
@ -423,12 +423,12 @@ func Test_EndOfWeek(t *testing.T) {
gtest.C(t, func(t *gtest.T) {
timeTemp := gtime.NewFromStr("2020-12-12 18:24:06")
timeTemp1 := timeTemp.EndOfWeek()
t.Assert(timeTemp1.Format("Y-m-d H:i:s.u"), "2020-12-12 23:59:59.000")
t.Assert(timeTemp1.Layout("Y-m-d H:i:s.u"), "2020-12-12 23:59:59.000")
})
gtest.C(t, func(t *gtest.T) {
timeTemp := gtime.NewFromStr("2020-12-12 18:24:06")
timeTemp1 := timeTemp.EndOfWeek(true)
t.Assert(timeTemp1.Format("Y-m-d H:i:s.u"), "2020-12-12 23:59:59.999")
t.Assert(timeTemp1.Layout("Y-m-d H:i:s.u"), "2020-12-12 23:59:59.999")
})
}
@ -436,7 +436,7 @@ func Test_StartOfMonth(t *testing.T) {
gtest.C(t, func(t *gtest.T) {
timeTemp := gtime.NewFromStr("2020-12-12 18:24:06")
timeTemp1 := timeTemp.StartOfMonth()
t.Assert(timeTemp1.Format("Y-m-d H:i:s"), "2020-12-01 00:00:00")
t.Assert(timeTemp1.Layout("Y-m-d H:i:s"), "2020-12-01 00:00:00")
})
}
@ -444,12 +444,12 @@ func Test_EndOfMonth(t *testing.T) {
gtest.C(t, func(t *gtest.T) {
timeTemp := gtime.NewFromStr("2020-12-12 18:24:06")
timeTemp1 := timeTemp.EndOfMonth()
t.Assert(timeTemp1.Format("Y-m-d H:i:s.u"), "2020-12-31 23:59:59.000")
t.Assert(timeTemp1.Layout("Y-m-d H:i:s.u"), "2020-12-31 23:59:59.000")
})
gtest.C(t, func(t *gtest.T) {
timeTemp := gtime.NewFromStr("2020-12-12 18:24:06")
timeTemp1 := timeTemp.EndOfMonth(true)
t.Assert(timeTemp1.Format("Y-m-d H:i:s.u"), "2020-12-31 23:59:59.999")
t.Assert(timeTemp1.Layout("Y-m-d H:i:s.u"), "2020-12-31 23:59:59.999")
})
}
@ -457,7 +457,7 @@ func Test_StartOfQuarter(t *testing.T) {
gtest.C(t, func(t *gtest.T) {
timeTemp := gtime.NewFromStr("2020-12-06 18:24:06")
timeTemp1 := timeTemp.StartOfQuarter()
t.Assert(timeTemp1.Format("Y-m-d H:i:s"), "2020-10-01 00:00:00")
t.Assert(timeTemp1.Layout("Y-m-d H:i:s"), "2020-10-01 00:00:00")
})
}
@ -465,12 +465,12 @@ func Test_EndOfQuarter(t *testing.T) {
gtest.C(t, func(t *gtest.T) {
timeTemp := gtime.NewFromStr("2020-12-06 18:24:06")
timeTemp1 := timeTemp.EndOfQuarter()
t.Assert(timeTemp1.Format("Y-m-d H:i:s.u"), "2020-12-31 23:59:59.000")
t.Assert(timeTemp1.Layout("Y-m-d H:i:s.u"), "2020-12-31 23:59:59.000")
})
gtest.C(t, func(t *gtest.T) {
timeTemp := gtime.NewFromStr("2020-12-06 18:24:06")
timeTemp1 := timeTemp.EndOfQuarter(true)
t.Assert(timeTemp1.Format("Y-m-d H:i:s.u"), "2020-12-31 23:59:59.999")
t.Assert(timeTemp1.Layout("Y-m-d H:i:s.u"), "2020-12-31 23:59:59.999")
})
}
@ -478,7 +478,7 @@ func Test_StartOfHalf(t *testing.T) {
gtest.C(t, func(t *gtest.T) {
timeTemp := gtime.NewFromStr("2020-12-06 18:24:06")
timeTemp1 := timeTemp.StartOfHalf()
t.Assert(timeTemp1.Format("Y-m-d H:i:s"), "2020-07-01 00:00:00")
t.Assert(timeTemp1.Layout("Y-m-d H:i:s"), "2020-07-01 00:00:00")
})
}
@ -486,12 +486,12 @@ func Test_EndOfHalf(t *testing.T) {
gtest.C(t, func(t *gtest.T) {
timeTemp := gtime.NewFromStr("2020-12-06 18:24:06")
timeTemp1 := timeTemp.EndOfHalf()
t.Assert(timeTemp1.Format("Y-m-d H:i:s.u"), "2020-12-31 23:59:59.000")
t.Assert(timeTemp1.Layout("Y-m-d H:i:s.u"), "2020-12-31 23:59:59.000")
})
gtest.C(t, func(t *gtest.T) {
timeTemp := gtime.NewFromStr("2020-12-06 18:24:06")
timeTemp1 := timeTemp.EndOfHalf(true)
t.Assert(timeTemp1.Format("Y-m-d H:i:s.u"), "2020-12-31 23:59:59.999")
t.Assert(timeTemp1.Layout("Y-m-d H:i:s.u"), "2020-12-31 23:59:59.999")
})
}
@ -499,7 +499,7 @@ func Test_StartOfYear(t *testing.T) {
gtest.C(t, func(t *gtest.T) {
timeTemp := gtime.NewFromStr("2020-12-06 18:24:06")
timeTemp1 := timeTemp.StartOfYear()
t.Assert(timeTemp1.Format("Y-m-d H:i:s"), "2020-01-01 00:00:00")
t.Assert(timeTemp1.Layout("Y-m-d H:i:s"), "2020-01-01 00:00:00")
})
}
@ -507,12 +507,12 @@ func Test_EndOfYear(t *testing.T) {
gtest.C(t, func(t *gtest.T) {
timeTemp := gtime.NewFromStr("2020-12-06 18:24:06")
timeTemp1 := timeTemp.EndOfYear()
t.Assert(timeTemp1.Format("Y-m-d H:i:s.u"), "2020-12-31 23:59:59.000")
t.Assert(timeTemp1.Layout("Y-m-d H:i:s.u"), "2020-12-31 23:59:59.000")
})
gtest.C(t, func(t *gtest.T) {
timeTemp := gtime.NewFromStr("2020-12-06 18:24:06")
timeTemp1 := timeTemp.EndOfYear(true)
t.Assert(timeTemp1.Format("Y-m-d H:i:s.u"), "2020-12-31 23:59:59.999")
t.Assert(timeTemp1.Layout("Y-m-d H:i:s.u"), "2020-12-31 23:59:59.999")
})
}

2
os/gview/gview_buildin.go
View File

@ -169,7 +169,7 @@ func (view *View) buildInFuncDate(format interface{}, timestamp ...interface{})
if t == 0 {
t = gtime.Timestamp()
}
return gtime.NewFromTimeStamp(t).Format(gconv.String(format))
return gtime.NewFromTimeStamp(t).Layout(gconv.String(format))
}
// buildInFuncCompare implements build-in template function: compare

2
util/gvalid/internal/builtin/builtin_date_format.go
View File

@ -43,7 +43,7 @@ func (r RuleDateFormat) Run(in RunInput) error {
}
return nil
}
if _, err := gtime.StrToTimeFormat(in.Value.String(), in.RulePattern); err != nil {
if _, err := gtime.StrToTimeLayout(in.Value.String(), in.RulePattern); err != nil {
return errors.New(in.Message)
}
return nil

2
util/gvalid/internal/builtin/builtin_datetime.go
View File

@ -43,7 +43,7 @@ func (r RuleDatetime) Run(in RunInput) error {
}
return nil
}
if _, err := gtime.StrToTimeFormat(in.Value.String(), `Y-m-d H:i:s`); err != nil {
if _, err := gtime.StrToTimeLayout(in.Value.String(), `Y-m-d H:i:s`); err != nil {
return errors.New(in.Message)
}
return nil