电脑疯子技术论坛|电脑极客社区

微信扫一扫 分享朋友圈

已有 2522 人浏览分享

go结构体嵌套的切片数组操作

[复制链接]
2522 0
这篇文章主要介绍了go结构体嵌套的切片数组操作 具有很好的参考价值希望对大家有
所帮助一起跟随小编过来看看吧。


看代码吧~
  1. package main
  2. import (
  3. "fmt"
  4. )
  5. type XCDataStu struct {
  6. Id   int    `json:"id"   xorm:"id"`
  7. Name string `json:"name"  xorm:"name"`
  8. }
  9. type XCDataStu1 struct {
  10. Id             int    `json:"id" xorm:"id"`
  11. Str1           string `json:"str1" xorm:"str1"`
  12. Db1            string `json:"db1" xorm:"db1"`
  13. Device_type    string `json:"Device_type" xorm:"Device_type"`
  14. DeviceTypeName string `json:"DeviceTypeName"`
  15. }
  16. type XCDataStuAll struct {//结构体嵌套
  17. XCDataStuinall  XCDataStu
  18. XCDataStu1inall XCDataStu1
  19. }
  20. func main() {
  21. /*1*/
  22. xcData := []XCDataStu{
  23.   XCDataStu{Id: 758, Name: "David758"},
  24.   XCDataStu{Id: 759, Name: "David759"},
  25. }
  26. /*2*/
  27. xcdataall := make([]XCDataStuAll, len(xcData))
  28. /*xcdataall[0]={ XCDataStu{Id: 758, Name: "David758"},
  29. XCDataStu1{Id: 0, Str1: "dsa", Db1: "dsa",
  30.   Device_type: "fhls", DeviceTypeName: "dasf"}}*/
  31. fmt.Println(len(xcData))
  32. fmt.Println(xcData[0])
  33. fmt.Println(xcData[1])
  34. i := 0
  35. for ; i < 2; i++ {
  36.   xcdataall[i].XCDataStuinall.Id = xcData[i].Id
  37.   xcdataall[i].XCDataStuinall.Name = xcData[i].Name
  38. }
  39. fmt.Println(xcdataall)
  40. }
复制代码

结构体切片:

可以直接声明时初始化 如程序中的1
可以用make 但是必须给定长度 否则不能使用下标进行赋值。
如程序中的2
  1. var xcdataall []XCDataStuAll
  2. for ; i < 2; i++ {
  3. xcdataall[i].XCDataStuinall.Id = xcData[i].Id
  4. xcdataall[i].XCDataStuinall.Name = xcData[i].Name
  5. }
复制代码

程序编译没错 但是最后运行后会出现panic。。。
panic: runtime error: index out of range

补充:go遍历结构体(struct)字段对应的值,切片(slice),字典(map)

一、遍历结构体字段:

eg1:
  1. package main
  2. import (
  3.     "fmt"
  4.     "reflect"
  5. )
  6. type person struct {
  7.     name string
  8.     age  int
  9. }
  10. func main() {
  11.     v := reflect.ValueOf(person{"steve", 30})
  12.     count := v.NumField()
  13.     for i := 0; i < count; i++ {
  14.         f := v.Field(i)
  15.         switch f.Kind() {
  16.         case reflect.String:
  17.             fmt.Println(f.String())
  18.         case reflect.Int:
  19.             fmt.Println(f.Int())
  20.         }
  21.     }
  22. }
复制代码

输出结果:
steve

30

eg2:
  1. package main
  2. import (
  3.     "fmt"
  4.     "reflect"
  5. )
  6. type NotknownType struct {
  7.     s1, s2, s3 string
  8. }
  9. var secret interface{} = NotknownType{"Ada", "Go", "Oberon"}
  10. func main() {
  11.     value := reflect.ValueOf(secret)
  12.     for i := 0; i < value.NumField(); i++ {
  13.         fmt.Printf("Field %d: %v\n", i, value.Field(i))
  14.     }
  15. }
复制代码

输出结果:
Field 0: Ada
Field 1: Go
Field 2: Oberon

二、遍历切片:

for range 结构
  1. package main
  2. import (
  3.     "fmt"
  4. )
  5. func main(){
  6.     slice := []string{"hello","world","hello","everyone!"}
  7.     for k,val:=range slice{
  8.         fmt.Printf("slice %d is :%s\n",k,val )
  9.     }
  10. }
复制代码

输出结果:
  1. slice 0 is :hello
  2. slice 1 is :world
  3. slice 2 is :hello
  4. slice 3 is :everyone!
复制代码

三、遍历map:
  1. package main
  2. import (
  3.     "fmt"
  4. )
  5. func main() {
  6.     m := make(map[string]string)
  7.     m["1"] = "hello"
  8.     m["2"] = "world"
  9.     m["3"] = "go"
  10.     m["4"] = "is"
  11.     m["5"] = "cool"
  12.     fmt.Printf("The corresponding relationship between key and value is:\n")
  13.     for key, val := range m {
  14.         fmt.Printf("%v===>%v\n", key, val)
  15.     }
  16. }
复制代码

输出结果:
The corresponding relationship between key and value is:
1===>hello
2===>world
3===>go
4===>is
5===>cool

但是还有一个问题 上面的程序不做改动运行第二次 结果顺序就会改变 因为map遍历出来结果是无序的这不
好控制 也不利于业务逻辑;当业务依赖key次序时 需要引入“sort”包来解决随机化问题。

代码如下:
  1. package main
  2. import (
  3.     "fmt"
  4.     "sort"
  5. )
  6. func main() {
  7.     m := make(map[string]string)
  8.     m["1"] = "hello"
  9.     m["2"] = "world"
  10.     m["3"] = "go"
  11.     m["4"] = "is"
  12.     m["5"] = "cool"
  13.     sorted_keys := make([]string, 0)
  14.     for k, _ := range m {
  15.         sorted_keys = append(sorted_keys, k)
  16.     }
  17.     sort.Strings(sorted_keys)
  18.     for _, k := range sorted_keys {
  19.         fmt.Printf("%v=====>%v\n", k, m[k])
  20.     }
  21. }
复制代码

输出结果是:
1=====>hello
2=====>world
3=====>go
4=====>is
5=====>cool

注意:

输出的结果运行多次不会改变顺序。

但是key的先后顺序是按照字母或者数字排列的。

以上为个人经验 希望能给大家一个参考。

您需要登录后才可以回帖 登录 | 注册

本版积分规则

1

关注

0

粉丝

9021

主题
精彩推荐
热门资讯
网友晒图
图文推荐

Powered by Pcgho! X3.4

© 2008-2022 Pcgho Inc.