Go 语言编程实例（六）

本节主要分享：JSON、时间日期、Epoch、时间格式化解析、伪随机数

以下代码在存放于github中如下仓库:github

Go JSON实例

JSON格式在网络通讯中使用的比较频繁，简单而优雅。Go 提供了对JSON编码和解码的内置支持，包括内置和自定义数据类型。

package main

import (
    "encoding/json"
    "fmt"

    "os"
)

type Response1 struct{
    Page int
    Fruits []string
}

type Response2 struct{
    Page   int       `json:"page"`
    Fruits []string  `json:"fruits"`
}

func main(){
    bolB,_:=json.Marshal(true)
    fmt.Println(string(bolB))

    intB,_:=json.Marshal(1)
    fmt.Println(string(intB))

    fltB,_:=json.Marshal(2.34)
    fmt.Println(string(fltB))

    //slice，map示例 编码成json 数组

    slcD := []string{"apple","peach","pear"}
    slcB , _ := json.Marshal(slcD)
    fmt.Println(string(slcB))

    mapD := map[string]int {"apple":5,"lettuce":7}
    mapB , _ := json.Marshal(mapD)
    fmt.Println(string(mapB))


    //自动编码自定义数据
    res1D := &Response1{
        Page: 1,
        Fruits:[]string{"apple","peach","pear"}}
    res1B ,_ :=json.Marshal(res1D)
    fmt.Println(string(res1B))

    res2D := &Response2{
        Page: 1,
        Fruits:[]string{"apple","peach","pear"}}
    res2B , _ := json.Marshal(res2D)
    fmt.Println(string(res2B))

    byt := []byte(`{"num":6.13,"strs":["a","b"]}`)

    var dat map[string]interface{}

    if err := json.Unmarshal(byt,&dat);err != nil{
        panic(err)
    }
    fmt.Println(dat)

    num:= dat["num"].(float64)
    fmt.Println(num)

    strs := dat["strs"].([]interface{})
    str1 := strs[0].(string)
    fmt.Println(str1)

    str := `{"page":1,"fruits":["apple","peach"]}`
    res := Response2{}

    json.Unmarshal([]byte(str),&res)
    fmt.Println(res)
    fmt.Println(res.Fruits[0])

    enc:= json.NewEncoder(os.Stdout)
    d := map[string]int{"apple":5,"lettuce":7}
    enc.Encode(d)
}

Go 时间日期编程

Go 编程为时间和持续时间提供了广泛的支持。示例是从获取当前时间开始，创建时间结构体进行解析，时间对比，两个时间的间隔问题，时间的加减问题。

package main

import (
    "fmt"
    "time"
)

func main(){
    p := fmt.Println

    //得到当前时间
    nowtime := time.Now()
    p(nowtime)

    //创建一个时间结构体进行解析
    then := time.Date(
        2017,8,18,19,34,52,621544,time.UTC)

    p(then)

    //这里可以使用其他的函数不一一例举了
    p(then.Year())
    p(then.Month())
    p(then.Second())
    p(then.Location())
    p(then.Weekday())

    //同时可以进行时间的比对
    p(then.Before(nowtime))
    p(then.After(nowtime))
    p(then.Equal(nowtime))

    //两个时间的间隔
    diff := nowtime.Sub(then)

    p(diff)

    p(diff.Hours())
    p(diff.Minutes())
    p(diff.Seconds())
    p(diff.Nanoseconds())

    //时间加减
    p(then.Add(diff))
    p(then.Add(-diff))
}

Go 时代（Epoch）实例

程序中的一个常见要求是获取自 Unix 纪元依赖的秒数，毫秒数或纳秒数。示例是使用 Unix或UnixNano 的 time.Now ,分别以秒或者纳秒为单位获得自 Unix 纪元起经过的时间。

同时也有方法将整数秒或者纳秒转换为相应的时间。

package main

import (
    "time"
    "fmt"
)

func main(){

    //使用 time.Now() 与 Unix 或者 UnixNano 并用获得时间
    now  := time.Now()
    secs := now.Unix()
    nanos:= now.UnixNano()
    fmt.Println(now)


    millis := nanos/1000000
    fmt.Println(secs)
    fmt.Println(millis)
    fmt.Println(nanos)

    //通过秒或者纳秒反向求解

    fmt.Println(time.Unix(secs,0))
    fmt.Println(time.Unix(0,nanos))
}

Go时间格式化/解析实例

Go 支持通过基于模式的布局进行时间格式化和解析。这里是根据 RFC3339 格式化时间的一个基本示例，还有错误示例。

package main

import (
    "fmt"
    "time"
)

func main(){
    p := fmt.Println

    t := time.Now()
    p(t.Format(time.RFC3339))


    t1 , _ := time.Parse(
        time.RFC3339,
        "2017-11-01T22:35:52+00:00")
    p(t1)

    //格式化和解析

    p(t.Format("3:04PM"))
    p(t.Format("Mon Jan _2 15:04:05 20017"))
    p(t.Format("2006-01-02T15:04:05.99999-08:00"))

    form := "3 04 PM"
    t2,_ := time.Parse(form,"8 41 PM")
    p(t2)

    fmt.Printf("%d-%02d-%02dT%02d:%02d:%02d-00:00\n",
            t.Year(),t.Month(),t.Day(),
            t.Hour(),t.Minute(),t.Second())

    //错误处理
    ansic := "Mon jan _2 15:04:05 2006"
    _,e:=time.Parse(ansic,"8:41PM")
    p(e)
}

Go 随机数示例

Go 的 math/rand 包提供伪随机数生成。例如，rand.Intn 返回一个随机 int n,0 <= n < 100。 rand.Float64 返回一个 float64 f, 0.0 <= f < 1.0 。这可以用于生产其他范围内的随机浮点，例如 5.0 <= f < 10.0

这是一个伪随机数，每次进入调用函数产的第一个随机都是一样的。

package main

import (
    "fmt"
    "math/rand"
)

func main(){
    p := fmt.Println

    //产生 0 - 100 的伪随机数
    p(rand.Intn(100))
    p(rand.Intn(100))

    //产生浮点随机数
    p(rand.Float64())
    p(rand.ExpFloat64()*10)
    p(rand.ExpFloat64()*100)

    
}

如需进一步讨论可以加群：295023494