从零基础学Go(六)——Go的复杂数据结构(下)

嚯呀怪怪怪

于 2024-08-18 22:56:37 发布

阅读量505

点赞数 11

文章标签： golang 数据结构开发语言学习方法架构程序人生经验分享

本文链接：https://blog.csdn.net/m0_46580983/article/details/141307155

版权

前言📃

结构体

基本介绍

Go语言中的结构体（struct）是一种复合数据类型，它允许你将多个不同类型的数据项组合成一个单一的实体。结构体在Go中非常常用，用于创建具有多种字段的对象。结构体是Go中实现面向对象编程特性的一种方式，虽然Go本身并不支持传统意义上的类和继承，但通过接口和结构体的组合使用，可以实现类似的功能。

基本操作

定义结构体

使用type关键字和struct关键字来定义一个新的结构体类型。

type Person struct {
    Name string
    Age  int
}

匿名字段

结构体可以包含匿名字段，即字段前不加类型名，这通常用于嵌入其他结构体或类型。

type Address struct {
    Street string
    City   string
}

type Employee struct {
    Name  string
    Age   int
    Address // 匿名字段，可以访问Address的所有字段
}

指针和值接收

结构体可以作为值或指针来使用。当作为值使用时，每次函数调用都会复制整个结构体；当作为指针使用时，只会复制结构体的内存地址。

func (p *Person) Greet() {
    fmt.Println("Hello, my name is", p.Name)
}

方法

可以为结构体定义方法，这些方法可以访问结构体的字段。

func (p *Person) SetAge(age int) {
    p.Age = age
}

结构体字面量

可以创建结构体的字面量来初始化结构体变量。

person := Person{
    Name: "Alice",
    Age:  30,
}

结构体标签

结构体字段可以有标签，这些标签可以用于反射或其他用途。

type Example struct {
    Field string `json:"field"`
}

在Go语言中，反射是一种能力，允许程序在运行时检查和修改变量的类型和值。反射在Go中是通过reflect包提供的。使用反射，你可以：

获取类型信息：你可以使用反射来获取一个变量的类型信息，即使这个类型在编译时是未知的。
检查和修改值：反射允许你检查和修改一个变量的值，即使这个变量是私有的。
创建动态类型：你可以使用反射来创建一个动态类型，这意味着你可以在运行时定义新的类型。
实现泛型算法：反射使得编写能够处理不同数据类型的算法成为可能。

后续的文章我们将详细介绍反射的内容~

结构体和内存对齐

Go编译器会为结构体的字段进行内存对齐，以提高访问效率。

结构体是Go语言中实现面向对象编程特性的一种方式，尽管Go本身并不支持传统的面向对象概念，如类和继承。通过使用结构体和接口，Go提供了一种简洁而强大的方式，来组织和使用数据。

函数

基本介绍

在计算机编程中，函数是一种封装代码的方式，允许你定义一个可以在程序中多次调用的代码块。以下是函数的一些关键概念和特性：

封装性：函数将一段代码和它的操作封装在一起，使得代码更加模块化和易于管理。
参数：函数可以接收输入值，称为参数或形参。这些参数允许函数根据传入的数据执行不同的操作。
返回值：函数可以有一个或多个返回值，用于将结果传递回调用者。
作用域：函数有自己的作用域，这意味着在函数内部定义的变量在函数外部是不可见的。
可重用性：由于函数可以接收不同的参数并返回结果，它们可以被多次调用，执行相同的任务但针对不同的数据。
抽象：函数提供了一种抽象机制，允许开发者专注于使用函数而无需了解其内部实现细节。
递归：函数可以调用自身，这称为递归。递归是一种强大的编程技术，可以用于解决某些类型的问题，如树的遍历或分治算法。
可维护性：由于函数的封装性，修改函数的内部实现通常不会影响使用该函数的其他代码，这提高了代码的可维护性。
调试：函数使得调试更加容易，因为你可以单独测试和验证函数的行为，而不必考虑整个程序的上下文。
高阶函数：在某些编程语言中，函数可以作为参数传递给其他函数，或者作为其他函数的返回值，这称为高阶函数。
闭包：在支持闭包的编程语言中，函数可以捕获它们被创建时的作用域中的变量，即使这些变量是在函数外部定义的。
重载：一些编程语言支持函数重载，这意味着你可以定义多个同名函数，只要它们的参数列表不同。
默认参数：某些语言允许为函数参数指定默认值，如果调用时未提供这些参数，则使用默认值。
命名规范：函数命名通常遵循一定的规范，如驼峰命名法（camelCase）或下划线命名法（snake_case），以提高代码的可读性。
错误处理：在某些编程语言中，函数通过返回特定的错误值来处理错误情况，调用者需要检查这些错误并相应地处理。

函数是编程中的核心概念之一，几乎所有的编程语言都支持函数或类似的代码封装机制。通过使用函数，开发者可以编写更加清晰、高效和可维护的代码。

Go语言的函数是执行特定任务的代码块，可以接收参数，执行操作，并返回结果。以下是Go函数的一些关键特性：

基本操作

定义函数

使用func关键字定义函数，后跟函数名和参数列表。

func Add(x int, y int) int {
    return x + y
}

返回值

函数可以有零个或多个返回值。如果函数有多个返回值，它们可以一起被返回。

func MinAndMax(x, y int) (int, int) {
    if x < y {
        return x, y
    }
    return y, x
}

变长参数

函数可以接受任意数量的参数，通过使用省略号...来定义。

func Sum(nums ...int) int {
    sum := 0
    for _, num := range nums {
        sum += num
    }
    return sum
}

匿名函数

Go支持匿名函数，即没有函数名的函数，通常用于简短的函数定义或作为参数传递给其他函数

func main() {
    double := func(x int) int {
        return x * 2
    }
    fmt.Println(double(5)) // 输出：10
}

闭包

Go的匿名函数可以捕获并包含其外部作用域中的变量，形成闭包

func GenerateSequence() func() int {
    counter := 0
    return func() int {
        counter++
        return counter
    }
}

递归函数

函数可以调用自身，实现递归。

func Factorial(x int) int {
    if x == 0 {
        return 1
    }
    return x * Factorial(x-1)
}

高阶函数

Go的函数可以作为参数传递给其他函数，也可以作为返回值返回

func Apply(f func(int) int, x int) int {
    return f(x)
}

错误处理

Go使用内置的error类型来处理错误，通常作为函数的最后一个返回值。

func Divide(x, y int) (int, error) {
    if y == 0 {
        return 0, errors.New("division by zero")
    }
    return x / y, nil
}

方法

Go允许为用户定义的类型添加方法，方法类似于其他语言中的实例方法。

type Counter struct {
    count int
}

func (c *Counter) Increment() {
    c.count++
}

接口实现

函数可以作为接口的一部分实现，允许函数具有多态性。

type Stringer interface {
    String() string
}

func (c *Counter) String() string {
    return fmt.Sprintf("Count: %d", c.count)
}

接口

在Go语言中，接口（Interface）是一种抽象类型，它定义了一组方法。一个接口可能由任何类型实现，只要该类型提供了接口中声明的所有方法。Go接口是隐式的，不需要显式声明类型实现了接口，只要类型拥有接口中定义的所有方法即可。

基本介绍

接口的关键特性：

抽象性：接口只定义方法，不实现它们。
灵活性：任何类型只要实现了接口的方法，就自动实现了该接口。
多态性：接口允许你使用相同的代码操作不同类型的对象。
动态性：Go的接口是动态类型的，这意味着在运行时检查接口变量所持有的具体类型。
空接口：Go中有一个特殊的接口叫做interface{}，它没有任何方法，任何类型都实现了空接口。
类型断言：可以使用类型断言来检查接口变量中实际存储的类型，并转换为该类型。
值接收者和指针接收者：接口的方法可以有值接收者和指针接收者。使用指针接收者可以避免复制整个对象。
嵌入接口：一个接口可以嵌入到另一个接口中，继承其方法。
接口和并发：接口经常用于并发编程中，例如通道的实现。

接口的使用场景：

定义通用行为：当需要对不同类型的对象执行相同的操作时。
实现多态性：允许不同的对象对同一消息做出响应，但具体行为取决于对象的实际类型。
降低耦合度：接口使得模块间的依赖关系基于抽象而非具体实现。
实现适配器模式：允许使用现有的类通过一个接口与另一个模块协同工作。
错误处理：Go的error类型就是一个接口，它允许返回不同类型的错误。

package main

import "fmt"

// 定义一个接口，包含一个方法
type Animal interface {
    Speak() string
}

// 实现接口的两个具体类型
type Dog struct{}
type Cat struct{}

// 为Dog实现Speak方法
func (d Dog) Speak() string {
    return "Woof!"
}

// 为Cat实现Speak方法
func (c Cat) Speak() string {
    return "Meow!"
}

func main() {
    // 创建一个接口变量，存储实现了Animal接口的Dog类型
    dog := Dog{}
    fmt.Println(dog.Speak()) // 输出：Woof!

    // 创建一个接口变量，存储实现了Animal接口的Cat类型
    cat := Cat{}
    fmt.Println(cat.Speak()) // 输出：Meow!
    
    // 使用接口作为参数，实现多态性
    animals := []Animal{dog, cat}
    for _, animal := range animals {
        fmt.Println(animal.Speak())
    }

}

基本操作

接口的定义

接口可以包含任意数量的方法签名，但不允许包含任何实现。接口中的方法是隐式的，不需要显式声明。

type ExampleInterface interface {
   MethodOne()
   MethodTwo(arg1 int) string
}

实现接口

一个类型实现接口只需提供接口声明的所有方法的具体实现即可。

type ConcreteType struct{}

func (ct *ConcreteType) MethodOne() {
   // 实现细节
}

func (ct *ConcreteType) MethodTwo(arg1 int) string {
   // 实现细节
   return "返回值"
}

使用接口

接口变量可以用来存储任何实现了接口的类型的值。

var example ExampleInterface

// 实例化ConcreteType并赋值给接口变量
concrete := ConcreteType{}
example = &concrete // 注意：如果ConcreteType是结构体指针，需要使用指针

// 调用接口变量的方法
example.MethodOne()

类型断言

使用类型断言来检查接口变量中实际存储的类型，并转换为该类型。

if val, ok := interface{}(concrete).(*ConcreteType); ok {
   fmt.Println("类型断言成功", val)
} else {
   fmt.Println("类型断言失败")
}

空接口

空接口interface{}没有声明任何方法，因此任何类型都实现了空接口。

var emptyInterface interface{}

// 任何类型都可以赋值给空接口
emptyInterface = "这是一个字符串"
emptyInterface = 42
emptyInterface = ConcreteType{}

接口的嵌入

接口可以嵌入到其他接口或结构体中。

type ReadWriter interface {
   Reader
   Writer
}

type Data struct {
   content string
}

// Data嵌入了ReadWriter接口
var _ ReadWriter = Data{}

使用接口实现多态性

package main

import (
	"fmt"
	"math"
)

// 定义一个接口，包含计算面积的方法
type Shape interface {
	Area() float64
}

// 圆形结构体
type Circle struct {
	Radius float64
}

// 圆形实现Shape接口的Area方法
func (c Circle) Area() float64 {
	return math.Pi * c.Radius * c.Radius
}

// 矩形结构体
type Rectangle struct {
	Width, Height float64
}

// 矩形实现Shape接口的Area方法
func (r Rectangle) Area() float64 {
	return r.Width * r.Height
}

func main() {
	// 创建接口变量，用于存储实现了Shape接口的类型
	var shapes [2]Shape

	// 存储不同类型的Shape
	shapes[0] = Circle{Radius: 5}
	shapes[1] = Rectangle{Width: 10, Height: 5}
	
	// 遍历shapes，调用Area方法计算面积
	for _, shape := range shapes {
		fmt.Println("面积:", shape.Area())
	}

}