golang 时间编程

     编程离不开时间，时间管理，严格的说分成两块，一个是当前的时刻，对应的是一个点，还有是一段时间间隔。本文简单的讲讲go的时间相关的编程，比较简单，高手可以一笑而过。

    golang对时间的支持，是package time做的事儿，里面有好多的函数，我就不一一举例学习，毕竟这是官方文档干的事情。我们初步的学习下常用的函数。

    第一个是UNIX epoch time，确切的说就是自1970-01-01 00：00：00 GMT以来的秒数，不知道如何获取的，可以在shell下执行 date +%s

   golang中一个很重要的表征时间的数据类型是Time，基本就是三个成员变量 sec ，nsec，Location，详细意思可以参看注释。

type Time struct {
           // sec gives the number of seconds elapsed since
            // January 1, year 1 00:00:00 UTC.
            sec int64
        
            // nsec specifies a non-negative nanosecond
            // offset within the second named by Seconds.
            // It must be in the range [0, 999999999].
            nsec int32
        
            // loc specifies the Location that should be used to
            // determine the minute, hour, month, day, and year
            // that correspond to this Time.
            // Only the zero Time has a nil Location.
            // In that case it is interpreted to mean UTC.
            loc *Location
        }

   OK，如何取到UNIX epoch time.

now := time.Now()

   用time package中Now()函数获取到当前的时间信息，Now()函数非常的重要，他是后面一切转换的起始点。从Now()我们获取到了Time，从Time类型我们从容的获取到UNIX epoch time ,自然获取到year ，month ，day，weekday, hour,minute,second,nanosecond.

 获取UNIX epoch time：

var epoch_seconds int64 = now.Unix()

    获取Year

func (t Time) Year() int

cur_year := now.Year()

  获取Month

func (t Time) Month() Month

cur_month := now.Month()

if cur_month == time.November {
    ...
}

    Month是int类型，fmt.Printf("%v") 或者fmt.Println可以打印出November来，同时Month type有String()函数，输出“November”这样的字符串

const (
        January Month = 1 + iota
        February
        March
        April
        May
        June
        July
        August
        September
        October
        November
        December
)

  year mon day，这些都可以在Date函数中一并返回：

func (t Time) Date() (year int, month Month, day int)

year,mon,day = now.Date()

    获取Hour 

func (t Time) Hour() int
  cur_hour := now.Hour()

    Minute可以通过Minute()返回，second可以通过Second()返回。

    time还提供了Clock()的同时返回 hour,minute,second = now.Clock().

package main

import "fmt"
import "time"



func main(){
    
    now := time.Now()
    year,mon,day := now.UTC().Date()
    hour,min,sec := now.UTC().Clock()
    zone,_ := now.UTC().Zone()
    fmt.Printf("UTC time is %d-%d-%d %02d:%02d:%02d %s\n",
                year,mon,day,hour,min,sec,zone)

    year,mon,day = now.Date()
    hour,min,sec = now.Clock()
    zone,_ = now.Zone()
    fmt.Printf("local time is %d-%d-%d %02d:%02d:%02d %s\n",
     year,mon,day,hour,min,sec,zone)
}

go版本的输出
---------------------
UTC   time is 2013-11-22 15:51:22 UTC
local time is 2013-11-22 23:51:22 CST

     我们另一个关心的话题，是时间间隔，比如我们profile一个以非常耗时的function，我们会在函数开始前记下时刻值，函数结束后，再次记录下时刻值，然后两者的差值，就是函数运行时间。

    这表明Time是可以相减的

start_time := time.Now()
expensive_function
end_time :=time.Now()

var duration Duration = end_time.Sub(start_time)

    Duration是一种数据类型，其实是个int64类型，表征的是两个时刻之间的纳秒数。

type Duration int64

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

   Duration类型有Minutes()/Second()/Nanoseconds(), 将duration折算成分钟/秒/纳秒。

now := time.Now()
    time.Sleep(3*time.Second);
    end_time := time.Now()

    var dur_time time.Duration = end_time.Sub(now)
    var elapsed_min float64 = dur_time.Minutes()
    var elapsed_sec float64 = dur_time.Seconds()
    var elapsed_nano int64 = dur_time.Nanoseconds()
    fmt.Printf("elasped %f minutes or \nelapsed %f seconds or \nelapsed %d nanoseconds\n",
                elapsed_min,elapsed_sec,elapsed_nano)

   输出如下

elasped 0.050005 minutes or 
elapsed 3.000292 seconds or 
elapsed 3000292435 nanoseconds

   Go中的time.Sleep一律是以纳秒为单位的，当然本质是Duration类型：

    sleep 3秒可以写成

time.Sleep(3000000000)

time.Sleep(3*time.Second);

package main
 
import (
    "fmt"
    "time"
)
 
const (
    date        = "2006-01-02"
    shortdate   = "06-01-02"
    times       = "15:04:02"
    shorttime   = "15:04"
    datetime    = "2006-01-02 15:04:02"
    newdatetime = "2006/01/02 15~04~02"
    newtime     = "15~04~02"
)
 
func main() {
    thisdate := "2014-03-17 14:55:06"
    timeformatdate, _ := time.Parse(datetime, thisdate)
    fmt.Println(timeformatdate)
    convdate := timeformatdate.Format(date)
    convshortdate := timeformatdate.Format(shortdate)
    convtime := timeformatdate.Format(times)
    convshorttime := timeformatdate.Format(shorttime)
    convnewdatetime := timeformatdate.Format(newdatetime)
    convnewtime := timeformatdate.Format(newtime)
    fmt.Println(convdate)
    fmt.Println(convshortdate)
    fmt.Println(convtime)
    fmt.Println(convshorttime)
    fmt.Println(convnewdatetime)
    fmt.Println(convnewtime)
}

转载于:https://my.oschina.net/lengxugz/blog/497043