获取当前时间的年、月、日、时、分、秒的方法如下：
获取从1970到现在经过的时间的方法如下：
时间间隔格式化输出方法：
总结
获取当前时间的年、月、日、时、分、秒的方法如下：// 获取当前时间
now := time.Now()
// 当前时间的年、月、日、小时、分钟、秒和纳秒都可以通过现有接口直接获取
year := now.Year()
month := now.Month()
day := now.Day()
hour := now.Hour()
minute := now.Minute()
second := now.Second()
nanosecond := now.Nanosecond()
// 当前时间的微秒和毫秒是通过纳秒计算生成
microsecond := nanosecond / 1e3
millisecond := nanosecond / 1e6
fmt.Println(now.Format("2006-01-02 15:04:05.000000000"))
fmt.Println(year, month, day, hour, minute, second, nanosecond, microsecond, millisecond)
运行结果如下：
获取从1970到现在经过的时间的方法如下：# 当前时间格式输出
2022-06-09 19:25:52.022598620
2022 June 9 19 25 52 22598620 22598 22
// 获取从1970经过的时间，秒和纳秒都可以通过现有接口直接获取
sec := now.Unix() // 时间戳位数为10
ms := now.UnixMilli() // 时间戳位数为13
us := now.UnixMicro() // 时间戳位数为16
ns := now.UnixNano() // 时间戳位数为19
fmt.Printf("sec:%v\n ms:%v\n us:%v\n ns:%v\n", sec, ms, us, ns)
运行结果如下：
时间间隔格式化输出方法：# 1970经过的时间格式输出
sec:1654773952
ms:1654773952022
us:1654773952022598
ns:1654773952022598620
// 时间间隔返回的是time.Duration，下面以1h1m1s1ms1us1ns的时间间隔举例，测试各种格式的打印效果
duration := 1*time.Hour + 1*time.Minute + 1*time.Second +
1*time.Millisecond + 1*time.Microsecond + 1*time.Nanosecond
// 直接使用%v打印，不转换sec、ms或其他。
fmt.Printf("duration:%v\n", duration)
fmt.Printf("duration:%6v\n", duration)
fmt.Printf("duration:%.6v\n", duration)
fmt.Printf("duration:%.3v\n", duration)
// duration支持Hours()、 Minutes()、Seconds() 和
// Milliseconds()、Microseconds()、Nanoseconds()接口
// 前三个接口返回类型为float64可以通过0.3f打印小数点后的数，
// 后三个为int64，是整数，小数点后都是0
// 下面列举秒和毫秒的格式打印，其他时间单位可以参考秒和毫秒
// 秒的打印格式%f可以打印小数点后9位，精确到纳秒
fmt.Printf("duration:%vsec\n", duration.Seconds())
fmt.Printf("duration:%0.3fsec\n", duration.Seconds())
fmt.Printf("duration:%0.6fsec\n", duration.Seconds())
// 毫秒没有小数点，都是整数，转换成float后，小数点后都是0
fmt.Printf("duration:%vms\n", duration.Milliseconds())
fmt.Printf("duration:%.3dms\n", duration.Milliseconds())
fmt.Printf("duration:%.3fms\n", float64(duration.Milliseconds()))
}
行结果如下：
# 1h1m1s1ms1us1ns的时间间隔举例格式输出
# %v没有单位转换的时间输出
duration:1h1m1.001001001s
duration:1h1m1.001001001s
duration:1h1m1.
duration:1h1# 秒的格式输出
duration:3661.001001001sec
duration:3661.001sec
duration:3661.001001sec# 毫秒的格式输出
duration:3661001ms
duration:3661001ms
duration:3661001.000ms
通过测试程序可以看到：
1.没时间单位转换的格式输出，直接用%v能精确到ns，%.3V，只是对输出的字符串进行了切割。此处建议直接用%v即可。
2.对于秒的格式输出，%v精确到小数点9位，即纳秒。当然可以根据%f的格式调整，例如%.3f精确到毫秒
3.对于毫秒的格式输出，直接用%v或%d即可，转换成float64没有意义
一般在统计一个函数或一段程序运行了多长时间，一般建议使用第二种方式，转换成秒的格式输出，再根据精度调整%f的格式即可。
第一种方式有可能出现时间单位不统一，例如一个是分钟，一个是秒。
上面例子完成的代码如下：
package main
import (
"fmt"
"time"
)
func main() {
// 获取当前时间
now := time.Now()
// 当前时间的年、月、日、小时、分钟、秒和纳秒都可以通过现有接口直接获取
year := now.Year()
month := now.Month()
day := now.Day()
hour := now.Hour()
minute := now.Minute()
second := now.Second()
nanosecond := now.Nanosecond()
// 当前时间的微秒和毫秒是通过纳秒计算生成
microsecond := nanosecond / 1e3
millisecond := nanosecond / 1e6
fmt.Println(now.Format("2006-01-02 15:04:05.000000000"))
fmt.Println(year, month, day, hour, minute, second, nanosecond, microsecond, millisecond)
// 获取从1970经过的时间，秒和纳秒都可以通过现有接口直接获取
sec := now.Unix() // 时间戳位数为10
ms := now.UnixMilli() // 时间戳位数为13
us := now.UnixMicro() // 时间戳位数为16
ns := now.UnixNano() // 时间戳位数为19
fmt.Printf("sec:%v\n ms:%v\n us:%v\n ns:%v\n", sec, ms, us, ns)
// 时间间隔返回的是time.Duration，下面以1h1m1s1ms1us1ns的时间间隔举例，测试各种格式的打印效果
duration := 1*time.Hour + 1*time.Minute + 1*time.Second +
1*time.Millisecond + 1*time.Microsecond + 1*time.Nanosecond
// 直接使用%v打印，不转换sec、ms或其他。
fmt.Printf("duration:%v\n", duration)
fmt.Printf("duration:%6v\n", duration)
fmt.Printf("duration:%.6v\n", duration)
fmt.Printf("duration:%.3v\n", duration)
// duration支持Hours()、 Minutes()、Seconds() 和
// Milliseconds()、Microseconds()、Nanoseconds()接口
// 前三个接口返回类型为float64可以通过0.3f打印小数点后的数，
// 后三个为int64，是整数，小数点后都是0
// 下面列举秒和毫秒的格式打印，其他时间单位可以参考秒和毫秒
// 秒的打印格式%f可以打印小数点后9位，精确到纳秒
fmt.Printf("duration:%vsec\n", duration.Seconds())
fmt.Printf("duration:%0.3fsec\n", duration.Seconds())
fmt.Printf("duration:%0.6fsec\n", duration.Seconds())
// 毫秒没有小数点，都是整数，转换成float后，小数点后都是0
fmt.Printf("duration:%vms\n", duration.Milliseconds())
fmt.Printf("duration:%.3dms\n", duration.Milliseconds())
fmt.Printf("duration:%.3fms\n", float64(duration.Milliseconds()))
}
下面是时间间隔的时间单位转换的源码：
// time.go
// Nanoseconds returns the duration as an integer nanosecond count.
func (d Duration) Nanoseconds() int64 { return int64(d) }
// Microseconds returns the duration as an integer microsecond count.
func (d Duration) Microseconds() int64 { return int64(d) / 1e3 }
// Milliseconds returns the duration as an integer millisecond count.
func (d Duration) Milliseconds() int64 { return int64(d) / 1e6 }
// These methods return float64 because the dominant
// use case is for printing a floating point number like 1.5s, and
// a truncation to integer would make them not useful in those cases.
// Splitting the integer and fraction ourselves guarantees that
// converting the returned float64 to an integer rounds the same
// way that a pure integer conversion would have, even in cases
// where, say, float64(d.Nanoseconds())/1e9 would have rounded
// differently.
// Seconds returns the duration as a floating point number of seconds.
func (d Duration) Seconds() float64 {
sec := d / Second
nsec := d % Second
return float64(sec) + float64(nsec)/1e9
}
// Minutes returns the duration as a floating point number of minutes.
func (d Duration) Minutes() float64 {
min := d / Minute
nsec := d % Minute
return float64(min) + float64(nsec)/(60*1e9)
}
// Hours returns the duration as a floating point number of hours.
func (d Duration) Hours() float64 {
hour := d / Hour
nsec := d % Hour
return float64(hour) + float64(nsec)/(60*60*1e9)
}
补充：如果想格式化为12小时方式，需指定PM。
func formatDemo() {
now := time.Now()
// 格式化的模板为Go的出生时间2006年1月2号15点04分 Mon Jan
// 24小时制
fmt.Println(now.Format("2006-01-02 15:04:05.000 Mon Jan"))
// 12小时制
fmt.Println(now.Format("2006-01-02 03:04:05.000 PM Mon Jan"))
fmt.Println(now.Format("2006/01/02 15:04"))
fmt.Println(now.Format("15:04 2006/01/02"))
fmt.Println(now.Format("2006/01/02"))
}
总结
到此这篇关于golang中time包之时间间隔格式化和秒、毫秒、纳秒等时间戳格式输出的文章就介绍到这了,更多相关golang time包时间间隔格式化内容请搜索易知道(ezd.cc)以前的文章或继续浏览下面的相关文章希望大家以后多多支持易知道(ezd.cc)！
