go语言的时间包

发表于 | 分类于 | 浏览 次
go语言的时间模的块基本用法

time包

时间类型

time.Now()获取当前时间对象。然后可以根据时间对象获取对象的年月日。。。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
package main

import (
    "fmt"
    "time"
)

func main() {

    // 获取当前时间对象
    now := time.Now()
    fmt.Println(now)

    // 年
    fmt.Println(now.Year())
    // 月
    fmt.Println(now.Month())
    // 日
    fmt.Println(now.Day())
    // 小时
    fmt.Println(now.Hour())
    // 分
    fmt.Println(now.Minute())
    // 秒
    fmt.Println(now.Second())
}

执行结果：

1
2
3
4
5
6
7
2019-08-05 13:56:04.2639783 +0800 CST m=+0.003994001
2019
August
5
13
56
4

时间戳

时间对象转时间戳

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
package main

import (
    "fmt"
    "time"
)

func main() {
    now := time.Now()
    // 获取当前时间对应的时间戳
    timeStamp1 := now.Unix()
    fmt.Println(timeStamp1)
    // 获取当前时间对应的纳秒时间戳
    timeStamp2 := now.UnixNano()
    fmt.Println(timeStamp2)
}

执行结果：

1
2
1564984727
1564984727247498100

时间戳转时间对象

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
package main

import (
    "fmt"
    "time"
)

func main() {
    var tsp int64 = 1564984727
    timeObj := time.Unix(tsp, 0)
    fmt.Println(timeObj)

    // 年
    fmt.Println(timeObj.Year())
    // 月
    fmt.Println(timeObj.Month())
    // 日
    fmt.Println(timeObj.Day())
    // 小时
    fmt.Println(timeObj.Hour())
    // 分
    fmt.Println(timeObj.Minute())
    // 秒
    fmt.Println(timeObj.Second())
}

执行结果：

1
2
3
4
5
6
7
2019-08-05 13:58:47 +0800 CST
2019
August
5
13
58
47

时间间隔

time.Duration是time包定义的一个类型，它代表两个时间点之间经过的时间，以纳秒为单位常用来时间计算。

1
2
3
4
5
6
7
8
const (
    Nanosecond  Duration = 1
    Microsecond          = 1000 * Nanosecond
    Millisecond          = 1000 * Microsecond
    Second               = 1000 * Millisecond
    Minute               = 60 * Second
    Hour                 = 60 * Minute
)

例如：time.Second表示一秒，time.Hour表示一小时。

时间操作

Add

1
func (t Time) Add(d Duration) Time

时间相加：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
package main

import (
    "fmt"
    "time"
)

func main() {
    now := time.Now()
    // 现在的时间
    fmt.Println(now)
    // 10秒后的时间
    fmt.Println(now.Add(time.Second * 10))

    // 三十分钟后的时间
    fmt.Println(now.Add(time.Minute * 30))

    // 一天后的时间
    fmt.Println(now.Add(time.Hour * 24))
    
    // 十分钟之前的时间
    fmt.Println(now.Add(-time.Minute * 10))

}

执行结果：

1
2
3
4
5
2019-08-05 14:13:31.230839 +0800 CST m=+0.003991501
2019-08-05 14:13:41.230839 +0800 CST m=+10.003991501
2019-08-05 14:43:31.230839 +0800 CST m=+1800.003991501
2019-08-06 14:13:31.230839 +0800 CST m=+86400.003991501
2019-08-06 14:03:31.230839 +0800 CST m=+86400.003991501

Sub

1
func (t Time) Sub(u Time) Duration

两个时间对象相减得到time.Duration：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
package main

import (
    "fmt"
    "time"
)

func main() {
    now := time.Now()

    // 10小时后的时间
    later := now.Add(time.Hour * 10)

    // 计算now和later相差值
    sub := now.Sub(later)
    fmt.Println(sub)
}
1
-10h0m0s

Equal

1
func (t Time) Equal(u Time) bool

判断两个时间是否相同，受时区影响。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
package main

import (
    "fmt"
    "time"
)

func main() {
    // UTC时间
    now1 := time.Now().UTC()
    fmt.Println(now1)
    // 北京时间
    now2 := time.Now().Local()
    fmt.Println(now2)

    // 比较两个时间是否相同，会考虑到时区影响。
    e := now1.Equal(now2)
    fmt.Println(e)
    // 与值比较不同
    fmt.Println(now2 == now1)
}

执行结果：

1
2
3
4
2019-08-05 06:31:17.0639578 +0000 UTC
2019-08-05 14:31:17.0639578 +0800 CST
true
false

Before

1
func (t Time) Before(u Time) bool

比较t时间是否在u之前：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
package main

import (
    "fmt"
    "time"
)

func main() {
    now := time.Now()
    fmt.Println(now)
    before := now.Add(-time.Hour * 2)
    fmt.Println(before)

    // 判断是否在前
    b := before.Before(now)
    fmt.Println(b)
}

执行结果：

1
2
3
2019-08-05 14:40:06.0742141 +0800 CST m=+0.004017201
2019-08-05 12:40:06.0742141 +0800 CST m=-7199.995982799
true

After

1
func (t Time) After(u Time) bool

比较t时间是否在u之后：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
package main

import (
    "fmt"
    "time"
)

func main() {
    now := time.Now()
    fmt.Println(now)
    after := now.Add(time.Hour * 2)
    fmt.Println(after)

    // 判断是否在后
    b := after.After(now)
    fmt.Println(b)
}

执行结果：

1
2
3
2019-08-05 15:09:40.8128673 +0800 CST m=+0.004022201
2019-08-05 17:09:40.8128673 +0800 CST m=+7200.004022201
true

定时器

使用time.Tick()来设置定时器，定时器的本质上是一个channel。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
package main

import (
    "fmt"
    "time"
)

func main() {
    // 定义一个时间间隔为3秒的定时器，
    dingshiqi := time.Tick(time.Second * 3)

    //循环定时器
    for i := range dingshiqi {
        // 每十秒执行的任务
        fmt.Println(i)
    }
}

执行结果：

1
2
3
4
5
6
7
2019-08-05 15:14:58.4715038 +0800 CST m=+3.004032801
2019-08-05 15:15:01.4733053 +0800 CST m=+6.005834401
2019-08-05 15:15:04.4716833 +0800 CST m=+9.004212301
2019-08-05 15:15:07.4723472 +0800 CST m=+12.004876201
2019-08-05 15:15:10.4720618 +0800 CST m=+15.004590901
2019-08-05 15:15:13.4716867 +0800 CST m=+18.004215801
2019-08-05 15:15:16.4728042 +0800 CST m=+21.005333301

时间格式化

go语言的格式化和其它语言有不同之处，是使用Go的诞生时间2006年1月2号15点04分（记忆口诀为20061234）。也许这就是技术人员的浪漫吧。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
package main

import (
    "fmt"
    "time"
)

func main() {
    now := time.Now()

    fmt.Println(now.Format("2006-01-02 15:04:05"))
    fmt.Println(now.Format("2006-01-02 15:04:05 PM"))
    fmt.Println(now.Format("2006/01/02"))
}

执行结果：

1
2
3
2019-08-05 15:31:39
2019-08-05 15:31:39 PM
2019/08/05

解析字符串格式的时间

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
package main

import (
    "fmt"
    "time"
)

func main() {
    timeStr := "2019/08/05 13:14:52"

    // 加载时区
    loc, err := time.LoadLocation("Asia/Shanghai")
    if err != nil {
        fmt.Println(err)
    }

    // 按照指定时区和字符串解析成时间
    timeObj, _ := time.ParseInLocation("2006/01/02 15:04:05", timeStr, loc)
    timeObj1, _ := time.Parse("2006/01/02 15:04:05", timeStr)
    fmt.Println(timeObj)
    fmt.Println(timeObj.Year())
    fmt.Println(timeObj1)
    fmt.Println(timeObj1.Year())
}

执行结果：

1
2
3
4
2019-08-05 13:14:52 +0800 CST
2019
2019-08-05 13:14:52 +0000 UTC
2019
/