(摘) golang之Time

获取当前时间戳

seconds := time.Now().Unix()

获取当前年月日时分和星期几

//获取当前时间的Time结构体实例
t := time.Now()
​
//通过Date函数同时获取年月日
year, month, day := t.Date()
//假设日期为2021-1-7 打印结果为 year:2021, month:1, day:7
fmt.Printf("year:%d, month:%d, day:%d\n", year, month, day)
​
//通过Clock函数同时获取时分秒
hour, minute, second := t.Clock()
//假设时间是18:51:9 打印结果 hour:18,minute:51,second:9
fmt.Printf("hour:%d,minute:%d,second:%d\n", hour, minute, second)
​
//也可以单独获取年、月、日、时、分、秒、星期几
year := t.Year() //获取所属年份
month := t.Month() //获取所属月份，不带前导零
day := t.Day() //获取所属日，不带前导零
hour := t.Hour() //获取当前小时
minutes := t.Minute() //获取当前分钟
seconds := t.Seconds() //获取当前描述
nanosecond := t.Nanosecond() //获取当前纳秒数
weekday := t.Weekday()  //获取是星期几， t.Weekday返回的是Weekday类型

返回当前时间是一年中的第几天

yearday := time.Now().YearDay()

时间戳格式化成日期字符串

// 1、将时间戳转换成int64类型
timestamps := int64(1609945385) //该时间戳代表2021-01-06 23：03：05
​
//2、将int64类型时间戳转换成Time结构,time.Unix函数的第2个参数代表纳秒数
t := time.Unix(timestamps, 0)
​
//3、调用Time结构体的Format函数,这里我们定义一组格式
var formats = []string{
    "2006年01月02日 15时04分05秒",
    "2006-01-02 15:04:05",
    "2006/01/02 15:04:05",
    "06-01-02",
    "06年01月02日",
    "2006.01.02",
    "06/1/2",
}
​
for _, layout := range formats {
    result := t.Format(layout)
    fmt.Printf("日期格式:%s, 转换结果:%s \n", layout, result)
}

计算两个日期之间相差

t1str := "2021-01-07 15:57:23"
t2str := "2021-01-07 18:57:23"
layout := "2006-01-02 15:04:05" //时间字符串的格式
//1、将时间字符串转换成Time类型
location, _ := time.LoadLocation("Asia/Shanghai")
t1 := time.ParseInLocation(layout, t1str, location)
t2 := time.ParseInLocation(layout, t2str, location)
​
//2、计算两个Time结构实例之间的差
d := t2.Sub(t1)
​
//3、根据返回的Duration类型的d转换成相应的小时/分钟/秒数
hours := d.Hours() //转换成两个时刻相差的小时数
minutes := d.Minutes() //转换成两个时刻相差的分钟数
seconds := d.Seconds() //转换成两个时刻相差的秒数
milliseconds := d.Milliseconds() //转换成两个时刻相差的毫秒数
microseconds := d.Microseconds() //转换成两个时刻相差的微妙数
nanoseconds := d.Nanoseconds() //转换成两个时刻相差的纳秒数

获取从某个时间 至今 经过的时间

t1str := "2014-10-02 13:14:15"
layout := "2006-01-02 15:04:05" //时间字符串的格式
​//1、将时间字符串转换成Time类型
location, _ := time.LoadLocation("Asia/Shanghai")
t := time.ParseInLocation(layout, t1str, location)
​
//2、计算两个Time结构实例之间的差
d := time.Since(t)
​
//2、根据返回的d转换成响应的小时/分钟/秒数
hours := d.Hours() //转换成两个时刻相差的小时数
minutes := d.Minutes() //转换成两个时刻相差的分钟数
seconds := d.Seconds() //转换成两个时刻相差的秒数
milliseconds := d.Milliseconds() //转换成两个时刻相差的毫秒数
microseconds := d.Microseconds() //转换成两个时刻相差的微妙数
nanoseconds := d.Nanoseconds() //转换成两个时刻相差的纳秒数
fmt.Printf("从%s至今你们一起度过了共%d", t1str, d.Round(24*time.Hour))
fmt.Printf("从%s至今共一起度过了%f小时\n", t1str, time.Now().Format(layout), hours)

计算从今天到未来某个时间经过的时间

t1str := "2021-12-21 13:14:15"
layout := "2006-01-02 15:04:05" //时间字符串的格式
//第1步，将时间字符串转换成Time类型
location, _ := time.LoadLocation("Asia/Shanghai")
t := time.ParseInLocation(layout, t1str, location)
​
//第2步，计算两个Time结构实例之间的差
d := time.Until(t)
​
//第3步，根据返回的d转换成响应的小时/分钟/秒数
hours := d.Hours() //转换成两个时刻相差的小时数
fmt.Printf("距女朋友生日%s还有%f小时\n", t1str, hours)

时间之间的比较：是早、是晚、还是相等相关函数

pivot := "2021-12-12 13:14:15"
layout := "2006-01-02 15:04:05" //时间字符串的格式
//第1步，将时间字符串转换成Time类型
location, _ := time.LoadLocation("Asia/Shanghai")
pivotT := time.ParseInLocation(layout, t1str, location)
​
//第2步，获取现在的时间
t := time.Now()
​
//第3步，和约定时间比较下是否来早了
if t.Before(pivotT) {
    fmt.Println("来早了")
}
​
//和约定时间比较一下，看是否来晚了
if t.After(pivotT) {
    fmt.Println("oh，糟糕，来晚了")
}
​
//和约定时间比较一下，一看，刚刚好
if t.Equal(pivotT) {
    fmt.Println("还好，还好，刚刚好")
}

计算N天后的时间

d := 3 * 24 * time.Hour​
afterNDay := time.Now().Add(d)​
fmt.Println("3天后的日期是", afterNDay.Format("2006-01-02"))

定时器

使用time.Tick(时间间隔)来设置定时器，定时器的本质上是一个通道（channel）。

func tickDemo() {
    ticker := time.Tick(time.Second) //定义一个1秒间隔的定时器
    for i := range ticker {
        fmt.Println(i)//每秒都会执行的任务
    }
}

时间戳转时间

timeStamp := 1569826535
t := time.Unix(int64(timeStamp), 0)  // time.Time
strTime := t.Format("2006-01-02 15:04:05")
fmt.Println(strTime)  // 2019-09-30 14:55:35

时间字符串转时间

s := "2019年9月30日 15:10:30"  // ---> 2019-09-30 15:10:30
t, err := time.Parse("2006年1月2日 15:4:5", s)
if err != nil {
    fmt.Println(err.Error())
}
result := t.Format("2006-01-02 15:04:05")
fmt.Println(result)

时间加减法

timeStamp := 1569826535             // 2019-09-30 14:55:35
t := time.Unix(int64(timeStamp), 0) // time.Time
  
// 时间年月日加减，如果是负数，怎表示减去多少
t2 := t.AddDate(0, -1, 0)
fmt.Println(t2.Format("2006/01/02 15:04:05"))
  
// 第二种写法，同样的是负数表示减法
t3 := t.Add(-time.Hour * 24)
fmt.Println(t3.Format("2006/01/02 15:04:05"))

其它

10位数的时间戳是以 秒 为单位；
13位数的时间戳是以 毫秒 为单位；
19位数的时间戳是以 纳秒 为单位；

const (
	Nanosecond  Duration = 1
	Microsecond          = 1000 * Nanosecond
	Millisecond          = 1000 * Microsecond
	Second               = 1000 * Millisecond
	Minute               = 60 * Second
	Hour                 = 60 * Minute
)

//Nanosecond表示1纳秒的时间间隔
//Microsecond表示1微妙的时间间隔
//Millisecond表示1毫秒的时间间隔
//Second表示1秒的时间间隔
//Minute表示1分钟的时间间隔
//Hour表示1小时的时间间隔

定时器

延时

time.NewTimer时间到了,只响应一次

func main() {
   //time.NewTimer时间到了,只响应一次
   //创建一个定时器,设置时间为2s,2s后,往time通道写内容(当前时间)
   timer := time.NewTimer(2 * time.Second)
   fmt.Println("当前时间: ", time.Now())
 
   //2s后,往timer.c写数据,有数据后,就可以读取
   t := <-timer.C //channel没有数据前后阻塞
   fmt.Println("t = ", t)
}

time.After(2 * time.Second)延迟多少秒产生个事件

    func main() {
       //定时2秒,2秒后产生一个事件,往channel里面写内容
       <-time.After(2 * time.Second)
       fmt.Println("时间到")
    }

停止

func main() {
 
   timer := time.NewTimer(3 * time.Second)
 
   go func() {
      <-timer.C
      fmt.Println("子协程可以打印了,因为定时器的时间到了")
   }()
 
   //关闭定时器
   timer.Stop()
   for {
 
   }
}

重置

func main() {
   timer := time.NewTimer(3 * time.Second)
   //重置上面的那个无效
   flag := timer.Reset(1 * time.Second)
   fmt.Println(flag)  //true
   <-timer.C
   fmt.Println("时间到")
}

###Ticker 定时触发的计时器,它会以一个间隔(interval)往channel发送一个事件(当前时间),而channel的接收者可以以固定的时间间隔从channel中读取事件

func main() {
 
   ticker := time.NewTicker(1 * time.Second)
   i := 0
   for {
      <-ticker.C
 
      i++
      fmt.Println("i = ", i)
 
      if i ==5 {
        //停止ticker
         ticker.Stop()
         break
      }
   }
}