Golang时间操作JSON序列化与反序列化
时间操作
Time
1. 获取当前时间
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
2. 获取指定的时间
t := time.Date(2009, 7, 15, 16, 30, 28, 0, time.Local)
fmt.Println(t) //2009-07-15 16:30:28 +0800 DST
3. 时间转字符串
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
4. 字符串转时间
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
5. 根据当前时间获取指定内容
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
6. 时间戳 (距离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
7. 时间间隔
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
8. 睡眠
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(JavaScript Object Notation, JS 对象简谱) 是⼀种轻量级的数据交换格式。
语法规则
在 JS 语⾔中，⼀切都是对象。因此，任何⽀持的类型都可以通过 JSON 来表⽰.
键/值对
JSON 键值对是⽤来保存 JS 对象的⼀种⽅式，键/值对组合中的键名写在前⾯并⽤双引号 "" 包裹，使⽤冒号 : 分隔，然后紧接着值 {"firstName": "Json"}
json 的序列化
json 序列化是指，将有 key-value 结构的数据类型(⽐如结构体、map、切⽚)序列化成 json 字符串的操作。
1. 结构体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))
}
2. map json序列化：
func main() {
//定义⼀个map
js获取json的key和valuevar 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))
}
3. 切⽚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))
}
4. 基本数据类型序列化
对基本数据类型进⾏序列化意义不⼤
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、切⽚)的操作1. 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)
}
2. 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)
}
3. 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)
}
版权声明：本站内容均来自互联网，仅供演示用，请勿用于商业和其他非法用途。如果侵犯了您的权益请与我们联系QQ:729038198，我们将在24小时内删除。
发表评论