『Go 语言学习专栏』-- 第四期

golang-learning-four.png

4.png

大家好，我是谢伟，是一名程序员。

本专栏的主旨是：梳理 Golang 知识，力求从初级水平提升至中级水平。

同时将一些符合人性的编程经验和好的编程方法，分享给大家。

希望对大家有帮助。

本节的主题是：结构体

0 引入

Golang 中用来表示单一的数据类型可以使用变量声明的方式：

比如：

var Number int
var Married bool
var Name string

同一数据类型的集合可以使用下面的变量声明方式：

var Infor map[string]string
var Names []string
var Number [10]int

如果需要表示不同的数据类型的集合那应该怎么处理?

结构体

结构体可以用来表示不同的数据类型的集合, 同时可以表示用户自定义类型。

定义及声明
- 按顺序初始化
- 按任意顺序初始化
- 字段赋值
- new 函数分配指针
标签
字段访问
方法：值传递和指针传递
函数和方法的区别
组合：内嵌结构体、内嵌匿名成员
格式化显示结构体

1. 定义及声明

type 和 struct 关键字构成结构体的声明。

在 Golang 中，结构体可以当做是一种数据类型。

所以可以这样这样操作：

type Name struct{}
var Infor Name

另外，结构体在 golang 中的作用又可以当做类。

所以又存在方法。

type Name struct {
}

func (n Name) ResponseNumber() int {
    return 1
}

调用结构体方法是使用点号.

func main() {
    var name Name
    name.ResponseNumber()
}

声明示例：

type Information struct {
    Name    string
    Age     int
    School  string
    Married bool
    Habits  []string
    Infor   map[string]string
}

func exampleInformationDeclare() {
    // one
    var (
        exampleInformationOne Information
        Infor                 map[string]string
    )
    Infor = make(map[string]string)
    Infor["key"] = "hello-world"
    exampleInformationOne = Information{
        "xiewei", 18, "shanghaiUniversity", true,
        []string{"1", "2", "3"}, Infor,
    }
    fmt.Println(exampleInformationOne, exampleInformationOne.Name)

    // two
    var exampleInformationTwo Information
    exampleInformationTwo.Name = "golang"
    exampleInformationTwo.School = "Google"
    exampleInformationTwo.Age = 10
    exampleInformationTwo.Infor = Infor

    fmt.Println(exampleInformationTwo, exampleInformationTwo.Married)

    // three
    var exampleInformationThree Information
    exampleInformationThree = Information{
        Name:    "Python",
        School:  "Gudio school",
        Age:     18,
        Habits:  []string{"1", "2"},
        Infor:   Infor,
        Married: true,
    }

    fmt.Println(exampleInformationThree, exampleInformationThree.School)

    // four

    var exampleInformationFour *Information
    exampleInformationFour = new(Information)
    exampleInformationFour.Name = "Java"

    fmt.Println(exampleInformationFour, exampleInformationFour.School)
}



func main() {
    exampleInformationDeclare()
}

2. 标签

这种带标签的结构体的定义，在转换为json格式的数据的时候会自动将对应的字段转换为标签中的字段：

比如：Name 转换为 name 字段。

标签字段不能在编程中实际使用。

比如：可以这样: InformationWithLabel.Name

不可以这样：InformationWithLabel.name

type InformationWithLabel struct {
    Name string `json:"name"`
    Age  int    `json:"age"`
}

3. 字段的访问

结构体内的是一系列相关字段的集合。如果定义了一个结构体如何访问?

可以使用点号获取结构体的字段。

比如：

type InformationWithLabel struct {
    Name string `json:"name"`
    Age  int    `json:"age"`
}

func exampleInformationWithLabelFiled() {
    var example InformationWithLabel
    example = InformationWithLabel{
        Name: "xiewei",
        Age:  18,
    }
    fmt.Println(example.Name, example.Age)
}

4. 方法

上文讲到在 golang 中结构体相当于面向对象中的类。

所以存在方法。

方法根据传入的参数的不同，又分为：值传递和指针传递。两者的效果就是：值传递不可改变值，指针传递可以改变值。

示例：

type Response struct {
    Code    int
    Result  []byte
    Headers map[string]string
}

func (r Response) GetAttrCode() int {
    return r.Code
}
func (r Response) GetAttrResult() []byte {
    return r.Result
}

func (r Response) GetAttrHeader() map[string]string {
    return r.Headers
}

func (r *Response) SetCode(code int) {
    r.Code = code
}

func (r *Response) SetHeaders(key, value string) {
    r.Headers[key] = value
}

func exampleResponse() {
    var (
        response Response
        headers  map[string]string
    )
    headers = make(map[string]string)
    headers["Server"] = "GitHub.com"
    headers["Status"] = "Ok"
    response.Headers = headers
    response.Code = 200
    response.Result = []byte("hello world")

    fmt.Println(response.GetAttrCode())
    fmt.Println(response.GetAttrHeader())
    fmt.Println(response.GetAttrResult())

    response.SetCode(404)
    fmt.Println(response)

    response.SetHeaders("Status", "failed")
    fmt.Println(response)
}


func main() {
    exampleResponse()
}


>>>

200
map[Server:GitHub.com Status:Ok]
[104 101 108 108 111 32 119 111 114 108 100]
{404 [104 101 108 108 111 32 119 111 114 108 100] map[Server:GitHub.com Status:Ok]}
{404 [104 101 108 108 111 32 119 111 114 108 100] map[Status:failed Server:GitHub.com]}

可以看出：

结构体的方法如何定义
值传递的适用于取值
指针传递适用于更改字段的值

同时方法和普通的函数的定义又有些许的不同。

5. 函数和方法的区别

Golang 中函数和方法存在区别。

先看示例：

func NormalFunc(arg int) int {
    return arg + 1
}


func (r *Response) SetCode(code int) {
    r.Code = code
}

Go 方法是作用在接收者（receiver）上的一个函数。接收者可以是几乎任何类型。

但一般选择结构体作为接收者。

6. 组合：

匿名字段

在 Golang 中可以通过结构体的组合实现类的继承。

即：将一个结构体A当成另一个结构体B的匿名字段，则这个结构体B自动拥有A的所有字段和方法。

type Response struct {
    Code    int
    Result  []byte
    Headers map[string]string
}

func (r Response) GetAttrCode() int {
    return r.Code
}
func (r Response) GetAttrResult() []byte {
    return r.Result
}

func (r Response) GetAttrHeader() map[string]string {
    return r.Headers
}

func (r *Response) SetCode(code int) {
    r.Code = code
}

func (r *Response) SetHeaders(key, value string) {
    r.Headers[key] = value
}

type Requests struct {
    Url    string
    Params string
}

type CollectionRequests struct {
    CollectionNumber int
    Requests
    Response
}

func exampleCollectionRequests() {

    var collectionRequests CollectionRequests
    collectionRequests.CollectionNumber = 10
    collectionRequests.Url = "https://www.example.com"
    collectionRequests.Params = "name"
    collectionRequests.Code = 201
    collectionRequests.Result = []byte("hello Golang")

    var headers map[string]string
    headers = make(map[string]string)
    headers["status"] = "Good"
    collectionRequests.Headers = headers
    fmt.Println(collectionRequests)
    
    fmt.Println(collectionRequests.GetAttrCode())
}

func main() {
    exampleCollectionRequests()
}

>>>

{10 {https://www.example.com name} {201 [104 101 108 108 111 32 71 111 108 97 110 103] map[status:Good]}}
201

上文CollectionRequests 拥有两个匿名字段Requests、Response ，则自动拥有这个两个结构体的字段和方法。

内嵌结构体

这个组合的形式会遇到两个问题：

字段相同怎么办？即结构体A 有字段 a, 结构体 B 也有字段 a。怎么处理？
方法相同怎么办？即结构体A 有方法 methodOne, 结构体 B 也有方法 methodOne。怎么处理？

应该尽量避免命名冲突。同时可以使用多个点号的方法访问字段。方法则优先使用结构体B 的。

type OtherRequests struct {
    Request Requests
    Resp    Response
    Code    int
}
func (o OtherRequests) GetAttrCode() {
    fmt.Println(fmt.Sprintf("Outer Code = %d", o.Code))
    fmt.Println(fmt.Sprintf("inner Code = %d", o.Resp.Code))
}
func exampleOtherRequests() {
    var other OtherRequests
    other.Code = 201
    other.Resp.Code = 202
    fmt.Println(other)
    other.GetAttrCode()
    fmt.Println(other.Resp.GetAttrCode())
}
func main() {
    exampleOtherRequests()
}


>>>
{{ } {202 [] map[]} 201}
Outer Code = 201
inner Code = 202
202

可以看出通过组合结构体的方式，可以实现类中的继承和多态。

7. 格式化显示结构体

为理解这一节，我们先看看 Python 中如何格式化显示Class

class Info(object):

    def __init__(self, name, age, school):
        self.Name = name
        self.Age = age
        self.School = school

    def __repr__(self):
        return "Name = {}, Age = {}, School = {} ".format(self.Name, self.Age, self.School)

    def __str__(self):
        return "Name = {}, Age = {}, School = {} ".format(self.Name, self.Age, self.School)

if __name__ == "__main__":
    A = Info("xieWei", 20, "shanghaiUniversity")
    print(A)

>>>

Name = xieWei, Age = 20, School = shanghaiUniversity

同样在 Golang 中只需要实现一个名为 String 的方法即可格式化显示结构体。

type OtherRequests struct {
    Request Requests
    Resp    Response
    Code    int
}

func (o OtherRequests) String() string {
    return fmt.Sprintf("Request = %v , Response = %v , Code = %d", o.Request, o.Resp, o.Code)
}

func exampleOtherRequests() {
    var other OtherRequests
    other.Code = 201
    other.Resp.Code = 202
    fmt.Println(other)
    other.GetAttrCode()
    fmt.Println(other.Resp.GetAttrCode())
}

func main() {

    exampleOtherRequests()
}

>>>
Request = { } , Response = {202 [] map[]} , Code = 201
Outer Code = 201
inner Code = 202
202

本节结束。希望有所启发，再会。