Go语言结构体

Go 语言中数组能够存储同一类型的数据，但在结构体中咱们能够为不一样项定义不一样的数据类型。

结构体是由一系列具备相同类型或不一样类型的数据构成的数据集合。

struct 特色

一、用来自定义复杂数据结构
二、struct里面能够包含一个或多个字段（属性）
三、struct类型能够定义方法，注意和函数的区分
四、struct类型是值类型
五、struct类型能够嵌套
六、结构体是用户单独定义的类型，不能和其余类型进行强制转换
七、Go中的struct没有构造函数，通常可使用工厂模式来解决这个问题
八、咱们能够为struct中的每一个字段，写上一个tag。这个tag能够经过反射的机制获取到，最经常使用的场景就是json序列化和反序列化
九、访问结构体成员, 用 "." 来链接，格式为："结构体.成员名"

struct 定义

可用 type 在全局或函数内定义新类型。
第一种，定义一个新的数据类型，结构体中只有一个成员。

type bigint int64
type smallint int8

新类型不是原类型的别名，除拥有相

type oldboy struct {
    Linux  string
    Python string
    Golang string
}

第三种，定义一个新的数据类型，指向结构体的指针。

同数据存储结构外，它们之间没有任何关系，不会持有原类型任何信息。除非目标类型是未命名类型，不然必须显式转换。

第二种，定义一个新的数据类型，结构体中有多个成员。

type Linux string

type oldboy struct {
    *Linux
}

不能同时嵌入某一类型和其指针类型，由于它们名字相同。实例以下：

package main

type Linux string

type oldboy struct {
    *Linux
    Linux
}

func main() {

}

编译错误：

./main.go:7:2: duplicate field Linux

struct 初始化

有序初始化: 结构体中的多个成员的值，必须一一对应。
无序初始化: 结构体中的多个成员的值，无须一一对应，可初始化部分值。

package main

type oldboy struct {
    Linux  string
    Python string
    Golang string
}

// 有序初始化
var ordered = oldboy{"linux", "python", "golang"}

// 无序初始化
var disordered = oldboy{Golang: "golang"}

func main() {
}

结构体初始化方法有以下几种：

package main

import (
    "fmt"
)

type oldboy struct {
    int
    string
}

var one oldboy

func main() {
    two := new(oldboy) //同 var two *oldboy = new(oldboy)
    three := oldboy{1, "three"}
    four := oldboy{}
    five := &oldboy{}
    six := &oldboy{2, "six"} //同 var six *oldboy = &oldboy{2, "six"}

    fmt.Println(one, two, three, four, five, six)
}

one three four 返回 oldboy 类型变量；two five six 返回 *oldboy 类型变量；若无初始化值，则默认为零值。

匿名字段

定义一个struct，定义的时候是字段名与其类型一一对应，实际上Go语言支持只提供类型，而不写字段名的方式，也就是匿名字段，或称为嵌入字段。

当匿名字段是一个struct的时候，那么这个struct所拥有的所有字段都被隐式地引入了当前定义的这个struct。

package main

import (
    "fmt"
)

type Person struct {
    name string
    age  int
    addr string
}

type Employee struct {
    Person //匿名字段
    salary int
    int           //用内置类型做为匿名字段
    addr   string //相似于重载
}

func main() {
    em1 := Employee{
        Person{"oldboy", 18, "北京"},
        10,
        100,
        "首都",
    }
    fmt.Println(em1)
    var em2 Person = em1.Person 
    fmt.Println(em2)
}

struct与tag应用

声明struct结构的时候，在属性的右侧用小米点括起来的内容叫标签（Tag），在转换成其它数据格式的时候，会使用其中特定的字段做为键值。例如转成json格式，实例以下：

package main

import (
    "encoding/json"
    "fmt"
)

type User struct {
    UserId   int
    UserName string
}
type UserTag struct {
    UserId   int    `json:"user_id" bson:"user_id"`
    UserName string `json:"user_name" bson:"user_name"`
}

func main() {
    user := &User{UserId: 1, UserName: "oldboy"}
    json_user, _ := json.Marshal(user)
    fmt.Printf("struct User echo : %v\n", string(json_user))

    user_tag := &UserTag{UserId: 1, UserName: "oldboy"}
    json_user_tag, _ := json.Marshal(user_tag)
    fmt.Printf("struct UserTag echo : %v\n", string(json_user_tag))
}

运行结果：

struct User echo : {"UserId":1,"UserName":"oldboy"}
struct UserTag echo : {"user_id":1,"user_name":"oldboy"}

标签是struct类型的组成部分：

package main

var user1 struct {
    UserId int `json:"user_id"`
}
var user2 struct {
    UserId int `bson:"user_id"`
}

func main() {
    user1 = user2
}

编译错误：

./main.go:11:8: cannot use user2 (type struct { UserId int "bson:\"user_id\"" }) as type struct { UserId int "json:\"user_id\"" } in assignment