遍历结构体
如何实现遍历结构体字段? 好吧，言归正传!举个例子：
demo1:
|
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 (
"fmt"
"reflect"
)
type Student struct {
name string
age int
}
func main() {
v := reflect.ValueOf(Student{"乔峰", 29})
count := v.NumField()
for i := 0; i < count; i++ {
f := v.Field(i) //字段值
switch f.Kind() {
case reflect.String:
fmt.Println(f.String())
case reflect.Int:
fmt.Println(f.Int())
}
}
}
|
再举给栗子：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
|
package main
import (
"fmt"
"reflect"
)
type LanType struct {
s1, s2, s3 string
}
var language interface{} = LanType{"Php", "Go", "Python3"}
func main() {
value := reflect.ValueOf(language)
for i := 0; i < value.NumField(); i++ {
fmt.Printf("字段索引 %d: %v\n", i, value.Field(i))
}
}
|
输出：
BASIC
字段索引 0: Php
字段索引 1: Go
字段索引 2: Python3
遍历切片
使用 for range遍历：
|
1
2
3
4
5
6
7
8
9
10
11
12
|
package main
import (
"fmt"
)
func main() {
language := []string{"Php", "Go", "Python3"}
for k, val := range language {
fmt.Printf("切片索引 %d is :%s\n", k, val)
}
}
|
输出：
BASIC
切片索引 0 is :Php
切片索引 1 is :Go
切片索引 2 is :Python3
遍历Ｍap
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
|
package main
import (
"fmt"
)
func main() {
language := make(map[string]string)
language["1"] = "Php"
language["2"] = "Go"
language["3"] = "Python3"
language["4"] = "C#"
for key, val := range language {
fmt.Printf("%v=>%v\n", key, val)
}
}
|
输出：这里就不贴了，结果会随机输出，因为map遍历出来结果是无序的，顺序不好控制，也不利于业务逻辑;当业务依赖key次序时，那么我们就需要引入“sort”包来解决随机化问题：
比如这样：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
|
package main
import (
"fmt"
"sort"
)
func main() {
language := make(map[string]string)
language["1"] = "Php"
language["2"] = "Go"
language["3"] = "Python3"
language["4"] = "C#"
sorted_keys := make([]string, 0)
for k, _ := range language {
sorted_keys = append(sorted_keys, k) // 提取键名
}
sort.Strings(sorted_keys) //
for _, k := range sorted_keys {
fmt.Printf("%v=>%v\n", k, language[k])
}
}
|
输出：
BASIC
1=>Php
2=>Go
3=>Python3
4=>C#
这样输出的结果运行多次也不会改变顺序。
Golang json序列化（struct，int，map，slice）
|
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
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
|
package main
import (
"encoding/json"
"fmt"
)
//把结构体都改小写
type User struct {
UserName string `json:"user_name"` //json的tag标记
Nickname string `json:"nickname"`
Age int
Birthday string
Sex string
Email string
Phone string
}
func testStruct() {
user1 := &User{
UserName: "超哥",
Nickname: "大头哥",
Age: 18,
Birthday: "2008/8/8",
Sex: "男",
Email: "mahuateng@qq.com",
Phone: "110",
}
//开始json序列化
data, err := json.Marshal(user1)
if err != nil {
fmt.Printf("json.marshal failed,err:", err)
return
}
fmt.Printf("%s\n", string(data))
}
func testInt() {
var a = 18
//开始json序列化
data, err := json.Marshal(a)
if err != nil {
fmt.Printf("json.marshal failed,err:", err)
return
}
fmt.Printf("%s\n", string(data))
}
func testMap() {
var m map[string]interface{} //声明map
m = make(map[string]interface{}) //必须初始化map分配内存
m["username"] = "user1"
m["age"] = 18
m["sex"] = "man"
fmt.Println(m)
data, err := json.Marshal(m)
if err != nil {
fmt.Printf("json.marshal failed,err:", err)
return
}
fmt.Printf("%s\n", string(data))
}
func testSlice() {
//定义一个slice，元素是map
var m map[string]interface{}
var s []map[string]interface{}
m = make(map[string]interface{})
m["username"] = "user1"
m["age"] = 18
m["sex"] = "man"
s = append(s, m)
m = make(map[string]interface{})
m["username"]="user2"
m["age"]=188
m["sex"]="male"
s=append(s,m)
data, err := json.Marshal(s)
if err != nil {
fmt.Printf("json.marshal failed,err:", err)
return
}
fmt.Printf("%s\n", string(data))
}
func main() {
testStruct() //结构体的序列化
testInt()//序列化数值
testMap()//序列化map
testSlice()//序列化切片
}
|
到此这篇关于Go遍历struct,map,slice的实现的文章就介绍到这了,更多相关Go遍历struct,map,slice内容请搜索服务器之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持服务器之家！
原文链接：https://www.cnblogs.com/phpper/p/14332578.html