关于golang:官方教程Go泛型入门

前言

本周Go官网重磅公布了Go 1.18 beta 1版本，正式反对泛型。作为Go语言诞生12年以来最大的性能改革，官网配套推出了一个十分粗疏的Go泛型入门基础教程，通俗易懂。

自己对Go官网教程在翻译的根底上做了一些表述上的优化，以飨读者。

教程内容

这个教程次要介绍Go泛型的基础知识。通过泛型，你能够申明和应用泛型函数，在调用函数的时候，容许应用不同类型的参数作为函数实参。

在这个教程里，咱们先申明2个简略的非泛型函数，而后在一个泛型函数里实现这2个函数的逻辑。

接下来通过以下几个局部来进行解说：

1. 为你的代码创立一个目录
2. 实现非泛型函数
3. 实现一个泛型函数来解决不同类型
4. 调用泛型函数的时候移除类型实参
5. 申明类型限度(type constraint)

留神：对于Go的其它教程，大家能够参考https://go.dev/doc/tutorial/。

留神：大家能够应用Go playground的Go dev branch模式来编写和运行你的泛型代码，地址https://go.dev/play/?v=gotip。

筹备工作

• 装置Go 1.18 Beta 1或者更新的版本。装置指引能够参考上面的介绍。
• 有一个代码编辑工具。任何文本编辑器都能够。
• 有一个命令行终端。Go能够运行在Linux，Mac上的任何命令行终端，也能够运行在Windows的PowerShell或者cmd之上。

装置和应用beta版本

这个教程须要应用Go 1.18 Beta 1版本了的泛型性能。应用如下步骤，装置beta版本

1. 应用上面的命令装置beta版本

   $ go install golang.org/dl/go1.18beta1@latest

2. 运行如下命令来下载更新

   $ go1.18beta1 download

3. 应用beta版本的go命令，不要去应用release版本的go命令

   你能够通过间接应用go1.18beta1命令或者给go1.18beta1起一个简略的别名

   • 间接应用go1.18beta1命令

     $ go1.18beta1 version

   • 给go1.18beta1命令起一个别名

     $ alias go=go1.18beta1$ go version

   上面的教程都假如你曾经把go1.18beta1命令设置了别名go。

为你的代码创立一个目录

首先创立一个目录用于寄存你写的代码。

1. 关上一个命令行终端，切换到你的home目录

   • 在Linux或者Mac上执行如下命令(Linux或者Mac上只须要执行cd就能够进入到home目录)

     cd

   • 在Windows上执行如下命令

     C:\> cd %HOMEPATH%

2. 在命令行终端，创立一个名为generics的目录

   $ mkdir generics$ cd generics

3. 创立一个go module

   运行go mod init命令，来给你的我的项目设置module门路

   $ go mod init example/generics

   留神：对于生产代码，你能够依据我的项目理论状况来指定module门路，如果想理解更多，能够参考https://go.dev/doc/modules/ma...。

接下来，咱们来应用map写一些简略的代码。

实现非泛型函数

在这个步骤，你要实现2个函数，每个函数都是把map里<key, value>对应的所有value相加，返回总和。

你须要申明2个函数，因为你要解决2种不同类型的map，一个map存储的value是int64类型，一个map存储的value是float64类型。

代码实现

1. 关上你的代码编辑器，在generics目录创立文件main.go，你的代码将实现在这个文件里。

2. 进入main.go，在文件最结尾，写包申明

   package main

   一个独立的可执行程序总是申明在package main里，这点和库不一样。

3. 在包申明的上面，写如下代码

   // SumInts adds together the values of m.func SumInts(m map[string]int64) int64 {    var s int64    for _, v := range m {        s += v    }    return s}// SumFloats adds together the values of m.func SumFloats(m map[string]float64) float64 {    var s float64    for _, v := range m {        s += v    }    return s}

   在下面的代码里，咱们定义了2个函数，用于计算map里value的总和

   • SumInts计算value为int64类型的总和
   • SumFloats计算value为float64类型的总和

4. 在main.go的package main申明上面，实现main函数，用于初始化2个map，并把它们作为参数传递给咱们实现的2个函数。

   func main() {// Initialize a map for the integer valuesints := map[string]int64{    "first": 34,    "second": 12,}// Initialize a map for the float valuesfloats := map[string]float64{    "first": 35.98,    "second": 26.99,}fmt.Printf("Non-Generic Sums: %v and %v\n",    SumInts(ints),    SumFloats(floats))}

   在这段代码里，咱们做了如下几个事件

   • 初始化2个map，每个map都有2个记录
   • 调用SumInts和SumFloats来别离计算2个map的value的总和
   • 打印后果
5. 在main.go的package main上面，增加import fmt，下面代码里调用的打印函数须要fmt这个package。
6. 保留main.go。

代码运行

在main.go所在目录下，运行如下命令

$ go run .Non-Generic Sums: 46 and 62.97

应用泛型，咱们只须要实现1个函数就能够计算2个不同类型map的value总和。接下来，咱们会展现如何实现这个泛型函数。

实现一个泛型函数来解决不同类型

这个章节，咱们会实现一个泛型函数，该泛型函数既能够接管value为int类型的map作为参数，也能够接管value为float类型的map作为参数，这样咱们就不必为不同类型的map别离实现各自的函数了。

函数要反对这种泛型行为，须要有2个前提条件：

1. 对于函数而言，须要一种形式来申明这个函数到底反对哪些类型的参数
2. 对于函数调用方而言，须要一种形式来指定传给函数的到底是int类型的map还是float类型的map

为了满足以上前提条件：

1. 在申明函数的时候，除了须要像一般函数一样增加函数参数之外，还要申明类型参数(type parameters)。这些类型参数让函数可能实现泛型行为，让函数能够解决不同类型的参数。
2. 在函数调用的时候，除了须要像一般函数调用一样传递实参之外，还须要指定泛型函数的类型参数对应的类型实参(type arguments)。

每个类型参数都有一个类型限度(type constraint)，类型限度就好比类型参数的meta类型，每个类型限度会指明函数调用时该类型参数容许的类型实参。

只管一个类型参数的类型限度是一系列类型的汇合，然而在编译期，类型参数只会示意一种具体的类型，也就是函数调用方理论应用的类型实参。如果类型实参的类型不满足类型参数的类型限度，编译就会失败。

记住：一个类型参数肯定要反对代码里对该类型所做的所有操作。例如你的函数代码试图对某个类型参数执行string操作，比方依照下标索引取值，然而这个类型参数的类型限度包含了数字类型，那代码就会编译失败。

在接下来的代码里，咱们会应用类型限度来容许value为int类型和float类型的map作为函数的入参。

代码实现

1. 在下面实现的SumInts和SumFloats前面，增加如下函数

   // SumIntsOrFloats sums the values of map m. It supports both int64 and float64// as types for map values.func SumIntsOrFloats[K comparable, V int64 | float64](m map[K]V) V {    var s V    for _, v := range m {        s += v    }    return s}

   在这段代码里，咱们做了如下事件：

   • 申明函数SumIntsOrFloats，它有2个类型参数K和V(在[ ]外面)，一个函数参数m，类型是map[K]V，返回返回类型是V。
   • 类型参数K的类型限度是comparable。comparable限度是Go里预申明的。它能够承受任何能做==和!=操作的类型。Go语言里map的key必须是comparable的，因而类型参数K的类型限度应用comparable是很有必要的，这也能够确保调用方应用了非法的类型作为map的key。
   • 类型参数V的类型限度是int64和float64的并集，|示意取并集，也就是int64和float64的任一个都能够满足该类型限度，能够作为函数调用方应用的类型实参。
   • 函数参数m的类型是map[K]V。咱们晓得map[K]V是一个非法的map类型，因为K是一个comparable的类型。如果咱们不申明K为comparable，那编译器会回绝对map[K]V的援用。

2. 在main.go已有代码前面，增加如下代码

   fmt.Printf("Generic Sums: %v and %v\n",    SumIntsOrFloats[string, int64](ints),    SumIntsOrFloats[string, float64](floats))

   在这段代码里：

   • 调用了下面定义的泛型函数，传递了2种类型的map作为函数的实参。

   • 函数调用时指明了类型实参(方括号[ ]外面的类型名称)，用于替换调用的函数的类型实参。

     在接下来的内容里，你会常常看到调用函数时，会省略掉类型实参，因为Go通常(不是肯定)能够依据你的代码推断出类型实参。

   • 打印函数的返回值。

代码运行

在main.go所在目录下，运行如下命令：

$ go run .Non-Generic Sums: 46 and 62.97Generic Sums: 46 and 62.97

编译器会主动把函数里的类型参数替换函数调用里指定的类型实参，在很多场景里，咱们能够疏忽掉这些类型实参，因为编译器能够进行主动推导。

调用泛型函数的时候移除类型实参

在这个章节，咱们会增加一个批改版本的泛型函数调用，通过移除函数调用时的类型实参，让函数调用更为简洁。

咱们在函数调用时能够移除类型实参是因为编译器能够主动推导进去，编译器是依据函数调用时传的函数实参类型做的推导判断。

留神：类型实参的主动推导并不是永远可行的。比方，你调用的泛型函数没有形参，不须要传递实参，那编译器就不能依据实参主动推导，须要在函数调用时在方括号[]里显示指定类型实参。

代码实现

• 在main.go已有代码前面，增加如下代码

  fmt.Printf("Generic Sums, type parameters inferred: %v and %v\n",    SumIntsOrFloats(ints),    SumIntsOrFloats(floats))

  在这段代码里，咱们调用了泛型函数，疏忽了类型实参，交给编译器进行主动类型推导。

代码运行

在main.go所在目录下，运行如下命令：

$ go run .Non-Generic Sums: 46 and 62.97Generic Sums: 46 and 62.97Generic Sums, type parameters inferred: 46 and 62.97

接下来，咱们会进一步简化泛型函数。咱们能够把int和float类型的并集做成一个能够复用的类型限度。

申明类型限度(type constraint)

在最初这个章节，咱们会把泛型函数里的类型限度以接口(interface)的模式做定义，这样类型限度就能够在很多中央被复用。申明类型限度能够帮忙精简代码，特地是在类型限度很简单的场景下。

咱们能够申明一个类型限度(type constraint)为接口(interface)类型。这样的类型限度能够容许任何实现了该接口的类型作为泛型函数的类型实参。例如，你申明了一个有3个办法的类型限度接口，而后把这个类型限度接口作用于泛型函数的类型限度，那函数调用时的类型实参必须要实现了接口里的所有办法。

类型限度接口也能够指代特定类型，在上面大家能够看到具体应用。

代码实现

1. 在main函数下面，import语句上面，增加如下代码用于申明一个类型限度

   type Number interface {    int64 | float64}

   在这段代码里，咱们

   • 申明了一个名为Number的接口类型用于类型限度
   • 在接口定义里，申明了int64和float64的并集

   咱们把本来来函数申明里的 int64和float64的并集革新成了一个新的类型限度接口Number，当咱们须要限度类型参数为int64或float64时，就能够应用Number这个类型限度来代替int64 | float64的写法。

2. 在已有的函数上面，增加一个新的SumNumbers泛型函数

   // SumNumbers sums the values of map m. Its supports both integers// and floats as map values.func SumNumbers[K comparable, V Number](m map[K]V) V {    var s V    for _, v := range m {        s += v    }    return s}

   在这段代码里

   • 咱们定义了一个新的泛型函数，函数逻辑和之前定义过的泛型函数SumIntsOrFloats齐全一样，只不过对于类型参数V，咱们应用了Number来作为类型限度。和之前一样，咱们把类型参数用于函数形参和函数返回类型。

3. 在main.go已有代码前面，增加如下代码

   fmt.Printf("Generic Sums with Constraint: %v and %v\n",    SumNumbers(ints),    SumNumbers(floats))

   在这段代码里

   • 咱们对2个map都调用SumNumbers，打印每次函数调用的返回值。

     和下面一样，在这个泛型函数调用里，咱们疏忽了类型实参(方括号[]外面的类型名称)，Go编译器依据函数实参进行主动类型推导。

代码运行

在main.go所在目录下，运行如下命令：

$ go run .Non-Generic Sums: 46 and 62.97Generic Sums: 46 and 62.97Generic Sums, type parameters inferred: 46 and 62.97Generic Sums with Constraint: 46 and 62.97

论断

目前为止，咱们曾经学完了Go泛型的入门常识。

如果你想持续试验，能够扩大Number接口，来反对更多的数字类型。

倡议接下来理解的主题：

• Go Tour：https://go.dev/tour/welcome/1，十分棒的Go根底入门指引，一步一步教会你入门Go。
• 能够在Effective Go：https://go.dev/doc/effective_go 和 How to Write Go code：https://go.dev/doc/code 找到写Go代码的最佳实际。

残缺代码

// example6.gopackage mainimport "fmt"type Number interface {    int64 | float64}func main() {    // Initialize a map for the integer values    ints := map[string]int64{        "first": 34,        "second": 12,    }    // Initialize a map for the float values    floats := map[string]float64{        "first": 35.98,        "second": 26.99,    }    fmt.Printf("Non-Generic Sums: %v and %v\n",        SumInts(ints),        SumFloats(floats))    fmt.Printf("Generic Sums: %v and %v\n",        SumIntsOrFloats[string, int64](ints),        SumIntsOrFloats[string, float64](floats))    fmt.Printf("Generic Sums, type parameters inferred: %v and %v\n",        SumIntsOrFloats(ints),        SumIntsOrFloats(floats))    fmt.Printf("Generic Sums with Constraint: %v and %v\n",        SumNumbers(ints),        SumNumbers(floats))}// SumInts adds together the values of m.func SumInts(m map[string]int64) int64 {    var s int64    for _, v := range m {        s += v    }    return s}// SumFloats adds together the values of m.func SumFloats(m map[string]float64) float64 {    var s float64    for _, v := range m {        s += v    }    return s}// SumIntsOrFloats sums the values of map m. It supports both floats and integers// as map values.func SumIntsOrFloats[K comparable, V int64 | float64](m map[K]V) V {    var s V    for _, v := range m {        s += v    }    return s}// SumNumbers sums the values of map m. Its supports both integers// and floats as map values.func SumNumbers[K comparable, V Number](m map[K]V) V {    var s V    for _, v := range m {        s += v    }    return s}

开源地址

文档和代码开源地址：https://github.com/jincheng9/...

也欢送大家关注公众号：coding进阶，学习更多Go、微服务和云原生架构相干常识。

References

• https://go.dev/doc/tutorial/g...