网站首页 返回列表像“草根”一样，紧贴着地面，低调的存在，冬去春来，枯荣无恙。

Go 语言编程实例（六）

2020-06-10 11:43:21 admin 1283

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

以下代码在存放于github中如下仓库:[github](https://link.jianshu.com?t=https://github.com/dpawsbear/go_learning)

#### 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

转载文章，原文链接： Go 语言编程实例（六）

关键字词go 编程

分享到：

上一篇： go并发应用 - 写一个任务调度小程序

下一篇：Golang可变参数

如需留言，请登录，没有账号？请注册

0 条评论 0 人参与

网站首页 返回列表像“草根”一样，紧贴着地面，低调的存在，冬去春来，枯荣无恙。

Go 语言编程实例（六）

zhou 3年前

zhou 3年前

zhou 3年前

zhou 3年前

武云 3年前

网站首页 返回列表 像“草根”一样，紧贴着地面，低调的存在，冬去春来，枯荣无恙。

Go 语言编程实例（六）

zhou 3年前

zhou 3年前

zhou 3年前

zhou 3年前

武云 3年前

网站首页返回列表像“草根”一样，紧贴着地面，低调的存在，冬去春来，枯荣无恙。