谈一谈Go的结构体struct的使用方法

系统管理员 2022-06-03 00:36 182阅读 0赞

定义结构体

package main
    
    import (
        "fmt"
    )
    
    type test struct {
    }
    
    func main() {
        a := test{}
        fmt.Println(a)
    }

输出：

\{\}

package main
    
    import (
        "fmt"
    )
    
    //定义一个person结构，类似于在PHP定义了一个person的class
    type Person struct {
        name string //默认零值为空字符串
        age  int    //默认零值为0
    }
    
    func main() {
        a := Person{}
        fmt.Println(a)
    }

输出：

\{ 0\}

访问结构体成员

package main
    
    import (
        "fmt"
    )
    
    //定义一个person结构，类似于在PHP定义了一个person的class
    type Person struct {
        name string //默认零值为空字符串
        age  int    //默认零值为0
    }
    
    func main() {
        a := Person{}
        //对Person进行属性操作，类似于javascript的操作
        a.name = "GO"
        a.age = 8
        fmt.Println(a)
    }

输出：

\{GO 8\}

字面量初始化

package main
    
    import (
        "fmt"
    )
    
    //定义一个person结构，类似于在PHP定义了一个person的class
    type Person struct {
        name string //默认零值为空字符串
        age  int    //默认零值为0
    }
    
    func main() {
        //也可以通过字面值进行初始化，这是常用的做法，写法类似于JSON的写法
        a := Person{
            name: "GO",
            age:  8} //注意，如果没有逗号，则}不能另起新行，否则会报错
        fmt.Println(a)
    }

输出：

\{GO 8\}

结构体作为参数传递

package main
    
    import (
        "fmt"
    )
    
    //定义一个person结构，类似于在PHP定义了一个person的class
    type person struct {
        name string //默认零值为空字符串
        age  int    //默认零值为0
    }
    
    func main() {
        //也可以通过字面值进行初始化，这是常用的做法，写法类似于JSON的写法 ，注意属性名不能加分号
        a := person{
            name: "GO",
            age:  8} //注意，如果没有逗号，则}不能另起新行，否则会报错
        fmt.Println("我在A前面输出", a)
        A(a) //A(&a)就是值传递，A函数应写成func A(per *person)
        fmt.Println("我在A后面输出", a)//很显然,A里面的赋值并没有改变a的值，证明结构是值类型，传值是值拷贝
    }
    
    //结构也是值类型，传值的时候也是值拷贝
    func A(per person) { //传递per参数，类型为person结构
        per.name = "PHP"
        fmt.Println("我在A里面输出", per)
    
    }

输出：

我在A前面输出 \{GO 8\}

我在A里面输出 \{PHP 8\}

我在A后面输出 \{GO 8\}

结构体指针

package main
    
    import (
        "fmt"
    )
    
    //定义一个person结构，类似于在PHP定义了一个person的class
    type person struct {
        name string //默认零值为空字符串
        age  int    //默认零值为0
    }
    
    func main() {
        //如何传递指针
        a := &person{ //变量初始化时，加&取地址
            name: "GO",
            age:  8} //注意，如果没有逗号，则}不能另起新行，否则会报错
        //当传地址的时候，想操作属性时，Go语言可以不需要加*，直接操作
        a.age = 9
        fmt.Println("我在A前面输出", a)
        A(a)
        fmt.Println("我在A后面输出", a) //很显然,A里面的赋值并没有改变a的值，证明结构是值类型，传值是值拷贝
    }
    
    //结构也是值类型，传值的时候也是值拷贝
    func A(per *person) { //此时为指针类型
        per.name = "PHP"
        fmt.Println("我在A里面输出", per)
    }

输出：

我在A前面输出 &\{GO 9\}

我在A里面输出 &\{PHP 9\}

我在A后面输出 &\{PHP 9\}

匿名结构体

package main
    
    import (
        "fmt"
    )
    
    //匿名结构
    func main() {
        a := &struct {
            name string
            age  int
        }{
            name: "PHP",
            age:  10,
        }
        fmt.Println(a) //很显然,A里面的赋值并没有改变a的值，证明结构是值类型，传值是值拷贝
    }

输出：

&\{PHP 10\}

结构体的嵌套

package main
    
    import (
        "fmt"
    )
    
    //结构嵌套
    type person struct {
        name    string
        age     int
        contact struct {
            phone, city string
        }
    }
    
    func main() {
        a := person{name: "GO", age: 8}
        a.contact.phone = "1112345678"
        a.contact.city = "福州"
        fmt.Println(a)
    }

输出：

\{GO 8 \{1112345678 福州\}\}

结构体匿名字段

package main
    
    import (
        "fmt"
    )
    
    //匿名字段
    type person struct {
        string
        int
    }
    
    func main() {
        a := person{"GO", 8} //注意这里的位置不能对调，应与声明的顺序一样
        fmt.Println(a)
    }

输出：

\{GO 8\}

结构体之间的比较(不同结构，没有可比性，会报错，哪怕属性值和属性都一样)

package main
    
    import (
        "fmt"
    )
    
    //匿名字段
    type person struct {
        string
        int
    }
    
    type person1 struct {
        string
        int
    }
    
    func main() {
        a := person{"GO", 8} //属性person结构
        b := person1{"GO", 8}//属于person1结构          
        fmt.Println(a == b)
    }

输出报错

.\\hello.go:21:16: invalid operation: a == b (mismatched types person and person1)

结构体之间的赋值

package main
    
    import (
        "fmt"
    )
    
    //匿名字段
    type person struct {
        string
        int
    }
    
    func main() {
        a := person{"GO", 8}
        b := a
        fmt.Println(a, b)
    }

输出：

\{GO 8\} \{GO 8\}

结构体之间的“继承“（注意：Go并没有面向对象语言的继承关系，如PHP）

输出：

\{ \{0\} PHP 15\} \{ \{0\} GO 8\}

嵌入结构体的使用方法

package main
    
    import (
        "fmt"
    )
    
    type human struct {
        sex int
    }
    
    type teacher struct {
        human
        name string
        age  int
    }
    
    type student struct {
        human
        name string
        age  int
    }
    
    func main() {
        a := teacher{name: "PHP", age: 15, human: human{sex: 0}} //嵌入结构作为匿名字段时，默认字段名就是嵌入的结果名
        b := student{name: "GO", age: 8, human: human{sex: 1}}
        fmt.Println(a, b)
    }

输出：

\{ \{0\} PHP 15\} \{ \{1\} GO 8\}

嵌入结构体如何修改相关属性

输出：  
\{ \{0\} PYTHON 15\} \{ \{0\} GO 8\}