本节主要分享：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
