Golang time包中的函数用法详解

 更新时间:2023年08月10日 09:42:06   作者:路多辛  
在日常开发过程中,会频繁遇到对时间进行操作的场景,使用 Golang 中的 time 包可以很方便地实现对时间的相关操作,接下来的几篇文章会详细讲解 time 包,本文讲解一下 time 包中的函数,需要的朋友可以参考下

func Now() Time

返回当前的系统时间。

package main
import (
	"fmt"
	"time"
)
func main() {
  now := time.Now()  
  fmt.Println(now.Unix())
}

func Parse(layout, value string) (Time, error)

将字符串解析为时间类型,并返回对应的 Time 对象。layout 参数是表示时间的格式,例如"2006-01-02 15:04:05"表示年、月、日、时、分、秒的格式。

package main
import (
	"fmt"
	"time"
)
func main() {
  layout := "2006-01-02 15:04:05"  
  str := "2023-07-19 12:34:56"  
  t, _ := time.Parse(layout, str)  
  fmt.Println(t)
}

func ParseDuration(s string) (Duration, error)

用于将字符串解析为 Duration 类型。

package main
import (
	"fmt"
	"time"
)
func main() {
	durationStr := "2h45m"
	duration, err := time.ParseDuration(durationStr)
	if err != nil {
		fmt.Println("解析持续时间错误:", err)
		return
	}
	fmt.Printf("解析后的持续时间为:%v\n", duration)
}

func ParseInLocation(layout, value string, loc *Location) (Time, error)

用于将字符串解析为 Time 类型,并在指定的时区中解析时间。

package main
import (
	"fmt"
	"time"
)
func main() {
	location := time.FixedZone("CustomZone", 2*60*60) // 创建一个偏移量为2小时的固定时区
	timeString := "2023-07-18 14:30:00"               // 要解析的字符串
	t, err := time.ParseInLocation("2006-01-02 15:04:05", timeString, location)
	if err != nil {
		fmt.Println("解析时间错误:", err)
		return
	}
	fmt.Printf("解析后的时间为:%v\n", t)
}

func Date(year int, month Month, day, hour, min, sec, nsec int, loc *Location) Time

根据给定的年、月、日、时、分、秒和纳秒创建一个 Time 对象,loc 参数表示时区。

package main
import (
	"fmt"
	"time"
)
func main() {
  t := time.Date(2023, 7, 19, 12, 34, 56, 0, time.UTC)  
  fmt.Println(t)
}

func Since(t Time) Duration

返回从当前时间到 t 之间的时间差,以纳秒为单位。

package main
import (
	"fmt"
	"time"
)
func main() {
  t := time.Date(2023, 7, 19, 12, 34, 56, 0, time.UTC)  
  duration := time.Since(t)  
  fmt.Println(duration)
}

func Until(t Time) Duration

返回从 t 到当前时间之间的时间差,以纳秒为单位。

package main
import (
	"fmt"
	"time"
)
func main() {
  t := time.Date(2023, 7, 19, 12, 34, 56, 0, time.UTC)  
  duration := time.Until(t)  
  fmt.Println(duration)
}

func After(d Duration) <-chan Time

用于创建一个通道,将在指定的时间间隔后向通道发送一个 time.Time 类型的值。

package main
import (
	"fmt"
	"time"
)
func main() {
	// 创建一个将在5秒后发送值的通道
	timer := time.After(5 * time.Second)
	// 等待通道发送值
	fmt.Println(<-timer)
}

func AfterFunc(d Duration, f func()) *Timer

用于创建一个定时器,并在指定的时间间隔后执行一个函数。

package main
import (
	"fmt"
	"time"
)
func main() {
	// 创建一个将在5秒后触发的定时器
	timer := time.AfterFunc(5*time.Second, func() {
		fmt.Println("路多辛的博客!")
	})
	// 停止定时器
	time.Sleep(10 * time.Second)
	timer.Stop()
	// 输出:路多辛的博客!
	fmt.Println("Program ended")
}

func Unix(sec int64, nsec int64) Time

用于将 Unix 时间戳转换为时间类型。

package main
import (
	"fmt"
	"time"
)
func main() {
	// 定义一个Unix时间戳
	unixTime := int64(1691587957)
	// 使用time.Unix函数将Unix时间戳转换为时间类型
	t := time.Unix(unixTime, 0)
	// 打印结果
	fmt.Println(t)
}

func UnixMilli(msec int64) Time

用于将毫秒时间戳转换为时间类型。

package main
import (
	"fmt"
	"time"
)
func main() {
	t := time.UnixMilli(1691587957000)
	// 打印结果
	fmt.Println(t)
}

func UnixMicro(usec int64) Time

用于将微秒时间戳转换为时间类型。

package main
import (
	"fmt"
	"time"
)
func main() {
	t := time.UnixMilli(1691587957000000)
	// 打印结果
	fmt.Println(t)
}

func Tick(d Duration) <-chan Time

用于创建一个定时器,该定时器每隔一定的时间间隔就会向通道发送当前的时间。

package main
import (
	"fmt"
	"time"
)
func main() {
	// 创建一个每隔1秒进行一次打印的定时器
	ticker := time.Tick(1 * time.Second)
	for {
		<-ticker // 等待定时器的发送
		fmt.Println("这是ticker的打印")
	}
}

func LoadLocation(name string) (*Location, error)

用于加载并返回一个特定的时区。

package main
import (
	"fmt"
	"time"
)
func main() {
	// 加载"Asia/Shanghai"时区
	location, err := time.LoadLocation("Asia/Shanghai")
	if err != nil {
		fmt.Println("无法加载时区:", err)
		return
	}
	// 使用该时区创建一个时间对象
	t := time.Now().In(location)
	fmt.Println("当前时间:", t)
}

func LoadLocationFromTZData(name string, data []byte) (*Location, error)

用于从 TZ 数据中加载并返回一个时区。

package main
import (
	"fmt"
	"time"
)
func main() {
	// 加载"Asia/Shanghai"时区
	location, err := time.LoadLocationFromTZData("Asia/Shanghai")
	if err != nil {
		fmt.Println("无法加载时区:", err)
		return
	}
	// 使用该时区创建一个时间对象
	t := time.Now().In(location)
	fmt.Println("当前时间:", t)
}

func FixedZone(name string, offset int) *Location

用于创建一个具有固定偏移量的时区。

package main
import (
	"fmt"
	"time"
)
func main() {
	// 创建一个偏移量为2小时的固定时区
	location := time.FixedZone("CustomZone", 2*60*60)
	// 使用该时区创建一个时间对象
	t := time.Now().In(location)
	fmt.Println("当前时间:", t)
}

func NewTicker(d Duration) *Ticker

用于创建一个新的 Ticker 对象,该对象可以在指定的时间间隔重复发送 Time 值。

package main
import (
	"fmt"
	"time"
)
func main() {
	// 创建一个每秒发送一次的 Ticker 对象
	ticker := time.NewTicker(1 * time.Second)
	defer ticker.Stop()
	for {
		select {
		case <-ticker.C:
			fmt.Println("打印一次路多辛的博客")
		}
	}
}

func NewTimer(d Duration) *Timer

用于创建一个新的 Timer 对象,该对象可以在指定的时间间隔后发送一个 Time 类型的值。

package main
import (
	"fmt"
	"time"
)
func main() {
	// 创建一个定时器,在2秒后发送一个时间值
	timer := time.NewTimer(2 * time.Second)
	defer timer.Stop()
	// 使用定时器发送的时间值处理函数
	timerHandler := func() {
		fmt.Println("收到时间值")
	}
	// 在定时器发送时间值之前执行处理函数
	go timerHandler()
	// 等待定时器发送时间值
	select {
	case <-timer.C:
		fmt.Println("定时器已发送时间值")
	}
}

func Sleep(d Duration)

让当前的 goroutine 休眠指定的时间。

package main
import (
	"fmt"
	"time"
)
func main() {
	fmt.Println("开始休眠")
	time.Sleep(2 * time.Second)
	fmt.Println("休眠结束")
}

以上就是Golang time包中的函数详解的详细内容,更多关于Golang time包函数的资料请关注脚本之家其它相关文章!

相关文章

  • GoLang五种字符串拼接方式小结

    GoLang五种字符串拼接方式小结

    本文主要介绍了GoLang五种字符串拼接方式详解,包括+操作符、fmt.Sprintf、strings.Builder、bytes.Buffer和strings.Join,具有一定的参考价值,感兴趣的可以了解一下
    2025-12-12
  • golang 解析word文档操作

    golang 解析word文档操作

    这篇文章主要介绍了golang 解析word文档操作,具有很好的参考价值,希望对大家有所帮助。一起跟随小编过来看看吧
    2020-12-12
  • Go实现SMTP邮件发送订阅功能(包含163邮箱、163企业邮箱、谷歌gmail邮箱)

    Go实现SMTP邮件发送订阅功能(包含163邮箱、163企业邮箱、谷歌gmail邮箱)

    这篇文章给大家介绍了Go实现SMTP邮件发送订阅功能(包含163邮箱、163企业邮箱、谷歌gmail邮箱),需求很简单,就是用户输入自己的邮箱后,使用官方邮箱给用户发送替邮件模版,文中有详细的代码示例供大家参考,需要的朋友可以参考下
    2023-10-10
  • Golang数组的传递详解

    Golang数组的传递详解

    今天小编就为大家分享一篇关于Golang数组的传递详解,小编觉得内容挺不错的,现在分享给大家,具有很好的参考价值,需要的朋友一起跟随小编来看看吧
    2019-03-03
  • Go语言实现LRU算法的核心思想和实现过程

    Go语言实现LRU算法的核心思想和实现过程

    这篇文章主要介绍了Go语言实现LRU算法的核心思想和实现过程,LRU算法是一种常用的缓存淘汰策略,它的核心思想是如果一个数据在最近一段时间内没有被访问到,那么在将来它被访问的可能性也很小,因此可以将其淘汰,感兴趣想要详细了解可以参考下文
    2023-05-05
  • Go语言新宠:pdqsort排序算法的完美打造

    Go语言新宠:pdqsort排序算法的完美打造

    pdqsort是一种新的排序算法,特别适用于Go语言,它是由Go语言团队开发的,旨在提供高效且稳定的排序算法,pdqsort采用了一种分治的策略,将数组分成小块进行排序,然后再合并这些块,需要的朋友可以参考下
    2023-10-10
  • 使用Go语言实现微信公众平台

    使用Go语言实现微信公众平台

    这篇文章主要介绍了使用Go语言实现微信公众平台,虽然不是全部代码,但是也是给我们提供了一个非常好的思路,需要的朋友可以参考下
    2015-01-01
  • Go语言文件读写操作案例详解

    Go语言文件读写操作案例详解

    这篇文章主要为大家介绍了Go语言文件读写操作案例详解,有需要的朋友可以借鉴参考下,希望能够有所帮助,祝大家多多进步,早日升职加薪
    2022-09-09
  • Golang 标准库 tips之waitgroup详解

    Golang 标准库 tips之waitgroup详解

    本篇文章给大家介绍Golang 标准库 tips之waitgroup的相关知识,包括使用 channel 实现 WaitGroup 的功能介绍,感兴趣的朋友跟随小编一起看看吧
    2021-07-07
  • pytorch中的transforms.ToTensor和transforms.Normalize的实现

    pytorch中的transforms.ToTensor和transforms.Normalize的实现

    本文主要介绍了pytorch中的transforms.ToTensor和transforms.Normalize的实现,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友们下面随着小编来一起学习学习吧
    2022-04-04

最新评论