OStack程序员社区-中国程序员成长平台 › 门户 › 编程› Go›Go教程

Go语言基础之3--时间和日期序列

原作者: [db:作者] 来自: [db:来源] 收藏邀请

1. time包

2. time.Time类型，用来表示时间

3. 获取当前时间， now := time.Now()

实例1-1 打印输出当前时间

package main

import (
    "fmt"
    "time"
)

func main() {
    //var now time.Time
    //now = time.Now()
    now := time.Now()
    fmt.Printf("current time is %v\n", now)
}

执行结果：

4. 年： time.Now().Year()

月：time.Now().Month()

日：time.Now().Day()

时：time.Now.Hour()

分：time.Now().Minute()

秒：time.Now.Second()

5. 格式化， fmt.Printf(“%02d/%02d%02d %02d:%02d:%02d”, now.Year()…)

实例1-2 格式化输出当前时间

package main

import (
    "fmt"
    "time"
)

func main() {
    now := time.Now()
    fmt.Printf("%02d/%02d/%02d %02d:%02d:%02d",
        now.Year(), now.Month(), now.Day(), now.Hour(), now.Minute(), now.Second())
}

执行结果如下：

6. 获取当前时间戳（时间戳就是1970年1月1日0点0分0秒到现在的秒数），

获取方法time.Now().Unix()。

实例1-3 打印当前时间时间戳及以纳秒形式显示

package main

import (
    "fmt"
    "time"
)

func main() {
    now := time.Now()
    fmt.Printf("timestamp:%d ns:%d\n", now.Unix(), now.UnixNano())
}

执行结果如下：

注意：纳秒范围太大，如果要存储，需要用int64类型，不然就溢出了。

7. 时间戳转Time类型。

实例1-4

package main

import (
    "fmt"
    "time"
)

func TimestampToTime(timestamp int64) { //时间戳是int64类型，所以我们这里必须定义为int64
    t := time.Unix(timestamp, 0) //传入参数对应的是秒和纳秒，这里把时间戳类型转化为time类型,因为传入的时间戳单位是秒，所以对应的纳秒我们写为0即可。
    fmt.Printf("convert timestamp to time:%v\n", t)
}

func main() {
    now := time.Now()
    TimestampToTime(now.Unix()) //传入的参数为当前的时间戳(单位是秒)
}

执行结果如下：

8. 定时器的简单使用（项目会用到（定时任务））

方法1：Newtimer（注意：只触发1次，必须reset，否则会堵塞）

实例1-5

package main

import (
    "fmt"
    "time"
)

func testTimer() { //testTimer是遍历时间定时器的函数
    timer := time.NewTimer(time.Second) //Newtimer相当于一个定时器，只触发一次
    //time.second表示1秒,newtimer中用到了duration函数，其单位为纳秒，1秒等于10亿纳秒，太大，所以go语言中已经写好了这个方法，time.second表示1秒
    for v := range timer.C {
        //使用range类型去遍历channel,现在是当为1秒时（每隔1秒）去执行一下for循环
        fmt.Printf("time:%v\n", v)
        timer.Reset(time.Second) //如果不加reset，那么就会死锁（deadlock），因为newtimer只执行一次，之后就不往管道中插入时间，我们也就无法在管道中去遍历，所以会报死锁。
        //加了reset之后，就相当于把当前定时器又重置回0秒，然后定时器到1秒后，又执行1次，这样就达到我们的目的了（不会阻塞，每个1秒重置一次）。
    }
}

func main() {
    testTimer()
    time.Sleep(time.Minute)  //表示main主线程sleep一分钟后退出。
}

执行结果：

方法2：NewTicker（不需要reset，每隔1秒去触发1次）

package main

import (
    "fmt"
    "time"
)

func testTicker() {
    timer := time.NewTicker(time.Second)
    for v := range timer.C {
        fmt.Printf("time:%v\n", v)
    }
}
func main() {
    testTicker()
    time.Sleep(time.Minute) //表示main主线程sleep一分钟后退出。
}

执行结果如下：

9. time.Duration用来表示纳秒

解释：

time包中的duration函数，其的单位是纳秒，这也是Go语言中时间最细的一个密度。

10. 一些常量，我们也可以直接拿去用：

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

11. 格式化

自带的format方法

2006年1月2日15时04分05秒是go语言诞生的日子，所以format方法的硬性规定就是：如果想格式化时间，并且借助format方法，就必须go语言的诞生时间做代码时间格式化的模板（必须是这个时间，如果不符，输出时间是不正确的）：

格式如下：

now := time.Now()
fmt.Println(now.Format(“02/1/2006 15:04:05”))
fmt.Println(now.Format(“2006/1/02 15:04”))
fmt.Println(now.Format(“2006/1/02”))

实例1-6

package main

import (
    "fmt"
    "time"
)

func main() {
    now := time.Now()
    //方法1：
    fmt.Printf("%02d/%02d/%02d %02d:%02d:%02d\n",
        now.Year(), now.Month(), now.Day(), now.Hour(), now.Minute(), now.Second())
// 方法2：
// 2016/01/02 15:04:05是go的诞生时间，必须写正确
    str := now.Format("02/01/2006 15:04:05")
    fmt.Printf("str:%s\n", str)
}

执行结果如下：

二、练习题

练习1：写一个程序，获取当前时间，并格式化成 2017/06/15 08:05:00形式

解答：

思路：此题方法较多，随便用哪一种格式化方法都可以；

package main

import (
    "fmt"
    "time"
)

func main() {
    now := time.Now()
    str := now.Format("2006/01/02 15:04:05")
    fmt.Printf("%s\n", str)
}

执行结果：

练习2：写一个程序，统计一段代码的执行耗时，单位精确到微秒

解答：

思路：代码执行之前获取一下时间，代码执行完在获取一下时间，两个时间相减，即为一段代码执行消耗的时间。

package main

import (
    "fmt"
    "time"
)

func test() { //测试代码函数
    for i := 0; i < 100000000; i++ {
        _ = i //变量i未使用，这里我们忽略掉它
    }
}
func main() {
    //var now time.Time
    //now = time.Now()
    //start := now.UnixNano
    start := time.Now().UnixNano() //开始时间
    test()
    end := time.Now().UnixNano()                 //结束时间
    fmt.Printf("cost=%d us\n", (end-start)/1000) //纳秒转微妙
}