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

 更新时间:2021年04月28日 12:01:01   作者:wake_alone  
这篇文章主要介绍了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 < 2; i++ {
  xcdataall[i].XCDataStuinall.Id = xcData[i].Id
  xcdataall[i].XCDataStuinall.Name = xcData[i].Name
 }
 fmt.Println(xcdataall)
}

结构体切片:

可以直接声明时初始化,如程序中的1

可以用make,但是必须给定长度,否则不能使用下标进行赋值。

如程序中的2

 var xcdataall []XCDataStuAll
 for ; i < 2; i++ {
  xcdataall[i].XCDataStuinall.Id = xcData[i].Id
  xcdataall[i].XCDataStuinall.Name = xcData[i].Name
 }

程序编译没错,但是最后运行后会出现panic。。。

panic: runtime error: index out of range

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

一、遍历结构体字段:

eg1:

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 < count; i++ {
        f := v.Field(i)
        switch f.Kind() {
        case reflect.String:
            fmt.Println(f.String())
        case reflect.Int:
            fmt.Println(f.Int())
        }
    }
}

输出结果:

steve

30

eg2:

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 < value.NumField(); i++ {
        fmt.Printf("Field %d: %v\n", i, value.Field(i))
    }
}

输出结果:

Field 0: Ada

Field 1: Go

Field 2: Oberon

二、遍历切片:

for range 结构

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的先后顺序是按照字母或者数字排列的。

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

相关文章

  • Go语言包管理工具Godep的用法

    Go语言包管理工具Godep的用法

    这篇文章介绍了Go语言包管理工具Godep的用法,对大家的学习或者工作具有一定的参考学习价值,需要的朋友们下面随着小编来一起学习学习吧
    2022-07-07
  • 深入理解GO语言的面向对象

    深入理解GO语言的面向对象

    相信很多人当初开发go语言的时候就是因为C++的特性太过于繁杂,从而使得很多C++的开发者因为C++的特性而头疼,go语言成功的精简了C++的特性,使其很简洁,很少的特性,却可以完成很多的事情。下面我们就来详细理解下GO语言的面向对象。
    2016-10-10
  • Golang项目搭配nginx部署反向代理负载均衡讲解

    Golang项目搭配nginx部署反向代理负载均衡讲解

    这篇文章主要为大家介绍了Golang项目搭配nginx部署正反向代理负载均衡讲解,有需要的朋友可以借鉴参考下,希望能够有所帮助,祝大家多多进步早日升职加薪
    2022-04-04
  • golang 对私有函数进行单元测试的实例

    golang 对私有函数进行单元测试的实例

    这篇文章主要介绍了golang 对私有函数进行单元测试的实例,具有很好的参考价值,希望对大家有所帮助。一起跟随小编过来看看吧
    2021-05-05
  • golang 实现两个结构体复制字段

    golang 实现两个结构体复制字段

    这篇文章主要介绍了golang 实现两个结构体复制字段,具有很好的参考价值,希望对大家有所帮助。一起跟随小编过来看看吧
    2021-04-04
  • GO实现协程池管理的方法

    GO实现协程池管理的方法

    这篇文章给大家介绍GO实现协程池管理的方法,分别使用channel实现协程池和消费者模式实现协程池,本文通过实例代码给大家介绍的非常详细,需要的朋友参考下吧
    2021-07-07
  • goFrame的队列gqueue对比channel使用详解

    goFrame的队列gqueue对比channel使用详解

    这篇文章主要为大家介绍了goFrame的gqueue对比channel使用详解,有需要的朋友可以借鉴参考下,希望能够有所帮助,祝大家多多进步,早日升职加薪
    2022-06-06
  • 深入理解Golang channel的应用

    深入理解Golang channel的应用

    channel是用于 goroutine 之间的同步、通信的数据结构。它为程序员提供了更高一层次的抽象,封装了更多的功能,这样并发编程变得更加容易和安全。本文通过示例为大家详细介绍了channel的应用,需要的可以参考一下
    2022-10-10
  • Go语言实现遍历文件夹

    Go语言实现遍历文件夹

    这篇文章主要为大家详细介绍了Go语言实现遍历文件夹的相关方法,文中的示例代码讲解详细,具有一定的参考价值,感兴趣的小伙伴可以了解一下
    2023-05-05
  • golang实现LRU缓存淘汰算法的示例代码

    golang实现LRU缓存淘汰算法的示例代码

    这篇文章主要介绍了golang实现LRU缓存淘汰算法的示例代码,小编觉得挺不错的,现在分享给大家,也给大家做个参考。一起跟随小编过来看看吧
    2018-12-12

最新评论