August Rush

一个还在努力成长的小火汁！

游龙当归海，海不迎我自来也。

We create our own demons.

You can reach me at augustrush0923@gmail.com
Go语言基础-结构体
发布：2021年02月20日 | 作者：augustrush | 阅读量: 1115

类型别名和自定义类型

自定义类型

在Go语言中有一些基本的数据类型，如string、整型、浮点型、布尔等数据类型，Go语言中可以使用type关键字来定义自定义类型。

自定义类型是定义了一个全新的类型。我们可以基于内置的基本类型定义，也可以通过struct定义。

例如：

type MyInt int // 将MyInt定义为int类型

var a MyInt = 10

fmt.Printf("%v  %T\n", a, a)

// 输出结果：10 main.MyInt

通过type关键字的定义，MyInt就是一种新的类型，它具有int的特性。

类型别名

类型别名规定：TypeAlias只是Type的别名，本质上TypeAlias与Type是同一个类型。

type TypeAlias = Type

例如：

type myInt = int

var a myInt = 10
fmt.Println("%v  %T", 10 ,int)


结构体

什么是结构体

结构体（struct）是用户自定义的类型，它代表若干字段的集合。有些时候将多个数据看做一个整体要比单独使用这些数据更有意义，这种情况下就适合使用结构体。

结构体是一个复合类型，用于表示一组数据。

结构体由一系列属性组成，每个属性都有自己的类型和值。

// 定义
type Person struct {
    name  string
    age   int 
    emial string
}

// 初始化
var p1 = Person{"August", 18, "august@gmail.com"}

// 结构体中取值
fmt.Println(p1.name, p1.age, p1.email)

结构体的定义

type 结构体名称 struct {
    字段名 字段类型
    字段名 字段类型
     ...    ...
}

其中：

  • 结构体名称：标识自定义结构体的名称，在同一个包内不能重复。
  • 字段名：标识结构体字段名。结构体中的字段名称必须唯一。
  • 字段类型：标识结构体字段的具体类型。
type Person struct {
    name string
    age int
    email string
}

同样类型的字段也可以写在一行，

type Person struct {
    name, email string
    age        int
}

结构体的嵌套

type Address struct {
    city, state string
}

type Person struct {
    name    string
    age     int
    address Address  // 如果使用匿名字段时， 就相当于是Address Address
}

结构体的初始化

只有当结构体实例化时，才会真正地分配内存。也就是必须实例化后才能使用结构体的字段。

结构体本身也是一种类型，我们可以像声明内置类型一样使用var关键字声明结构体类型。

var 结构体实例 结构体类型

var person Person

基本初始化

// 定义一个结构体（类型），每个结构体包含name，age，hobby 三个元素
type Person struct {
    name  string
    age   int
    hobby []string
}

方式一：先后顺序

var p1 = Person{"August", 18, []string{"篮球", "打游戏"}}

fmt.Println(p1.name, p1.age, p1.hobby)

方式二：关键字

var p2 = Person{name: "August", age: 18, hobby:[]string{"basketball", "computer game"}}

fmt.Println(p1.name, p1.age, p1.hobby)

方式三： 先声明再赋值

var p3 Person

p3.name = "August"
p3.age = 18
p3.hobby = []string{"woman", "dating"}

嵌套结构体初始化

type Address struct {
    city, state string
}

type Person struct {
    name    string
    age     int
    address Address
}

方式一：先后顺序

var p1 = Person{"August", 18, Address{"Beijing", "China"}}

fmt.Println(p1.name, p1.age, p1.address.city, p1.address.state)

方式二：关键字

var p2 = Person{name: "August", age: 18, address: Address{city: "Beijing", state: "China"}}

fmt.Println(p2.name, p2.age, p2.address.city, p2.address.state)

方式三： 先声明再赋值

var p3 Person

p3.name = "August"
p3.age = 18
p3.address = Address{"Beijing", "China"}

fmt.Println(p3.name, p3.age, p3.address.city, p3.address.state)

结构体指针

结构体指针的创建

可以通过new关键字对结构体进行实例化，得到的是结构体的地址。格式如下：

// var p *Person = new(Person)
var p = new(Person)


fmt.Printf("%T\n", p2)     //*main.person
fmt.Printf("p2=%#v\n", p2) //p2=&main.person{name:"", city:"", age:0}

Go语言中支持对结构体指针直接使用.来访问结构体的成员。

var p2 = new(person)
p2.name = "小王八"
p2.age = 18
p2.city = "北京"
fmt.Printf("p2=%#v\n", p2) //p2=&main.person{name:"小王八", city:"北京", age:18}


结构体赋值

赋值拷贝

type Person struct {
    name string
    age  int
}

p1 := Person{"武沛齐", 18}
p2 := p1

fmt.Println(p1) // {武沛齐, 18}
fmt.Println(p2) // {武沛齐, 18}

p1.name = "alex"

fmt.Println(p1) // {alex, 18}
fmt.Println(p2) // {武沛齐, 18}

结构体指针赋值

type Person struct {
    name string
    age  int
}

p1 := &Person{"武沛齐", 18}
p2 := p1

fmt.Println(p1) // {武沛齐, 18}
fmt.Println(p2) // {武沛齐, 18}

p1.name = "alex"

fmt.Println(p1) // {alex, 18}
fmt.Println(p2) // {alex, 18}

嵌套赋值拷贝

在存在结构体嵌套时，赋值会拷贝一份所有的数据。

type Address struct {
    city, state string
}

type Person struct {
    name    string
    age     int
    address Address
}

p1 := Person{"August", 18, Address{"Beijing", "China"}}
p2 := p1

fmt.Println(p1.address) // {Beijing, China}
fmt.Println(p2.address) // {Beijing, China}

p1.address.city = "Shanghai"

fmt.Println(p1.address) // {Shanghai, China}
fmt.Println(p2.address) // {Beijing, China}

其中数据本质上都拷贝了，只不过由于数据存储方式的不同，导致拷贝的有些是数据，有些是内存地址（指针）。

  • 拷贝的：字符串、数组、整型等。
  • 不拷贝的：map、切片。
type Address struct {
    city, state string
}

type Person struct {
    name    string
    age     int
    hobby   [2]string
    num     []int
    parent  map[string]string
    address Address
}

func main {
    p1 := Person{
        name:    "明里紬",
        age:     22,
        hobby:   [2]string{"做爱", "拍AV"},
        num:     []int{1, 2, 3, 4, 5},
        parent:  map[string]string{"dad": "baba", "mom": "mama"},
        address: Address{city: "Tokyo", state: "Japan"},
    }
    p2 := p1

    p1.hobby[0] = "做饭"
    p1.num[0] = 10
    p1.parent["dad"] = "殴斗桑"
    p1.parent["mom"] = "欧卡桑"
    p1.address.city = "东京"
    p1.address.state = "日本"

    fmt.Println(p1) //{明里紬 22 [做饭 拍AV] [10 2 3 4 5] map[dad:殴斗桑 mom:欧卡桑] {东京 日本}}
    fmt.Println(p2) //{明里紬 22 [做爱 拍AV] [10 2 3 4 5] map[dad:殴斗桑 mom:欧卡桑] {Tokyo Japan}}
}

map和切片之所以看似没有拷贝其实是假象。在Go语言中，结构体中的数据赋值给另一个变量时都会把所有数据拷贝一份再把新拷贝的值赋值给新的变量。map和切片也其实也拷贝了一份。但map和切边底层存储的是一个指针变量，真正的地址存储在另一个地址内。所以拷贝的只是一个指针变量。


结构体的匿名字段

结构体允许其成员字段在声明时没有字段名而只有类型，这种没有名字的字段就称为匿名字段。

// 匿名字段
type Class struct {
    string
    int
}

func main() {
    c1 := Class{"茶啊二中", 1}
    fmt.Printf("%#v\n", c1)  // main.Class{string:"茶啊二中", int:1}
    fmt.Println(c1.string, c1.int) // 茶啊二中 1
}

匿名字段默认采用类型名作为字段名，结构体要求字段名称必须唯一，因此一个结构体中同种类型的匿名字段只能有一个。


嵌套结构体

一个结构体中可以嵌套包含另一个结构体或结构体指针。

// 结构体的嵌套
type Address struct {
    Province, City string
}

//User 用户结构体
type User struct {
    Name    string
    Gender  string
    Address Address
}

func main() {
    user1 := User{
        Name:   "Graecia",
        Gender: "女",
        Address: Address{
            Province: "黑龙江",
            City:     "哈尔滨",
        },
    }
    fmt.Printf("user1=%#v\n", user1) // user1=main.User{Name:"Graecia", Gender:"女", Address:main.Address{Province:"黑龙江", City:"哈尔滨"}}

}


嵌套匿名结构体

//Address 地址结构体
type Address struct {
    Province string
    City     string
}

//User 用户结构体
type User struct {
    Name    string
    Gender  string
    Address //匿名结构体
}

func main() {
    var user2 User
    user2.Name = "Graecia"
    user2.Gender = "女"
    user2.Address.Province = "黑龙江"    //通过匿名结构体.字段名访问
    user2.City = "哈尔滨"                //直接访问匿名结构体的字段名
    fmt.Printf("user2=%#v\n", user2) //user2=main.User{Name:"Graecia", Gender:"女", Address:main.Address{Province:"黑龙江", City:"哈尔滨"}}
}

当访问结构体成员时会先在结构体中查找该字段，找不到再去匿名结构体中查找。

嵌套结构体的字段名冲突

嵌套结构体内部可能存在相同的字段名。这个时候为了避免歧义需要指定具体的内嵌结构体的字段。

//Address 地址结构体
type Address struct {
    Province   string
    City       string
    CreateTime string
}

//Email 邮箱结构体
type Email struct {
    Account    string
    CreateTime string
}

//User 用户结构体
type User struct {
    Name   string
    Gender string
    Address
    Email
}

func main() {
    var user3 User
    user3.Name = "Graecia"
    user3.Gender = "女"
    // user3.CreateTime = "2019" //ambiguous selector user3.CreateTime
    user3.Address.CreateTime = "2000" //指定Address结构体中的CreateTime
    user3.Email.CreateTime = "2000"   //指定Email结构体中的CreateTime
}


结构体标签

Tag是结构体的元信息，可以在运行的时候通过反射的机制读取出来。

Tag在结构体字段的后方定义，由一对反引号包裹起来，具体的格式如下：

`key:"value"`

结构体标签由一个或多个键值对组成。键与值使用冒号分隔，值用双引号括起来。键值对之间使用一个空格分隔。

注意事项： 为结构体编写Tag时，必须严格遵守键值对的规则。结构体标签的解析代码的容错能力很差，一旦格式写错，编译和运行时都不会提示任何错误，通过反射也无法正确取值。例如不要在key和value之间添加空格。


结构体与Json序列化

在Go语言中，通过json包的Marshal和Unmarshal来序列化和反序列化

//Student 学生
type Student struct {
    ID     int
    Gender string
    Name   string
}

//Class 班级
type Class struct {
    Title    string
    Students []*Student
}

func main() {
    c := &Class{
        Title:    "101",
        Students: make([]*Student, 0, 200),
    }
    for i := 0; i < 10; i++ {
        stu := &Student{
            Name:   fmt.Sprintf("stu%02d", i),
            Gender: "男",
            ID:     i,
        }
        c.Students = append(c.Students, stu)
    }
    //JSON序列化：结构体-->JSON格式的字符串
    data, err := json.Marshal(c)
    if err != nil {
        fmt.Println("json marshal failed")
        return
    }
    fmt.Printf("json:%s\n", data)
    //JSON反序列化：JSON格式的字符串-->结构体
    str := `{"Title":"101","Students":[{"ID":0,"Gender":"男","Name":"stu00"},{"ID":1,"Gender":"男","Name":"stu01"},{"ID":2,"Gender":"男","Name":"stu02"},{"ID":3,"Gender":"男","Name":"stu03"},{"ID":4,"Gender":"男","Name":"stu04"},{"ID":5,"Gender":"男","Name":"stu05"},{"ID":6,"Gender":"男","Name":"stu06"},{"ID":7,"Gender":"男","Name":"stu07"},{"ID":8,"Gender":"男","Name":"stu08"},{"ID":9,"Gender":"男","Name":"stu09"}]}`
    c1 := &Class{}
    err = json.Unmarshal([]byte(str), c1)
    if err != nil {
        fmt.Println("json unmarshal failed!")
        return
    }
    fmt.Printf("%#v\n", c1)
}
上一篇:Go语言基础-函数 下一篇:Go语言基础-接口


  • 标签云

  • 支付宝扫码支持一下

  • 微信扫码支持一下


基于Nginx+Supervisord+uWSGI+Django1.11.1+Python3.6.5构建

京ICP备20007446号-1 & 豫公网安备 41100202000460号

网站地图 & RSS | Feed