Golang 结构体

2024-01-07 20:23:07

前言

在 Go 语言中,结构体(struct)是一种自定义的数据类型,将多个不同类型的字段(fields)组合在一起
结构体通常用于模拟真实世界对象的属性和行为

定义结构体

可以使用 type 关键字和 struct 关键字来定义一个结构体:

type Person struct {
    Name string
    Age  int
}

在这个示例中,我们定义了一个名为 Person 的结构体,它有两个字段:Name 是 string 类型,Age 是 int 类型

常见的还有匿名结构体,看例子就明白了:

stu := struct{ name string }{"Allen"}
fmt.Println(stu.name) // Allen

实例化

创建结构体的实例(或对象)的过程称为实例化,可以通过结构体类型声明新的变量:

func main() {
    // 实例化结构体
    p := Person{Name: "Alice", Age: 30}

    // 访问结构体字段
    fmt.Println(p.Name) // 输出 "Alice"
    fmt.Println(p.Age)  // 输出 30
}

在这个示例中,p 是 Person 类型的变量,我们使用结构体字面量来初始化它的字段

结构体指针

可以使用 & 符号创建指向结构体的指针。通过指针,可以访问或修改结构体的字段:

func main() {
    // 创建指向 Person 结构体的指针
    p := &Person{Name: "Bob", Age: 25}

    // 通过指针访问结构体的字段
    fmt.Println(p.Name) // 输出 "Bob"
    fmt.Println(p.Age)  // 输出 25

    // 通过指针修改结构体的字段
    p.Age = 26
    fmt.Println(p.Age)  // 输出 26
}

p 是一个指向 Person 结构体的指针。即使我们使用了指针,我们仍然可以使用点操作符(.)来访问或修改字段,这是因为 Go 语言提供了指针的隐式解引用

结构体指针,它们用于直接访问或修改结构体实例的字段和方法,而不是通过副本。这在以下情况中很有用:

  • 当你需要在方法或函数中修改结构体的字段时
  • 当结构体很大,传递指针比复制整个结构体更高效时
  • 当你希望确保结构体的所有实例共享相同的数据时,例如,当多个变量需要指向同一个结构体实例以便可以同步状态变化

结构体方法

可以为结构体定义方法。方法是一种附加到特定类型(如结构体)的函数。方法的定义与普通函数类似,但它在函数名称之前有一个额外的参数,称为接收器(receiver),它指定了方法所附加的类型

func (p Person) SayHello() {
    fmt.Printf("Hi, my name is %s and I am %d years old.\n", p.Name, p.Age)
}

func main() {
    p := Person{Name: "Eve", Age: 22}
    p.SayHello() // 输出 "Hi, my name is Eve and I am 22 years old."
}

我们为 Person 结构体定义了一个 SayHello 方法,该方法可以通过 Person 类型的任何实例来调用

结构体字段标签

结构体字段可以通过字段标签(field tags)提供元数据。这些标签可以被用于多种用途,例如序列化和反序列化 JSON 数据、配置数据库字段映射以及进行验证等

字段标签是在结构体字段声明后以字符串形式提供的,并且总是放在反引号 (`) 之间。一个字段可以有多个标签,每个标签通常由一个特定的库或框架解析

下面是一个 JSON 序列化的例子,我们定义了一个结构体并使用了 JSON 标签:

type Person struct {
    Name string `json:"name"`
    Age  int    `json:"age"`
    City string `json:"city,omitempty"`
}

在这个例子中,Person 结构体有三个字段:Name、Age 和 City。每个字段后面都跟有一个 JSON 标签。这些标签指示 encoding/json 标准库如何序列化和反序列化结构体到 JSON 格式

  • json:“name” 表明 JSON 对象中对应的键是 name
  • json:“age” 表明 JSON 对象中对应的键是 age
  • json:“city,omitempty” 表明 JSON 对象中对应的键是 city,并且如果 City 字段的值为零值(在这里是空字符串),则在序列化的 JSON 对象中省略该键

使用标准库的 encoding/json 包来序列化结构体时,这些标签就会发挥作用:

func main() {
    p := Person{Name: "Alice", Age: 30, City: "Wonderland"}
    jsonData, _ := json.Marshal(p)
    fmt.Println(string(jsonData)) // 输出: {"name":"Alice","age":30,"city":"Wonderland"}

    p = Person{Name: "Bob", Age: 25}
    jsonData, _ = json.Marshal(p)
    fmt.Println(string(jsonData)) // 输出: {"name":"Bob","age":25} 注意没有 city 字段
}

在这个序列化的例子中,omitempty 选项导致 City 字段在 Bob 的情况下被省略,因为它是空字符串

继承

是通过组合(composition)来实现的,而不是像在其他一些面向对象编程语言中那样直接使用继承关键字。Go 的设计哲学鼓励组合而不是继承,这意味着一个结构体可以包含(嵌入)另一个结构体的字段,从而能够使用嵌入结构体的方法和字段,实现类似继承的行为

这是一个使用结构体组合来实现继承行为的例子:

type Animal struct {
    Name string
}

func (a *Animal) Speak() {
    fmt.Println(a.Name + " makes a noise.")
}

type Dog struct {
    Animal // 嵌入 Animal 结构体
}

func (d *Dog) Speak() {
    fmt.Println(d.Name + " barks.")
}

func main() {
    dog := Dog{}
    dog.Name = "Fido"
    dog.Speak() // 输出: Fido barks.
}

在这里,Animal 是一个基本的结构体,有一个 Speak 方法。Dog 结构体通过嵌入 Animal 继承了它的字段和方法。然而,Dog 也定义了它自己的 Speak 方法,这展示了 Go 中的方法覆盖(类似于其他语言中的重写)

自定义类型

可以通过类型声明(type declaration)来定义一个新的自定义类型。自定义类型基于现有的类型,但它有自己的独立名称和方法,这可以使代码更加清晰和类型安全

以下是创建自定义类型的基本语法:

type MyCustomType ExistingType

MyCustomType 是新定义的类型名称,而 ExistingType 是已有的类型,可以是内置类型,如 int、string 等,也可以是复杂类型,如结构体、接口等

下面是几个自定义类型的例子:

  1. 基于内置类型的自定义类型:
// 定义一个基于 int 的自定义类型
type MyInt int

func main() {
    var x MyInt = 5
    fmt.Println(x) // 输出: 5
}
  1. 基于结构体的自定义类型:
// 定义一个结构体
type Person struct {
    Name string
    Age  int
}

// 基于结构体的自定义类型
type Employee Person

func main() {
    e := Employee{Name: "John", Age: 30}
    fmt.Println(e) // 输出: {John 30}
}
  1. 为自定义类型添加方法:
// 基于 float64 的自定义类型
type Distance float64

// 为 Distance 类型定义一个方法
func (d Distance) String() string {
    return fmt.Sprintf("%f meters", d)
}

func main() {
    var d Distance = 5.5
    fmt.Println(d.String()) // 输出: 5.500000 meters
}

定义自定义类型允许你在类型上附加方法,使其表现得更像面向对象编程中的类。此外,自定义类型通过类型名称来提供更多上下文,这有助于代码的可读性和维护性

关于类型别名(从 Go 1.9 版本开始支持类型别名)
类型别名在 Go 语言中是通过使用 = 符号在类型定义中引入的。它们在语义上与原始类型相同,而不是创建一个新的类型。类型别名主要用于代码重构,允许开发者逐步更改类型的名称而不破坏现有的代码

这是一个类型别名的示例:

package main

import "fmt"

// 定义一个新的类型
type MyOriginalInt int

// 创建 MyOriginalInt 的别名
type MyIntAlias = MyOriginalInt

func main() {
    var a MyOriginalInt = 6
    var b MyIntAlias = a // 因为是别名,所以这是合法的,其实就是 var b = a

    fmt.Println(a, b) // 输出: 6 6
}

MyIntAlias 是 MyOriginalInt 的别名,所以它们可以互换使用。这意味着 MyIntAlias 的变量可以被视为 MyOriginalInt 类型的变量,反之亦然

类型别名的一个重要用途是在进行大规模重构时,特别是在为类型进行重命名时,它可以帮助保持代码库的向后兼容性。例如,如果一个库的公共类型名称需要更改,可以使用类型别名保持与旧代码的兼容性,同时推进新名称的使用

文章来源:https://blog.csdn.net/e5pool/article/details/135434976
本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。