Golang时间操作&JSON序列化与反序列化

2022-08-14 10:54:44

时间操作

Time包

获取当前时间

    t := time.Now()
    fmt.Printf("%T\n", t)   //time.Time
    fmt.Println(t)          //2019-07-08 15:23:55.1114609 +0800 DST m=+0.000192401

获取指定的时间

    t := time.Date(2009, 7, 15, 16, 30, 28, 0, time.Local)
    fmt.Println(t)              //2009-07-15 16:30:28 +0800 DST

时间转字符串

    t := time.Date(2009, 7, 15, 16, 30, 28, 0, time.Local)
    s1 := t.Format("2006年1月2日 15:04:05")
    fmt.Println(s1)              //2009年7月15日 16:30:28
    s2 := t.Format("2006-1-2 15:04:05")
    fmt.Println(s2)             //2009-7-15 16:30:28
    s3 := t.Format("2006/01/02")
    fmt.Println(s3)             //2009/07/15

字符串转时间

s = "2019年10月10日"
t, err := time.Parse("2006年1月2日", s)
if err != nil {
    fmt.Println("err:", err)
}
fmt.Println(t)                  //2019-10-10 00:00:00 +0000 UTC
fmt.Printf("%T\n", t)           //time.Time

根据当前时间获取指定内容

    t := time.Now()
    year, month, day := t.Date()
    fmt.Println(year, month, day)   //2019 July 8

    hour, min, sec := t.Clock()
    fmt.Println(hour, min, sec)     //15 50 12

    years := t.Year()
    fmt.Println("年", years)        //年 2019
    fmt.Println(t.YearDay())        //189    当前日期在当年多少天
    months  := t.Month()
    fmt.Println("月", months)       //月 July
    days := t.Day()
    fmt.Println("日", days)         //日 8
    hours := t.Hour()
	fmt.Println("时", hours)          //15
    minutes := t.Minute()
	fmt.Println("分", minutes)        //59
    seconds := t.Second()
	fmt.Println("秒", seconds)        //18
    nanoseconds := t.Nanosecond()
	fmt.Println("纳秒", nanoseconds)  //462754000
    weekday := t.Weekday()
	fmt.Println("星期",weekday)       //Monday

时间戳 (距离1970年1月1日0时0分0秒的时间差值)

    t1 := time.Date (1970, 1, 1, 1, 0, 0, 0, time.UTC)
    fmt.Println(t1.Unix())                  //3600 （秒的差值）
    t2 := time.Now()
    fmt.Println(t2.Unix())                  //1562573562

    fmt.Println(t1.UnixNano())              //3600000000000
    fmt.Println(t2.UnixNano())              //1562573562116878000

时间间隔

t1 := time.Now()
t2 := t1.Add(time.Minute)
fmt.Println(t1)                             //2019-07-08 16:17:46.4768441 +0800 DST m=+0.000175701
fmt.Println(t2)                             //2019-07-08 16:18:46.4768441 +0800 DST m=+60.000175701
fmt.Println(t1.Add(24 * time.Hour))         //2019-07-09 16:17:46.4768441 +0800 DST m=+86400.000175701

t3 := t1.AddDate(1, 0, 0)
fmt.Println(t3)                             //2020-07-08 16:19:42.9320107 +0800 DST

d := t2.Sub(t1)
fmt.Println(d)                              //1m0s

睡眠

time.Sleep(3 * time.Second)                 //程序睡眠3秒钟

//睡眠随机数
rand.Seed(time.Now().UnixNano())
randNum := rand.Intn(10) + 1
fmt.Println(randNum)
time.Sleep(time.Duration(randNum) * time.Second)
fmt.Println(randNum)

JSON序列化与反序列化

JSON

JSON(JavaScript Object Notation, JS 对象简谱) 是一种轻量级的数据交换格式。https://www.json.cn/

语法规则
在 JS 语言中，一切都是对象。因此，任何支持的类型都可以通过 JSON 来表示.
键/值对
JSON 键值对是用来保存 JS 对象的一种方式,键/值对组合中的键名写在前面并用双引号 "" 包裹，使用冒号 : 分隔，然后紧接着值

    {"firstName": "Json"}

json 的序列化
json 序列化是指，将有 key-value 结构的数据类型(比如结构体、map、切片)序列化成 json 字符串的操作。

结构体json序列化：

    type Monster struct {
        Name string
        Age int
        Birthday string
        Sal float64
        Skill string
    }

    func main() {
        monster := Monster{
            Name :"牛魔王",
            Age : 500 ,
            Birthday : "2011-11-11",
            Sal : 8000.0,
            Skill : "牛魔拳",
        }

        //将monster 序列化
        data, err := json.Marshal(&monster) //..
        if err != nil {
            fmt.Printf("序列号错误 err=%v\n", err)
        }
        //输出序列化后的结果
        fmt.Printf("monster序列化后=%v\n", string(data))
    }

map json序列化：

    func main() {
        //定义一个map
        var a map[string]interface{}
        //使用map,需要make
        a = make(map[string]interface{})
        a["name"] = "红孩儿"
        a["age"] = 30
        a["address"] = "洪崖洞"

        //将a这个map进行序列化
        //将monster 序列化
        data, err := json.Marshal(a)
        if err != nil {
            fmt.Printf("序列化错误 err=%v\n", err)
        }
        //输出序列化后的结果
        fmt.Printf("a map 序列化后=%v\n", string(data))
    }

切片json序列化：

    func main() {
        var slice []map[string]interface{}
        var m1 map[string]interface{}
        //使用map前，需要先make
        m1 = make(map[string]interface{})
        m1["name"] = "jack"
        m1["age"] = "7"
        m1["address"] = "北京"
        slice = append(slice, m1)

        var m2 map[string]interface{}
        //使用map前，需要先make
        m2 = make(map[string]interface{})
        m2["name"] = "tom"
        m2["age"] = "20"
        m2["address"] = [2]string{"墨西哥","夏威夷"}
        slice = append(slice, m2)

        //将切片进行序列化操作
        data, err := json.Marshal(slice)
        if err != nil {
            fmt.Printf("序列化错误 err=%v\n", err)
        }
        //输出序列化后的结果
        fmt.Printf("slice 序列化后=%v\n", string(data))
        
    }

基本数据类型序列化

对基本数据类型进行序列化意义不大

    func main() {
        var num1 float64 = 2345.67

        //对num1进行序列化
        data, err := json.Marshal(num1)
        if err != nil {
            fmt.Printf("序列化错误 err=%v\n", err)
        }
        //输出序列化后的结果
        fmt.Printf("num1 序列化后=%v\n", string(data))
    }

注意事项
对于结构体的序列化，如果我们希望序列化后的 key 的名字，又我们自己重新制定，那么可以给 struct指定一个 tag 标签.

type Monster struct {
	Name string `json:"monster_name"` //反射机制
	Age int `json:"monster_age"`
	Birthday string `json:"monster_birthday"`
	Sal float64 `json:"monster_sal"`
	Skill string `json:"monster_skill"`
}

func testStruct() {
	//演示
	monster := Monster{
		Name :"牛魔王",
		Age : 500 ,
		Birthday : "2011-11-11",
		Sal : 8000.0,
		Skill : "牛魔拳",
	}

	//将monster 序列化
	data, err := json.Marshal(&monster) //..
	if err != nil {
		fmt.Printf("序列号错误 err=%v\n", err)
	}
	//输出序列化后的结果
	fmt.Printf("monster序列化后=%v\n", string(data))

}

json 反序列化
json 反序列化是指，将 json 字符串反序列化成对应的数据类型(比如结构体、map、切片)的操作

json反序列化结构体：

    type Monster struct {
        Name string  
        Age int 
        Birthday string //....
        Sal float64
        Skill string
    }

    //演示将json字符串，反序列化成struct
    func main() {
        //说明str 在项目开发中，是通过网络传输获取到.. 或者是读取文件获取到
        str := "{\"Name\":\"牛魔王~~~\",\"Age\":500,\"Birthday\":\"2011-11-11\",\"Sal\":8000,\"Skill\":\"牛魔拳\"}"

        //定义一个Monster实例
        var monster Monster

        err := json.Unmarshal([]byte(str), &monster)
        if err != nil {
            fmt.Printf("unmarshal err=%v\n", err)
        }
        fmt.Printf("反序列化后 monster=%v monster.Name=%v \n", monster, monster.Name)
    }

json反序列化map：

func main() {
	str := "{\"address\":\"洪崖洞\",\"age\":30,\"name\":\"红孩儿\"}"
	//定义一个map
	var a map[string]interface{} 

	//反序列化
	//注意：反序列化map,不需要make,因为make操作被封装到 Unmarshal函数
	err := json.Unmarshal([]byte(str), &a)
	if err != nil {
		fmt.Printf("unmarshal err=%v\n", err)
	}
	fmt.Printf("反序列化后 a=%v\n", a)

}

json反序列化切片：

    func main() {
        str := "[{\"address\":\"北京\",\"age\":\"7\",\"name\":\"jack\"}," + 
            "{\"address\":[\"墨西哥\",\"夏威夷\"],\"age\":\"20\",\"name\":\"tom\"}]"
        
        //定义一个slice
        var slice []map[string]interface{}
        //反序列化，不需要make,因为make操作被封装到 Unmarshal函数
        err := json.Unmarshal([]byte(str), &slice)
        if err != nil {
            fmt.Printf("unmarshal err=%v\n", err)
        }
        fmt.Printf("反序列化后 slice=%v\n", slice)
    }

Golang时间操作&JSON序列化与反序列化

码农公寓

时间操作

Time包

JSON序列化与反序列化

JSON

相关文章