2024年Go最全Golang 泛型的介绍(2)，一文搞懂Golang架构

2401_84923269

于 2024-05-17 00:02:42 发布

阅读量594

点赞数 26

分类专栏：面试学习路线阿里巴巴文章标签： go 学习面试

本文链接：https://blog.csdn.net/2401_84923269/article/details/138979478

版权

面试学习路线阿里巴巴专栏收录该内容

1 篇文章 0 订阅

订阅专栏

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。

需要这份系统化的资料的朋友，可以添加戳这里获取

一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！

尽管Golang泛型提供了一些好处，但它还有一些局限性。

语法复杂性

Golang泛型的语法相对复杂，尤其是在使用代码生成工具时。这使得编写和维护泛型代码变得更加困难。此外，由于Golang的设计目标是简洁和易于阅读，官方团队对泛型的引入持保守态度。

性能影响

尽管泛型可以提高代码的性能，但在某些情况下，它可能会导致性能下降。这是因为泛型通常会引入额外的类型检查和转换操作，这可能会增加代码的执行时间和内存消耗。

因此，在编写泛型代码时，我们需要权衡代码的性能和灵活性，并根据实际情况做出决策。

案例

为了更好地理解Golang泛型的应用，下面将介绍三个案例，展示了泛型在不同场景下的实际应用。

案例一：通用的容器类型

在许多应用中，我们经常需要使用不同类型的容器来存储数据，例如数组、切片、队列等。使用Golang泛型，我们可以编写一个通用的容器类型，可以适用于不同类型的数据。

type Container[T any] struct {
    data []T
}

func (c \*Container[T]) Add(item T) {
    c.data = append(c.data, item)
}

func (c \*Container[T]) Get(index int) T {
    return c.data[index]
}

在上面的例子中，我们定义了一个Container[T]类型，其中T是一个类型参数，表示容器中存储的数据类型。我们可以使用Add方法向容器中添加数据，并使用Get方法获取指定位置的数据。

使用泛型的容器类型，我们可以创建不同类型的容器实例，例如：

intContainer := Container[int]{}
intContainer.Add(1)
intContainer.Add(2)
fmt.Println(intContainer.Get(0)) // 输出：1

stringContainer := Container[string]{}
stringContainer.Add("Hello")
stringContainer.Add("World")
fmt.Println(stringContainer.Get(1)) // 输出：World

这样，我们可以方便地使用相同的代码来处理不同类型的容器。

案例二：通用的排序函数

排序是一个常见的算法操作，我们经常需要对不同类型的数据进行排序。使用Golang泛型，我们可以编写一个通用的排序函数，可以适用于不同类型的数据。

func Sort[T comparable](arr []T) []T {
    sorted := make([]T, len(arr))
    copy(sorted, arr)
    sort.Slice(sorted, func(i, j int) bool {
        return sorted[i] < sorted[j]
    })
    return sorted
}

在上面的例子中，我们定义了一个Sort[T comparable]函数，其中T是一个类型参数，表示待排序数据的类型。我们使用sort.Slice函数对数据进行排序，并返回排序后的结果。

使用泛型的排序函数，我们可以对不同类型的数据进行排序，例如：

intArr := []int{3, 1, 2}
sortedIntArr := Sort(intArr)
fmt.Println(sortedIntArr) // 输出：[1 2 3]

stringArr := []string{"c", "a", "b"}
sortedStringArr := Sort(stringArr)
fmt.Println(sortedStringArr) // 输出：[a b c]

这样，我们可以方便地使用相同的排序函数来处理不同类型的数据。

案例三：通用的线程池

在并发编程中，线程池是一种常用的技术，用于管理和复用多个线程。使用Golang泛型，我们可以编写一个通用的线程池，可以适用于不同类型的任务。

type Task[T any] func(T) error

type Pool[T any] struct {
    tasks chan Task[T]
}

func (p \*Pool[T]) AddTask(task Task[T]) {
    p.tasks <- task
}

func (p \*Pool[T]) Run(workerNum int) {
    for i := 0; i < workerNum; i++ {
        go func() {
            for task := range p.tasks {
                task()
            }
        }()
    }
}

在上面的例子中，我们定义了一个Task[T]类型，表示要执行的任务，它接受一个参数并返回一个错误。然后，我们定义了一个Pool[T]类型，其中T是一个类型参数，表示任务的参数类型。我们使用通道来管理任务，并使用Run方法启动指定数量的工作线程来处理任务。

使用泛型的线程池，我们可以处理不同类型的任务，例如：

intTask := func(num int) error {
    fmt.Println(num)
    return nil
}

stringTask := func(str string) error {
    fmt.Println(str)
    return nil
}

pool := Pool[func() error]{}
pool.AddTask(func() error {
    return intTask(1)
})
pool.AddTask(func() error {
    return stringTask("Hello")
})
pool.Run(2) // 输出：1 Hello

这样，我们可以方便地使用相同的线程池来处理不同类型的任务。

通过上述三个案例，我们展示了泛型在不同场景下的实际应用。泛型可以让我们编写更通用、更高效和更安全的代码，从而提高开发效率和代码质量。尽管Golang在语言层面上没有原生支持泛型，但我们可以使用一些技巧来模拟泛型的行为。

然而，我们也需要注意泛型的局限性，包括语法复杂性和性能影响。在实际应用中，我们需要权衡不同方面的考虑，并选择最适合当前情况的实现方式。

随着Golang的发展，我们可以期待更多关于泛型的功能和改进，使得在处理不同类型的数据时更加灵活和高效。

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传