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

本篇文章向大家介绍《go结构体嵌套的切片数组操作》，主要包括切片、数组、go结构体、嵌套，具有一定的参考价值，需要的朋友可以参考一下。

看代码吧~

package main
import (
 "fmt"
)
type XCDataStu struct {
 Id   int    `json:"id"   xorm:"id"`
 Name string `json:"name"  xorm:"name"`
}
type XCDataStu1 struct {
 Id             int    `json:"id" xorm:"id"`
 Str1           string `json:"str1" xorm:"str1"`
 Db1            string `json:"db1" xorm:"db1"`
 Device_type    string `json:"Device_type" xorm:"Device_type"`
 DeviceTypeName string `json:"DeviceTypeName"`
}
type XCDataStuAll struct {//结构体嵌套
 XCDataStuinall  XCDataStu
 XCDataStu1inall XCDataStu1
}
func main() {
/*1*/
 xcData := []XCDataStu{
  XCDataStu{Id: 758, Name: "David758"},
  XCDataStu{Id: 759, Name: "David759"},
 }
/*2*/
 xcdataall := make([]XCDataStuAll, len(xcData))
 /*xcdataall[0]={ XCDataStu{Id: 758, Name: "David758"},
 XCDataStu1{Id: 0, Str1: "dsa", Db1: "dsa",
  Device_type: "fhls", DeviceTypeName: "dasf"}}*/
 fmt.Println(len(xcData))
 fmt.Println(xcData[0])
 fmt.Println(xcData[1])
 i := 0
 for ; i 

<h2>结构体切片：</h2>
<p>可以直接声明时初始化，如程序中的1</p>
<p>可以用make，但是必须给定长度，否则不能使用下标进行赋值。</p>
<p>如程序中的2</p>

<pre class="brush:plain;">
 var xcdataall []XCDataStuAll
 for ; i 

<p>程序编译没错，但是最后运行后会出现panic。。。</p>
<blockquote>
<p>panic: runtime error: index out of range</p>
</blockquote>
<p><strong>补充：go遍历结构体(struct)字段对应的值,切片(slice),字典(map)</strong></p>
<h2>一、遍历结构体字段：</h2>
<p><strong>eg1:</strong></p>

<pre class="brush:plain;">
package main
import (
    "fmt"
    "reflect"
)
type person struct {
    name string
    age  int
}
func main() {
    v := reflect.ValueOf(person{"steve", 30})
    count := v.NumField()
    for i := 0; i 

<p>输出结果：</p>
<blockquote>
<p>steve</p>
<p>30</p>
</blockquote>
<p><strong>eg2:</strong></p>

<pre class="brush:plain;">
package main
import (
    "fmt"
    "reflect"
)
type NotknownType struct {
    s1, s2, s3 string
}
var secret interface{} = NotknownType{"Ada", "Go", "Oberon"}
func main() {
    value := reflect.ValueOf(secret)
    for i := 0; i 

<p>输出结果：</p>
<blockquote>
<p>Field 0: Ada</p>
<p>Field 1: Go</p>
<p>Field 2: Oberon</p>
</blockquote>
<h2>二、遍历切片：</h2>
<p><strong>for range 结构</strong></p>

<pre class="brush:plain;">
package main
import (
    "fmt"
)
func main(){
    slice := []string{"hello","world","hello","everyone!"}
    for k,val:=range slice{
        fmt.Printf("slice %d is :%s\n",k,val )
    }
}

输出结果：

slice 0 is :hello

slice 1 is :world

slice 2 is :hello

slice 3 is :everyone!

三、遍历map：

package main
import (
    "fmt"
)
func main() {
    m := make(map[string]string)
    m["1"] = "hello"
    m["2"] = "world"
    m["3"] = "go"
    m["4"] = "is"
    m["5"] = "cool"
    fmt.Printf("The corresponding relationship between key and value is:\n")
    for key, val := range m {
        fmt.Printf("%v===>%v\n", key, val)
    }
}

输出结果：

The corresponding relationship between key and value is:

1===>hello

2===>world

3===>go

4===>is

5===>cool

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

代码如下：

package main
import (
    "fmt"
    "sort"
)
func main() {
    m := make(map[string]string)
    m["1"] = "hello"
    m["2"] = "world"
    m["3"] = "go"
    m["4"] = "is"
    m["5"] = "cool"
    sorted_keys := make([]string, 0)
    for k, _ := range m {
        sorted_keys = append(sorted_keys, k)
    }
    sort.Strings(sorted_keys)
    for _, k := range sorted_keys {
        fmt.Printf("%v=====>%v\n", k, m[k])
    }
}

输出结果是：

1=====>hello

2=====>world

3=====>go

4=====>is

5=====>cool

注意：

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

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

以上为个人经验，希望能给大家一个参考，也希望大家多多支持golang学习网。如有错误或未考虑完全的地方，望不吝赐教。

终于介绍完啦！小伙伴们，这篇关于《go结构体嵌套的切片数组操作》的介绍应该让你收获多多了吧！欢迎大家收藏或分享给更多需要学习的朋友吧~golang学习网公众号也会发布Golang相关知识，快来关注吧！