1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

package main
import (
	"encoding/json"
	"fmt"
)
func main()  {
	// map里面
	map1 := map[string]string {
		"name":"张三",
		"age":"18",
		"home":"北京",
	}
	// 将map解析成json
	json1, err := json.Marshal(map1)
	if err != nil {
		fmt.Println(err.Error())
	}
	fmt.Printf("json1: %s  类型: %T \n",json1,json1)
  
	map2 := map[string][]string {
		"fruit": {"香蕉","葡萄"},
		"coder":{"PHP","Go","Java"},
		"likes":{"打游戏","看动漫"},
	}
	json2, err := json.Marshal(map2)
	if err != nil {
		fmt.Println(err.Error())
	}
	fmt.Printf("json2: %s  类型: %T \n",json2,json2)
}
/**输出
json1: {"age":"18","home":"北京","name":"张三"}  类型: []uint8 
json2: {"coder":["PHP","Go","Java"],"fruit":["香蕉","葡萄"],"likes":["打游戏","看动漫"]}  类型: []uint8 
*/

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

package main
import (
	"encoding/json"
	"fmt"
)
func main()  {
	json1 := `{"age":"18","home":"北京","name":"张三"}`
	map1 := make(map[string]string)
	err := json.Unmarshal([]byte(json1), &map1)
	if err != nil {
		fmt.Println(err.Error())
	}
	fmt.Printf("map1: %v T: %T\n",map1,map1)

	json2 := `{"coder":["PHP","Go","Java"],"fruit":["香蕉","葡萄"],"likes":["打游戏","看动漫"]}`
	map2 := make(map[string][]string)
	err = json.Unmarshal([]byte(json2), &map2)
	if err != nil {
		fmt.Println(err.Error())
	}
	fmt.Printf("map2: %v T: %T\n",map2,map2)
}
/**输出
map1: map[age:18 home:北京 name:张三] T: map[string]string
map2: map[coder:[PHP Go Java] fruit:[香蕉 葡萄] likes:[打游戏 看动漫]] T: map[string][]string
*/

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

package main
import (
	"encoding/json"
	"fmt"
)
type Student struct {
	Name string
	Age int
	Class string
	phone string //小写字段，则不会导出
}
func main()  {
	s := Student{
		Name:  "张三",
		Age:   17,
		Class: "三年级",
		phone: "17600112222",
	}
	json1, err := json.Marshal(s)
	if err != nil {
		fmt.Println(err.Error())
	}
	fmt.Printf("json: %s \n",json1)
}
// 输出 json: {"Name":"张三","Age":17,"Class":"三年级"} 

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

package main
import (
	"encoding/json"
	"fmt"
)
// 定义一个学生结构体
type Student struct {
	Name  string `json:"_name"` // 字段标签的语法
	Age   int    `json:"_age"`
	Class string `json:"-"` // 不解析
	Phone string `json:"phone"`
	Score float32 // 没有标签时，则用字段名
}
func main()  {
	s := Student{
		Name:  "张三",
		Age:   17,
		Class: "三年级",
		Phone: "17600112222",
		Score: 88.5,
	}
	json1, err := json.Marshal(s)
	if err != nil {
		fmt.Println(err.Error())
	}
	fmt.Printf("json: %s \n",json1)
}
// 输出-> json: {"_name":"张三","_age":17,"phone":"17600112222","Score":88.5}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

package main
import (
	"encoding/json"
	"fmt"
)
type Student struct {
	Name  string `json:"_name"`
	Age   int    `json:"_age"`
    Top // 匿名字段
}
type Top struct {
	Sort int `json:"sort"`
	Score float64
	Class string
}
func main()  {
	s := Student{
		Name: "张三",
		Age:  18,
		Top:  Top{1,99.5,"一年级"},
	}
	json1, err := json.Marshal(s)
	if err != nil {
		fmt.Println(err.Error())
	}
	fmt.Printf("json: %s \n",json1)
}
//输出-> json: {"_name":"张三","_age":18,"sort":1,"Score":99.5,"Class":"一年级"}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

package main
import (
	"encoding/json"
	"fmt"
)
type Student struct {
	Name  string `json:"_name"`
	Age   int    `json:"_age"`
    Top // 匿名字段
}
type Top struct {
	Sort int `json:"sort"`
	Score float64
	Class string
}
func main(){
	student := Student{}
	js := `{"_name":"张三","_age":18,"sort":1,"Score":99.5,"Class":"一年级"}`
	err := json.Unmarshal([]byte(js), &student)
	if err != nil {
		fmt.Println(err.Error())
	}
	fmt.Printf("v: %+v  t: %T \n",student,student)
}
// 输出: v: {Name:张三 Age:18 Top:{Sort:1 Score:99.5 Class:一年级}}  t: main.Student

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18

package main
import (
	"encoding/json"
	"fmt"
)
func main(){
	student := []string {
		"张三",
		"李四",
		"小米",
	}
	marshal, err := json.Marshal(student)
	if err != nil {
		fmt.Println(err.Error())
	}
	fmt.Printf("v :%s T:%T",marshal,marshal)
}
// 输出 v :["张三","李四","小米"] T:[]uint8

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

package main
import (
	"encoding/json"
	"fmt"
)
func main(){
	json1 := `["张三","李四","小米"]`
	var sc []string
	err := json.Unmarshal([]byte(json1), &sc)
	if err != nil {
		fmt.Println(err.Error())
	}
	fmt.Printf("v :%v T:%T",sc,sc)
}
// 输出: v :[张三 李四 小米] T:[]string