golang时间处理扩展插件库timeutil的使用
Golang时间处理扩展插件库timeutil的使用
timeutil是一个对Golang标准库time包的有用扩展,提供了Timedelta、Strftime等功能。
快速开始
安装timeutil:
go get github.com/leekchan/timeutil
Timedelta
Timedelta表示两个日期之间的持续时间(受Python的timedelta启发)。
Timedelta结构体
type Timedelta struct {
Days, Seconds, Microseconds, Milliseconds, Minutes, Hours, Weeks time.Duration
}
初始化
所有字段都是可选的,默认为0。可以通过指定要使用的字段值来初始化任何类型的timedelta。
示例:
td := timeutil.Timedelta{Days: 10}
td = timeutil.Timedelta{Minutes: 17}
td = timeutil.Timedelta{Seconds: 56}
td = timeutil.Timedelta{Days: 10, Minutes: 17, Seconds: 56}
td = timeutil.Timedelta{Days: 1, Seconds: 1, Microseconds: 1, Milliseconds: 1, Minutes: 1, Hours: 1, Weeks: 1}
基本用法
package main
import (
"fmt"
"time"
"github.com/leekchan/timeutil"
)
func main() {
// 基本用法
base := time.Date(2015, 2, 3, 0, 0, 0, 0, time.UTC)
td := timeutil.Timedelta{Days: 10, Minutes: 17, Seconds: 56}
result := base.Add(td.Duration())
fmt.Println(result) // 输出: "2015-02-13 00:17:56 +0000 UTC"
}
操作
加法
base := time.Date(2015, 2, 3, 0, 0, 0, 0, time.UTC)
td := timeutil.Timedelta{Days: 1, Minutes: 1, Seconds: 1}
td2 := timeutil.Timedelta{Days: 2, Minutes: 2, Seconds: 2}
td = td.Add(&td2) // td = td + td2
result := base.Add(td.Duration())
fmt.Println(result) // 输出: "2015-02-06 00:03:03 +0000 UTC"
减法
base := time.Date(2015, 2, 3, 0, 0, 0, 0, time.UTC)
td := timeutil.Timedelta{Days: 2, Minutes: 2, Seconds: 2}
td2 := timeutil.Timedelta{Days: 1, Minutes: 1, Seconds: 1}
td = td.Subtract(&td2) // td = td - td2
result := base.Add(td.Duration())
fmt.Println(result) // 输出: "2015-02-04 00:01:01 +0000 UTC"
绝对值
base := time.Date(2015, 2, 3, 0, 0, 0, 0, time.UTC)
td := timeutil.Timedelta{Days: 1, Minutes: 1, Seconds: 1}
td2 := timeutil.Timedelta{Days: 2, Minutes: 2, Seconds: 2}
td = td.Subtract(&td2) // td = td - td2
td = td.Abs() // td = |td|
result := base.Add(td.Duration())
fmt.Println(result) // 输出: "2015-02-04 00:01:01 +0000 UTC"
Strftime
Strftime根据给定的格式字符串格式化time.Date。指令以百分号(%)字符开头。
(Strftime支持unicode格式字符串。)
格式化指令
指令 | 含义 | 示例 |
---|---|---|
%a | 星期几的缩写 | Sun, Mon, …, Sat |
%A | 星期几的全称 | Sunday, Monday, …, Saturday |
%w | 星期几的数字表示(0-6, 0是周日) | 0, 1, …, 6 |
%d | 月份中的第几天(补零) | 01, 02, …, 31 |
%b | 月份的缩写 | Jan, Feb, …, Dec |
%B | 月份的全称 | January, February, …, December |
%m | 月份的数字表示(补零) | 01, 02, …, 12 |
%y | 不带世纪的年份(补零) | 00, 01, …, 99 |
%Y | 带世纪的年份 | 1970, 1988, 2001, 2013 |
%H | 24小时制的小时(补零) | 00, 01, …, 23 |
%I | 12小时制的小时(补零) | 01, 02, …, 12 |
%p | 上午/下午标识 | AM, PM |
%M | 分钟(补零) | 00, 01, …, 59 |
%S | 秒(补零) | 00, 01, …, 59 |
%f | 微秒(补零) | 000000, 000001, …, 999999 |
%z | UTC偏移量(+HHMM或-HHMM) | +0000 |
%Z | 时区名称 | UTC |
%j | 一年中的第几天(补零) | 001, 002, …, 366 |
%U | 一年中的周数(周日为一周的第一天) | 00, 01, …, 53 |
%W | 一年中的周数(周一为一周的第一天) | 00, 01, …, 53 |
%c | 日期和时间表示 | Tue Aug 16 21:30:00 1988 |
%x | 日期表示 | 08/16/88 |
%X | 时间表示 | 21:30:00 |
%% | 百分号字符 | % |
示例
date := time.Date(2015, 7, 2, 15, 24, 30, 35, time.UTC)
str := timeutil.Strftime(&date, "%a %b %d %I:%M:%S %p %Y")
fmt.Println(str) // 输出: "Thu Jul 02 03:24:30 PM 2015"
// Unicode支持
str = timeutil.Strftime(&date, "작성일 : %a %b %d %I:%M:%S %p %Y")
fmt.Println(str) // 输出: "작성일 : Thu Jul 02 03:24:30 PM 2015"
待办功能
- 本地化支持
- Strptime - 根据格式字符串解析返回time.Date的函数
- 自动日期解析器 - 能够解析大多数已知日期表示格式的通用字符串解析器
- 其他有用功能…
更多关于golang时间处理扩展插件库timeutil的使用的实战教程也可以访问 https://www.itying.com/category-94-b0.html
1 回复
更多关于golang时间处理扩展插件库timeutil的使用的实战系列教程也可以访问 https://www.itying.com/category-94-b0.html
Golang 时间处理扩展库 timeutil 使用指南
timeutil 是一个常用的 Golang 时间处理扩展库,提供了许多标准库 time 包没有的实用功能。下面我将介绍其主要功能和使用方法。
安装
go get github.com/ikeikeikeike/go-timeutil
主要功能及示例
1. 时间解析增强
import (
"fmt"
"github.com/ikeikeikeike/go-timeutil"
)
func main() {
// 自动解析多种时间格式
t, _ := timeutil.Parse("2023-01-15")
fmt.Println(t) // 2023-01-15 00:00:00 +0000 UTC
t, _ = timeutil.Parse("15/01/2023")
fmt.Println(t) // 2023-01-15 00:00:00 +0000 UTC
}
2. 时间区间计算
// 计算两个时间之间的天数
days := timeutil.BetweenDays(time.Now(), time.Now().Add(24*time.Hour))
fmt.Println(days) // 1
// 检查时间是否在区间内
isBetween := timeutil.Between(
time.Now(),
time.Now().Add(-1*time.Hour),
time.Now().Add(1*time.Hour),
)
fmt.Println(isBetween) // true
3. 时间操作增强
// 获取当天的开始和结束时间
start, end := timeutil.Today()
fmt.Println(start) // 当天00:00:00
fmt.Println(end) // 当天23:59:59.999999999
// 获取本周的开始和结束时间
weekStart, weekEnd := timeutil.ThisWeek()
fmt.Println(weekStart) // 本周第一天00:00:00
fmt.Println(weekEnd) // 本周最后一天23:59:59.999999999
// 获取本月的开始和结束时间
monthStart, monthEnd := timeutil.ThisMonth()
fmt.Println(monthStart) // 本月第一天00:00:00
fmt.Println(monthEnd) // 本月最后一天23:59:59.999999999
4. 时间格式化增强
// 人性化时间显示
fmt.Println(timeutil.Humanize(time.Now().Add(-5*time.Minute))) // 5 minutes ago
fmt.Println(timeutil.Humanize(time.Now().Add(-2*time.Hour))) // 2 hours ago
fmt.Println(timeutil.Humanize(time.Now().Add(-3*24*time.Hour))) // 3 days ago
// 自定义格式化
fmt.Println(timeutil.Format(time.Now(), "YYYY-MM-DD")) // 2023-01-15
fmt.Println(timeutil.Format(time.Now(), "HH:mm:ss")) // 14:30:45
5. 时区处理
// 转换时区
loc, _ := time.LoadLocation("Asia/Shanghai")
shanghaiTime := timeutil.In(time.Now(), loc)
fmt.Println(shanghaiTime)
// 获取所有可用时区
zones := timeutil.Zones()
for _, zone := range zones {
fmt.Println(zone)
}
6. 定时任务辅助
// 等待到下一个整点
timeutil.WaitNextHour()
// 等待到下一个指定分钟
timeutil.WaitNextMinute(30) // 等待到下一个30分
实际应用示例
计算工作日
func countWorkdays(start, end time.Time) int {
count := 0
for d := start; d.Before(end); d = d.AddDate(0, 0, 1) {
if d.Weekday() != time.Saturday && d.Weekday() != time.Sunday {
count++
}
}
return count
}
func main() {
start, _ := time.Parse("2006-01-02", "2023-01-01")
end, _ := time.Parse("2006-01-02", "2023-01-31")
fmt.Println(countWorkdays(start, end)) // 22 (假设没有节假日)
}
生成时间序列
func generateTimeSeries(start time.Time, interval time.Duration, count int) []time.Time {
var series []time.Time
for i := 0; i < count; i++ {
series = append(series, start.Add(time.Duration(i)*interval))
}
return series
}
func main() {
series := generateTimeSeries(time.Now(), time.Hour, 24)
for _, t := range series {
fmt.Println(t)
}
}
总结
timeutil 库为 Golang 的时间处理提供了许多便利功能,包括:
- 更灵活的时间解析
- 时间区间计算
- 常用时间范围获取
- 人性化时间显示
- 时区处理辅助
- 定时任务支持
虽然标准库的 time 包功能已经很强大了,但在实际开发中,timeutil 这样的扩展库可以显著减少样板代码,提高开发效率。