原文我的部落格地址： 九卷
golang使用的版本：
go version go1.10.3
複製程式碼一：功能介紹
time的一些功能，比如時區，像linux中的定時器，時間計算等
- 格式化時間
- 時區(Location)
- 時間計算
- Ticker
- Timer(定時器)
Time一般分為時間Time 和 時段Duration
二：Time 結構體
time結構體定義：
type Time struct {
wall unit64 //表示距離公元1年1月1日00:00:00UTC的秒數
ext int64 //表示納秒
loc *Location //代表時區，主要處理偏移量。因為不同的時區，對應的時間不一樣
}
複製程式碼上面的loc表示時區， 那什麼是時區呢？ 因為地球是圓的，所以同一個時刻，在地球的一邊是白天，一邊是黑夜。而因為人類使用一天 24 小時的制度，所以，在地球對角的兩邊就應該差了 12 的小時才對。由於同一個時間點上面， 整個地球的時間應該都不一樣，為了解決這個問題，所以可以想見的，地球就被分成 24 個時區了， 因為繞地球一圈是 360 度角，這 360 度角共分為 24 個時區，當然一個時區就是 15 度角啦！ 又由於是以格林威治時間為標準時間(Greenwich Mean Time, GMT 時間)，加上地球自轉的關係，因此，在格林威治以東的區域時間是比較快的(+小時)， 而以西的地方當然就是較慢囉！
UTC又是什麼 ？ 在計算時間的時候，最準確的計算應該是使用‘原子震盪週期’所計算的物理時鐘了 (Atomic Clock, 也被稱為原子鐘)，這也被定義為標準時間 (International Atomic Time)。而我們常常看見的 UTC 也就是 Coordinated Universal Time (協和標準時間)就是利用這種 Atomic Clock 為基準所定義出來的正確時間。例如 1999 年在美國啟用的原子鐘 NIST F-1， 他所產生的時間誤差每兩千年才差一秒鐘！真的是很準吶！這個 UTC 標準時間是以 GMT 這個時區為主的喔！所以本地時間與 UTC 時間的時差就是本地時間與 GMT 時間的時差就是了！
UTC + 時區差 ＝ 本地時間, 國內一般使用的是北京時間，與UTC的時間關係如下： UTC + 8個小時 = 北京時間
更多關於時間的內容請檢視鳥哥的私房菜
初始化Time (struct)
下面的這些函式都是返回結構體Time，相當於把不同型別的日期格式初始化為結構體Time
- 當前時間
func Now() Time
複製程式碼例子1：
fmt.Println(time.Now())
//output: 2019-04-25 23:15:12.2473056 +0800 CST m=+0.042979701
fmt.Println(time.Now().Year(), time.Now().Month())
//output: 2019 April
複製程式碼從上面可以看出，Now()返回的是一個+0800 CST 的時間
- Parse 將字串轉換為Time型別
func Parse(layout, value string, defaultLocation, local *Location) (Time, error)
複製程式碼layout 定義輸入的時間格式，value 的時間格式需與 layout 保持一致
例子1：
fmt.Println(time.Parse("2006-01-02 15:04:05", "2018-04-23 00:00:23"))
//output: 2018-04-23 00:00:23 +0000 UTC <nil>
複製程式碼從上面示例可以看出，Parse()預設返回的是+0000 UTC 時間
- ParseInLocation 功能與 Parse 類似，但有兩個重要的不同之處：
- 第一，當缺少時區資訊時，Parse 將時間解釋為 UTC 時間，而 ParseInLocation 將返回值的 Location 設定為 loc；
- 第二，當時間字串提供了時區偏移量資訊時，Parse 會嘗試去匹配本地時區，而 ParseInLocation 會去匹配 loc。
func ParseInLocation(layout, value string, loc *Location) (Time, error)
複製程式碼例子1：
fmt.Println(time.ParseInLocation("2006-01-02 15:04:05", "2017-05-11 14:06:06", time.Local))
//output: 2017-05-11 14:06:06 +0800 CST <nil>
複製程式碼- Unix
根據秒和納秒返回一個時間
func Unix(sec int64, nsec int64) Time
複製程式碼例子1：
fmt.Println(time.Unix(1e9, 0))
//output:2001-09-09 09:46:40 +0800 CST
複製程式碼- Date
func Date(year int, month Month, day, hour, min, sec, nsec int, loc *Location) Time
複製程式碼例子1：
fmt.Println(time.Date(2018, 1, 2, 15, 30, 10, 0, time.Local))
//output: 2018-01-02 15:30:10 +0800 CST
複製程式碼- Local
返回本地時間
func (t Time) Local() Time
複製程式碼例子1：
fmt.Println(time.Now())
fmt.Println(time.Now().Local())
//output: 2019-03-26 00:51:19.5597562 +0800 CST m=+0.006832001
//output: 2019-03-26 00:51:19.5987973 +0800 CST
複製程式碼其他的返回Time的方法，請到 godoc 檢視time方法列表
三：時間的格式化
- Format
把時間(string)轉化為string格式
func (t Time) Format(layout string) string
複製程式碼例子1：
fmt.Println(time.Now().Format("2006-01-02 15:04:05"))
fmt.Println(time.Now().Format("2006/01/02"))
//2019-03-26 01:20:55
//2019/03/26
const TimeFormat = "15:04:05"
fmt.Println(time.Now().Format(TimeFormat))
//02:05:52
const MicroFormat = "2006/01/02 15:04:05.000000"
fmt.Println(time.Now().Format(MicroFormat))
//2019/03/26 02:07:45.051045
複製程式碼- 返回Unix時間戳
func (t Time) Unix() int64
複製程式碼例子1：返回現在時間的時間戳
fmt.Println(time.Now().Unix())
// 1553580240
複製程式碼例子2：返回指定格式日期的時間戳
t, _ := time.Parse("2006-01-02 15:04:05", "2018-03-23 00:00:23")
fmt.Println(t.Unix())
//1524441623
複製程式碼- 時間戳轉日期
Unix(sec int64, nsec int64) Time
複製程式碼把時間time轉化為日期date
例子1：
fmt.Println(time.Unix(time.Now().Unix(), 0))
//2019-03-26 02:03:45 +0800 CST
複製程式碼- 返回年月日星期
返回Time結構體後，就可以呼叫Time的一些方法得到年月日
例子1：
t := time.Now()
fmt.Println(t.Year())
fmt.Println(t.Month())
fmt.Println(t.Day())
fmt.Pritnln(t.Weekday())
複製程式碼- 年月日返回日期
用Date() 函式實現
例子1：
t := time.Date(2012, 2, 20, 23, 59, 59, 0, time.UTC)
fmt.Println(t)
//2012-02-20 23:59:59 +0000 UTC
t = time.Date(2012, 2, 20, 23, 59, 59, 0, time.Local)
fmt.Println(t)
//2012-02-20 23:59:59 +0800 CST
複製程式碼Date()函式後面還可以加一個時區引數，得到相關時區的日期
四：時區
- 設定時區的函式
LoadLocation(name string) (*Location, error)
複製程式碼例子1：
loc, _ := time.LoadLocation("Asia/Shanghai") //設定時區
t, _ := time.ParseInLocation("2006-01-02 15:04:05", "2012-02-20 15:07:51", loc)
fmt.Println(t)
fmt.Println(t.Unix()) //獲取時間戳
//2012-02-20 15:07:51 +0800 CST
//1329721671
複製程式碼例子2：
loc, _ := time.LoadLocation("Asia/Shanghai") //設定時區
t := time.Unix(1329721671, 0)
fmt.Println(t.In(loc).Format("2006-01-02 15:04:05"))
//2012-02-20 15:07:51
複製程式碼- LoadLocation函式的一些常用引數：
loc, err := time.LoadLocation("") //預設UTC時間
loc, err := time.LoadLocation("local") //伺服器設定本地時區，一般為CST
loc, err := time.LoadLocation("Asia/Shanghai") //設定指定時區，指定為亞洲上海時區
複製程式碼五：時間段
- 1、Duration 定義
type Duration int64
複製程式碼定義了以下持續時間型別.多用於時間的加減需要傳入Duration做為引數的時候
const (
Nanosecond Duration = 1
Microsecond = 1000 * Nanosecond
Millisecond = 1000 * Microsecond
Second = 1000 * Millisecond
Minute = 60 * Second
Hour = 60 * Minute
)
複製程式碼例子1：
這個我們寫一個完整的例子
package main
import (
"fmt"
"reflect"
"time"
)
func main() {
fmt.Println(reflect.TypeOf(1))
fmt.Println(reflect.TypeOf(1 * time.Second))
}
//int
//time.Duration
複製程式碼- 2、將duration字串轉化為Duration型別
func ParseDuration(s string) (Duration, error)
複製程式碼例子2：
td, _ := time.ParseDuration("2h20m")
fmt.Println(td)
fmt.Println("min:", td.Minutes(), "second:", td.Seconds())
//min: 140 second: 8400
複製程式碼六：時間計算
相加
- 1、根據時間段Duration相加
func (t Time) Add(d Duration) Time
複製程式碼例子1：
t := time.Date(2012, 2, 20, 23, 59, 59, 0, time.Local)
fmt.Println(t)
t = t.Add(60 * time.Second) //加60秒
fmt.Println(t)
t = t.Add(1 * time.Hour) //加1小時
fmt.Println(t)
//output:
//2012-02-20 23:59:59 +0800 CST
//2012-02-21 00:00:59 +0800 CST
//2012-02-21 00:59:59 +0800 CST
複製程式碼- 2、根據年，月，日來相加
func (t Time) AddDate(years int, months int, days int) Time
複製程式碼例子2：
t = time.Date(2019, 3, 25, 23, 59, 59, 0, time.Local)
t2 := t.AddDate(0, 0, 1) //增加 1日
fmt.Println(t2)
t2 = t.AddDate(2, 0, 0) //增加 2年
fmt.Println(t2)
//output:
//2019-03-26 23:59:59 +0800 CST
//2021-03-25 23:59:59 +0800 CST
複製程式碼相減
- 1、計算2個時間的時差 (引數 t-u)
func (t Time) Sub(u Time) Duration
複製程式碼- 2、返回與當前時間的時間差 (Now - t)
func Since(t Time) Duration:
複製程式碼例子1：
t := time.Date(2019, 4, 25, 23, 59, 59, 0, time.Local)
fmt.Println(t)
sub := t.Sub(time.Now()) // t - time.Now()
fmt.Println(sub)
sub = time.Since(t) //time.Now() - t, 相當於time.Now().Sub(t)
fmt.Println(sub)
複製程式碼- 3、與當前時間相減 (t - Now)
func Until(t Time) Duration
複製程式碼函式原型
// Until returns the duration until t.
// It is shorthand for t.Sub(time.Now()).
func Until(t Time) Duration {
return t.Sub(Now())
}
複製程式碼例子1：
t := time.Date(2019, 3, 25, 23, 59, 59, 0, time.Local)
fmt.Println(t)
t3 := time.Until(t)
fmt.Println(t3) //相當於 t - Now() 相當於 t.Sub(time.Now())
複製程式碼比較
- 時間t是否在u之前
func (t Time) Before(u Time) bool
複製程式碼- 時間t是否在u之後
func (t Time) After(u Time) bool
複製程式碼- 2時間是否相等
func (t Time) Equal(u Time) bool
複製程式碼例子1：
t := time.Date(2012, 2, 20, 23, 59, 59, 0, time.Local)
now := time.Now()
ok := t.Before(now)
fmt.Println(ok)
ok = t.After(now)
fmt.Println(ok)
ok = t.Equal(now)
fmt.Println(ok)
//true
//false
//false
複製程式碼七：Ticker
Ticker: 按照指定的週期來呼叫函式或計算表示式
- Ticker結構
type Ticker struct {
C <-chan Time // The channel on which the ticks are delivered.
r runtimeTimer
}
複製程式碼- 建立一個Ticker
func NewTicker(d Duration) *Ticker
複製程式碼例子1：
可以取消定時
package main
import (
"fmt"
"time"
)
func main() {
//NewTicker 函式可以取消定時
ticker := time.NewTicker(time.Millisecond * 500)
go func() {
for t := range ticker.C {
fmt.Println("Tick at", t)
}
}()
time.Sleep(time.Millisecond * 1500) //阻塞
ticker.Stop() //停止ticker
fmt.Println("Ticker stopped")
}
//Tick at 2019-03-26 18:53:34.3215978 +0800 CST m=+0.506824001
//Tick at 2019-03-26 18:53:34.8226754 +0800 CST m=+1.007901601
//Ticker stopped
複製程式碼例子2：不能取消定時的Tick，所以我們一般用上面的NewTicker
package main
import (
"fmt"
"time"
)
func main() {
tick := time.Tick(2 * time.Second)
for v := range tick {
fmt.Println("Tick val:", v)
}
}
//Tick val: 2019-03-26 18:04:10.3579389 +0800 CST m=+2.007946901
//Tick val: 2019-03-26 18:04:12.3586132 +0800 CST m=+4.008621301
//Tick val: 2019-03-26 18:04:14.3570512 +0800 CST m=+6.007059201
//Tick val: 2019-03-26 18:04:16.3580495 +0800 CST m=+8.008057601
複製程式碼八：定時器Timer
Timer: Timer型別用來代表一個獨立的事件，當設定的時間過期後，傳送當前時間到channel
使用Timer定時器，超時後需要重置，才能繼續觸發
- Timer結構：
type Timer struct {
C <-chan Time
r runtimeTimer
}
複製程式碼- 建立新的定時器
func NewTimer(d Duration) *Timer
複製程式碼- 停止定時器
func (t *Timer) Stop() bool
複製程式碼- 重置定時器，以 d 為觸發時間
func (t *Timer) Reset(d Duration) bool
複製程式碼例子1：
package main
import (
"fmt"
"time"
)
func main() {
timer1 := time.NewTimer(2 * time.Second)
<-timer1.C
fmt.Println("Timer 1 expired")
timer2 := time.NewTimer(time.Second)
go func() {
<-timer2.C
fmt.Println("Timer 2 expired")
}()
stop2 := timer2.Stop()
if stop2 {
fmt.Println("Timer 2 stopped")
}
}
複製程式碼- 過多長時間執行func函式
func AfterFunc(d Duration, f func()) *Timer
複製程式碼例子1：
package main
import (
"fmt"
"time"
)
func main() {
t := time.Second * 5
timer := time.AfterFunc(t, func() {
fmt.Printf("you %d second timer finished", t)
})
defer timer.Stop()
time.Sleep(time.Second * 6)
}
複製程式碼- After() 在經過時長 d 之後，向返回的只讀通道傳送當前時間
func After(d Duration) <-chan Time
複製程式碼例子1：
package main
import (
"fmt"
"time"
)
func main() {
done := make(chan struct{}) //採用協程等待結束
go func(ch <-chan time.Time) {
fmt.Printf("Now is %s\n", <-ch)
done <- struct{}{} // 通知主執行緒協程退出
}(time.After(time.Second * 3)) //呼叫After，將返回的只讀通道傳遞給協程函式
<-done
close(done)
}
複製程式碼