Go 语言入门指南: 环境搭建、基础语法和常用特性解析 ｜ 青训营

从零开始

Go 语言简介

Go 是一个开源的编程语言，它能让构造简单、可靠且高效的软件变得容易。

Go是从2007年末由Robert Griesemer, Rob Pike, Ken Thompson主持开发，后来还加入了Ian Lance Taylor, Russ Cox等人，并最终于2009年11月开源，在2012年早些时候发布了Go 1稳定版本。现在Go的开发已经是完全开放的，并且拥有一个活跃的社区。

Go语言的设计目标是简单、高效、可靠，并且易于编程，以解决其他编程语言的一些痛点和限制。

1. 并发支持：Go 语言天生支持并发编程，提供了轻量级的Goroutines和通道（Channel）机制，使并发编程变得简单和高效。这使得编写并发程序变得容易，且能够充分利用多核处理器。
2. 高性能：Go 语言在运行时性能方面表现优异。其编译器能够产生高效的机器码，使得 Go 程序在性能上能够与 C++ 等编程语言相媲美。
3. 跨平台：Go语言支持跨多个平台，包括Windows、Linux、macOS等。开发者可以方便地编译和运行代码在不同的操作系统上。
4. 强调工具链：Go语言提供了完善的工具链，包括代码格式化工具、测试工具、性能分析工具等，使得开发、测试和部署变得更加简单和高效。
5. 丰富的标准库：Go语言内置了许多常用的库，涵盖网络、文件操作、加密、文本处理等多个领域，让开发者能够更轻松地构建复杂的应用程序。

总体而言，Go语言的背景和特色使其成为一门优秀的现代编程语言，适用于构建高性能、高并发的系统，也适合快速开发和轻松上手。它在云计算、网络服务、分布式系统等领域得到广泛应用，并持续在开发者社区中受到关注和支持。

开发环境搭建

本文将以 Windows 下的 VS Code 作为例子介绍 Go 开发环境的搭建方法。当然你也可以使用 Goland 作为你的 IDE。

1. 安装Go语言

   首先，你需要下载并安装Go语言的二进制发行版本。前往官网下载适用于Windows的安装程序。

   运行安装向导，没啥问题的话一路下一步即可。

2. 配置环境变量

   正确安装完应该都会有，只是确认一下。

   确保 Go 语言的安装目录已经添加到系统的环境变量中。在开始菜单中搜索 path，打开 编辑系统环境变量 对话框，在 系统变量 中找到名为 “Path” 的变量，点击“编辑”，然后添加Go语言的安装路径（默认为 C:\Program Files\Go\bin 或你自定义的路径）。

3. 安装 Visual Studio Code

4. 安装 Go 扩展

   在 VS Code 中，打开扩展视图（快捷键 Ctrl+Shift+X ），搜索并安装 Go 的官方扩展。

   

   安装完毕后，重新启动 VS Code。

5. 配置 Go Proxy

   由于总所周知的原因，国内网络环境下载各种包的速度很慢很慢。因此，我们需要配置一下 Go proxy。

   访问 GOPROXY.IO - 一个全球代理 为 Go 模块而生 按照说明设置你的开发环境。

   使配置长久生效 （推荐）

   上面的配置步骤只会当次终端内生效，如何长久生效呢，这样就不用每次都去配置环境变量了。

   Mac/Linux

   # 设置你的 bash 环境变量
   echo "export GOPROXY=https://proxy.golang.com.cn,direct" >> ~/.profile && source ~/.profile
   
   # 如果你的终端是 zsh，使用以下命令
   echo "export GOPROXY=https://proxy.golang.com.cn,direct" >> ~/.zshrc && source ~/.zshrc
   

   Windows

   1. 右键 我的电脑 -> 属性 -> 高级系统设置 -> 环境变量
   2. 在 “[你的用户名]的用户变量” 中点击 ”新建“ 按钮
   3. 在 “变量名” 输入框并新增 “GOPROXY”
   4. 在对应的 “变量值” 输入框中新增 “https://proxy.golang.com.cn,direct”
   5. 最后点击 “确定” 按钮保存设置
   

6. 配置 Go 环境变量（可选）

   打开 VS Code后，按 Ctrl+Shift+P，输入 Go: Install/Update Tools，选择并运行该命令。它将会为你安装Go语言的一些常用工具，如格式化工具（gofmt）、代码检查工具（golint）、调试器（delve）等。

7. 创建 Go 项目

   现在，你可以创建一个Go项目并开始编写代码了。在任意目录下创建你的项目文件夹，然后在 VS Code中打开该文件夹。VS Code 会自动识别 Go 语言项目，并在左下角显示“Go”标志。

8. Hello, world!

   现在你已经搭建好了Go语言的开发环境，可以在 VS Code 中创建和编辑 Go 源代码文件，并使用Go的工具链进行编译、运行和调试。

   试试 Hello, world 吧!

   package main
   
   import "fmt"
   
   func main() {
       fmt.Println("Hello, World!")
   }
   

Let’s Go! 基本语法

Hello World

首先，让我们看看 Hello world 程序中发生了什么？

package main

import "fmt"
// This is discription
func main() {
    fmt.Println("Hello, World!")
}

让我们来看下以上程序的各个部分：

1. Package声明

   代码以 package main 开头，表明这个Go文件属于 main 包。在Go中，每个可执行程序都必须有一个 main 包，并且在 main 包中必须有一个main()函数作为程序的入口点。

2. 导入语句

   使用 import "fmt" 导入了 fmt 包。fmt 包是Go标准库中的一个包，提供了输入输出和格式化文本的功能。在本代码中，使用了 fmt.Println() 函数来输出文本。

3. 注释

   // This is description 是一行注释。在Go中，使用//表示单行注释，用于向代码中添加解释和说明。

4. main函数

   在Go程序中，main() 函数是程序的入口点。当程序执行时，它会首先执行 main() 函数。在这段代码中，main() 函数简单地调用 fmt.Println() 函数，将字符串"Hello, World!"输出到控制台。

5. 执行输出

   代码通过调用 fmt.Println("Hello, World!") 将 “Hello, World!” 这个字符串输出到终端。fmt.Println() 函数是一个方便的方法，用于在控制台输出文本，并在输出的最后自动添加一个换行符。

注意：在Go中，函数名首字母的大小写决定了该函数的可见性。

如果函数名以大写字母开头，那么它是可导出的 ，其他包可以访问该函数。（类似面向对象语言中的 public）

如果函数名以小写字母开头，它是私有的，其他包无法访问该函数。（类似面向对象语言中的 protected ）

在这个例子中，main()函数是可导出的，因为它以大写字母开头，允许被其他包调用。

变量和常量

在Go中，变量和常量的声明有一些不同。以下是它们的声明方式和特点

（参考 Go’s Declaration Syntax - Go 语言博客 (go-zh.org)了解这种类型声明形式出现的原因。）

变量声明：

1. 使用关键字var来声明一个变量，语法为：var variableName dataType
2. 变量名必须以字母或下划线开头，可以包含字母、数字和下划线，但不能使用Go的关键字。
3. 可以一次性声明多个变量，例如：var x, y int
4. 如果声明时未初始化变量，则变量会被赋予其数据类型的零值，比如：int类型的零值是0，string类型的零值是空字符串""。
5. 可以使用短变量声明来创建并初始化变量，语法为：variableName := value

示例：

var age int             // 声明一个整数变量 age
var name string         // 声明一个字符串变量 name
var x, y int            // 声明两个整数变量 x, y
x = 10                  // 给 x 赋值 10
name = "John"           // 给 name 赋值 "John"

var count = 5           // 声明一个整数变量 count 并初始化为 5
email := "example@go.com"  // 使用短变量声明声明一个字符串变量 email 并初始化为 "example@go.com"

在Go中，变量声明后必须使用，否则会导致编译错误。

Tips： 如果想要声明一个变量但不使用它，可以使用下划线 _ 来代替变量名，表示该变量被丢弃，不会占用内存空间。例如：

_ = 100 // 声明一个未使用的变量并初始化为 100，但在后续代码中并不使用该变量

总结：Go中的变量声明可以使用var关键字或短变量声明。变量声明时可以指定数据类型和初始值。未使用的变量可以使用下划线 _ 来代替。

常量声明：

1. 使用关键字const来声明常量，语法为：const constantName dataType = value
2. 常量的值在声明时必须初始化，并且一旦赋值不能再修改。
3. 常量可以是字符、字符串、布尔值或数值类型（整数、浮点数）。
4. 常量名的命名规则与变量相同，以字母或下划线开头，可以包含字母、数字和下划线，但不能使用Go的关键字。
5. 常量的值必须是一个编译时可以确定的表达式，例如：const PI = 3.14

示例：

const PI = 3.14             // 声明一个名为 PI 的常量并赋值为 3.14
const appName = "MyApp"     // 声明一个名为 appName 的常量并赋值为 "MyApp"
const isDebug = true        // 声明一个名为 isDebug 的常量并赋值为 true

const (
    monday = "Monday"
    tuesday = "Tuesday"
    // 可以在常量组中一次性声明多个常量
)

常量必须在声明时初始化，并且其值在程序运行期间不能改变。

数据类型

在 Go 编程语言中，数据类型用于声明函数和变量。

数据类型的出现是为了把数据分成所需内存大小不同的数据，编程的时候需要用大数据的时候才需要申请大内存，就可以充分利用内存。

Go 语言按类别有以下几种数据类型：

序号	类型和描述
1	布尔型 布尔型的值只可以是常量 true 或者 false。一个简单的例子：var b bool = true。
2	数字类型 整型 int 和浮点型 float32、float64，Go 语言支持整型和浮点型数字，并且支持复数，其中位的运算采用补码。
3	字符串类型: 字符串就是一串固定长度的字符连接起来的字符序列。Go 的字符串是由单个字节连接起来的。Go 语言的字符串的字节使用 UTF-8 编码标识 Unicode 文本。
4	派生类型: 包括： (a) 指针类型（Pointer） (b) 数组类型 © 结构化类型(struct) (d) Channel 类型 (e) 函数类型 (f) 切片类型 (g) 接口类型（interface） (h) Map 类型

复合数据类型

数组和切片 (Array & Slice)

数组是一个固定大小的数据结构，它包含一组相同类型的元素。在 Go 语言中，创建数组时，需要指定数组的大小，并且该大小在声明后无法改变。数组的大小是其类型的一部分，因此类型为 [size]dataType ，其中 size 表示数组大小， dataType 表示数组元素的数据类型。

• 数组是值类型，当将一个数组赋值给另一个数组时，会复制所有的元素。这意味着对于大型数组，复制操作可能会比较耗时和内存。

// 声明一个包含5个整数的数组
var numbers [5]int

// 初始化数组元素
numbers = [5]int{1, 2, 3, 4, 5}

// 声明并初始化一个数组
numbers := [5]int{1, 2, 3, 4, 5}

切片是对数组的引用。切片不需要指定大小，可以动态增长和收缩。在声明切片时，不需要指定大小，只需要指定元素的类型。

对切片的修改会影响到底层数组。当将一个切片赋值给另一个切片时，它们会引用相同的底层数组。

// 声明一个切片
var mySlice []int

// 使用 make() 函数创建切片，第一个参数是切片类型，第二个参数是切片长度，第三个参数是切片容量（可选）
mySlice = make([]int, 5)    // 长度为5，容量也为5的切片

// 初始化一个切片
mySlice = []int{1, 2, 3, 4, 5}

// 切片的动态增长
mySlice = append(mySlice, 6, 7, 8) // 添加元素到切片末尾

需要注意的是，切片本身并不存储数据，它只是一个引用，指向底层数组的一部分。当切片的容量不足时，底层数组会被自动扩容。

你可以创建一个新的切片，它引用了现有切片或数组的一部分。这被称为“切片的切片”。切片的切片的语法是 slice[start:end]，其中 start 是第一个元素的索引（包括），end 是最后一个元素后面的索引（不包括）。结果切片的长度是 end - start，容量是从 start 索引到底层数组末尾的元素数量。

// 切片的切片，获取子切片
subSlice := mySlice[2:5] // 这将创建一个从索引 2 到索引 4（不包括 5）的子切片

映射（Map）

在Go中，映射（Map）是一种键值对的无序集合，类似于Python中的字典（dict）。它提供了一种方便的方式来存储和检索键值对，并且允许根据键快速查找对应的值。

创建映射（Map）

在Go中，使用map[keyType]valueType的语法来声明一个映射。其中keyType表示键的数据类型，valueType表示值的数据类型。

// 声明一个映射，键为字符串类型，值为整数类型
var myMap map[string]int

初始化映射

使用make()函数来初始化一个映射。初始化映射后，才能对其进行赋值和操作。

// 初始化一个映射
myMap := make(map[string]int)

添加和更新键值对

可以使用赋值操作符（=）来添加或更新映射中的键值对。如果指定的键不存在，它将被添加到映射中；如果指定的键已经存在，它将更新对应的值。

myMap["apple"] = 10
myMap["banana"] = 5
myMap["apple"] = 15 // 更新键 "apple" 对应的值

访问和检查键值对

可以通过指定键来访问映射中的值。如果指定的键不存在，将返回值类型的零值。为了区分键不存在和值为零值两种情况，可以使用多返回值的方式来检查键是否存在。

value := myMap["apple"] // 访问键 "apple" 对应的值

// 检查键是否存在
value, exists := myMap["orange"]
if exists {
    fmt.Println("The value for 'orange' is:", value)
} else {
    fmt.Println("Key 'orange' does not exist.")
}

删除键值对

可以使用delete()函数来删除映射中的键值对。如果指定的键不存在，delete()函数不会产生错误。

delete(myMap, "banana") // 删除键 "banana" 对应的键值对

遍历映射

使用for range循环可以遍历映射中的所有键值对。

for key, value := range myMap {
    fmt.Println(key, value)
}

Go 中的映射是一个强大且方便的数据结构，它在许多场景下都非常有用，特别是用于表示键值对的集合。与 Python 中的字典类似，Go 的映射提供了快速的键值查找和更新，是处理键值对数据的理想选择。

结构体（Struct）

在Go语言中，结构体（Struct）是一种自定义的复合数据类型，它允许我们将不同类型的数据组合在一起，形成一个新的数据结构。结构体是由一系列字段（fields）组成，每个字段可以是不同的数据类型。结构体中的字段称为成员（members），它们表示结构体的特征和属性。

声明结构体

使用type关键字来声明一个新的结构体类型。结构体的定义以关键字type开头，后面紧跟结构体的名称，然后是一个由字段组成的花括号代码块。

type Person struct {
    Name   string
    Age    int
    Height float64
}

创建结构体实例

通过声明一个结构体变量并为其成员赋值，我们可以创建结构体的实例。

// 创建一个Person结构体的实例
person1 := Person{
    Name:   "Alice",
    Age:    30,
    Height: 1.75,
}

访问结构体成员

可以使用.运算符来访问结构体的成员。

fmt.Println(person1.Name)   // 输出: "Alice"
fmt.Println(person1.Age)    // 输出: 30
fmt.Println(person1.Height) // 输出: 1.75

结构体的匿名字段

结构体允许字段没有名称，这样的字段称为匿名字段。匿名字段的数据类型必须是命名的类型或具有命名的类型。

type Circle struct {
    float64 // 匿名字段，代表圆的半径
}

嵌套结构体

结构体可以包含其他结构体作为其成员，这被称为嵌套结构体。通过嵌套结构体，我们可以建立更复杂的数据结构。

type Address struct {
    City  string
    State string
}

type Person struct {
    Name    string
    Age     int
    Address Address // 嵌套结构体作为成员
}

结构体的方法

结构体可以关联方法，通过这些方法可以为结构体类型添加行为。方法是特殊类型的函数，它们与结构体关联，可以在结构体实例上调用。

type Rectangle struct {
    Width  float64
    Height float64
}

func (r Rectangle) Area() float64 {
    return r.Width * r.Height
}

rect := Rectangle{Width: 10, Height: 5}
area := rect.Area() // 调用结构体的方法

在青训营课程中，使用了结构体来格式化 Request 和 Response 数据。

接口（Interface）

在Go语言中，接口（Interface）是一种抽象类型，它定义了一组方法的集合，但并不提供这些方法的具体实现。接口描述了对象的行为，而不关心对象的具体类型。任何类型只要实现了接口中定义的所有方法，就被认为是实现了该接口。

定义接口

使用type关键字和interface关键字来定义一个接口。接口的定义由一组方法签名组成，这些方法签名描述了接口中的方法。方法签名包括方法的名称、参数列表和返回值列表。

type Shape interface {
    Area() float64
    Perimeter() float64
}

实现接口

要实现一个接口，只需在类型上提供接口中定义的所有方法。实现接口不需要显式地声明实现了哪个接口，只要提供了接口中的方法，编译器会自动判断该类型实现了哪些接口。

type Rectangle struct {
    Width  float64
    Height float64
}

func (r Rectangle) Area() float64 {
    return r.Width * r.Height
}

func (r Rectangle) Perimeter() float64 {
    return 2*r.Width + 2*r.Height
}

多态性

接口的一个重要特性是多态性。多态性使得一个接口类型的变量可以在不同实现类型上调用相同的方法，实现了面向对象编程中的多态概念。

func printShapeInfo(s Shape) {
    fmt.Println("Area:", s.Area())
    fmt.Println("Perimeter:", s.Perimeter())
}

rect := Rectangle{Width: 5, Height: 3}
printShapeInfo(rect)

在上面的示例中，我们定义了一个Shape接口，它有两个方法Area()和Perimeter()。然后我们创建了一个Rectangle类型并为它实现了Shape接口的方法。在printShapeInfo函数中，我们接收一个Shape接口类型的参数，并在不同类型的实现上调用了Area()和Perimeter()方法。这样，printShapeInfo函数可以处理任何实现了Shape接口的类型，实现了多态性。

通过接口，我们可以编写更灵活、可扩展的代码，因为接口将实现细节与接口的使用者解耦，允许我们对代码进行抽象和复用。

流程控制

条件语句

在Go语言中，条件语句主要包括if、else和switch三种类型。它们用于根据不同条件执行不同的代码块。

if 语句

if语句用于根据一个表达式的结果来执行相应的代码块。如果表达式的值为true，则执行if后的代码块；如果表达式的值为false，则跳过if后的代码块。

num := 10
if num > 0 {
    fmt.Println("Positive")
} else if num == 0 {
    fmt.Println("Zero")
} else {
    fmt.Println("Negative")
}

else语句用于在if条件为false时执行一个备用的代码块。

num := 10
if num%2 == 0 {
    fmt.Println("Even")
} else {
    fmt.Println("Odd")
}

switch 语句

switch 是编写一连串 if-else 语句的简便方法。它运行第一个值等于条件表达式的 case 语句。

Go 的 switch 语句类似于 C、C++、Java、JavaScript 和 PHP 中的，不过 Go 只运行选定的 case，而非之后所有的 case。

Go 的另一点重要的不同在于 switch 的 case 无需为常量，且取值不必为整数。

day := "Sunday"
switch day {
case "Monday":
    fmt.Println("Start of the week")
case "Tuesday":
    fmt.Println("Second day")
case "Wednesday", "Thursday":
    fmt.Println("Middle of the week")
case "Friday":
    fmt.Println("End of the work week")
case "Saturday", "Sunday":
    fmt.Println("Weekend")
default:
    fmt.Println("Invalid day")
}

实际上，Go 自动提供了在这些语言中每个 case 后面所需的 break 语句。除非以 fallthrough 语句结束，否则分支会自动终止。

num := 2
switch num {
case 1:
    fmt.Println("One")
    fallthrough
case 2:
    fmt.Println("Two")
case 3:
    fmt.Println("Three")
}

在上面的例子中，当num为2时，会输出：

Two
Three

这是因为在第一个case中使用了fallthrough关键字，导致继续执行下一个case的代码块。

循环语句

Go 只有一种循环结构：for 循环。

基本的 for 循环由三部分组成，它们用分号隔开：

• 初始化语句：在第一次迭代前执行
• 条件表达式：在每次迭代前求值
• 后置语句：在每次迭代的结尾执行

初始化语句通常为一句短变量声明，该变量声明仅在 for 语句的作用域中可见。

一旦条件表达式的布尔值为 false，循环迭代就会终止。

注意：和 C、Java、JavaScript 之类的语言不同，Go 的 for 语句后面的三个构成部分外没有小括号，
大括号 {}` 则是必须的。

1. 基本的for循环：类似于C语言的for循环，使用for关键字和循环条件。循环条件可以是一个布尔表达式，当条件为true时循环会继续执行。

for i := 0; i < 5; i++ {
    fmt.Println(i)
}

2. for循环省略初始化和步进：在for循环中，初始化和步进语句都是可选的。如果省略初始化语句，那么相当于一个无限循环。

i := 0
for ; i < 5; {
    fmt.Println(i)
    i++
}

3. for循环省略全部条件：可以将for循环的条件部分省略，相当于一个无限循环。

i := 0
for {
    fmt.Println(i)
    i++
    if i >= 5 {
        break
    }
}

在循环中，我们常常会用到 range 来遍历可迭代的数据结构。

numbers := []int{1, 2, 3, 4, 5}
for index, value := range numbers {
    fmt.Printf("Index: %d, Value: %d\n", index, value)
}

range循环会返回两个值，一个是索引（或键），另一个是对应索引（或键）的元素值。可以使用空白标识符_来忽略其中的某个值。

for _, value := range numbers {
    fmt.Println(value)
}

range循环也可以用于遍历映射的键值对。

mymap := map[string]int{"apple": 1, "banana": 2, "orange": 3}
for key, value := range mymap {
    fmt.Printf("Key: %s, Value: %d\n", key, value)
}

在for循环和range循环中，我们可以使用break和continue关键字来控制循环的执行流程，实现各种不同的逻辑。

函数

函数的声明和定义

使用func关键字来声明和定义一个函数。函数的声明包括函数名、参数列表和返回值。如果函数没有返回值，则可以省略返回值的部分。

func add(a, b int) int {
    return a + b
}

func greet(name string) {
    fmt.Println("Hello, " + name)
}

调用函数

要调用一个函数，只需要写出函数名并传递必要的参数。如果函数有返回值，可以使用变量接收返回值。

result := add(5, 3)
greet("Alice")

多返回值

Go语言中的函数可以返回多个值。多返回值在很多场景下非常有用，例如可以返回结果和错误，或者返回多个计算结果。

func divide(a, b int) (int, error) {
    if b == 0 {
        return 0, errors.New("division by zero")
    }
    return a / b, nil
}

result, err := divide(10, 2)
if err != nil {
    fmt.Println("Error:", err)
} else {
    fmt.Println("Result:", result)
}

匿名函数

在Go中，可以创建匿名函数（没有名字的函数），并将其分配给变量。匿名函数通常用于简短的代码块，例如作为函数参数传递或在闭包中使用。

add := func(a, b int) int {
    return a + b
}

result := add(3, 5)

变长参数

Go语言支持变长参数（可变参数），通过在参数类型前加上三个点（...）来指示。这允许函数接受任意数量的参数。

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

result := sum(1, 2, 3, 4, 5) // result = 15

函数作为参数和返回值

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

func add(a, b int) int {
    return a + b
}

func sub(a, b int) int {
    return a - b
}

func calculate(op func(int, int) int, a, b int) int {
    return op(a, b)
}

result1 := calculate(add, 5, 3) // result1 = 8
result2 := calculate(sub, 5, 3) // result2 = 2

错误处理

Go语言中的错误处理是一种机制，用于处理函数执行中可能发生的错误情况。在Go中，错误是一个接口类型（error），它通常用于表示函数是否执行成功以及错误的具体信息。

错误的定义

在Go中，error接口是一个预定义的接口，它只有一个方法：

type error interface {
    Error() string
}

一个实现了error接口的类型可以表示一个错误。通常情况下，返回error类型的值表示函数执行失败，返回nil表示函数执行成功。

函数返回错误

在函数执行过程中，如果发生错误，可以通过返回error类型的值来表示错误。函数可以返回一个非nil的error值，用于指示函数执行失败，并携带错误信息。

func divide(a, b int) (int, error) {
    if b == 0 {
        return 0, errors.New("division by zero")
    }
    return a / b, nil
}

处理错误

在调用可能返回错误的函数时，通常需要检查错误并根据不同的错误情况采取相应的处理措施。

result, err := divide(10, 2)
if err != nil {
    fmt.Println("Error:", err)
} else {
    fmt.Println("Result:", result)
}

自定义错误

除了使用errors.New()函数创建基本的错误信息，我们还可以定义自己的错误类型，只需要实现error接口的Error()方法即可。

type MyError struct {
    message string
}

func (e *MyError) Error() string {
    return e.message
}

func doSomething() error {
    return &MyError{"Something went wrong"}
}

处理多个错误

在实际编程中，一个函数可能会返回多个错误，通常使用多个if语句或switch语句来处理不同的错误情况。

result1, err1 := doSomething()
result2, err2 := doAnotherThing()

if err1 != nil {
    fmt.Println("Error 1:", err1)
}

if err2 != nil {
    fmt.Println("Error 2:", err2)
}

// 继续处理其他结果

常用特性解析

Defer 语句

在Go语言中，defer语句用于在函数返回之前执行一些操作。这些操作可能包括资源释放、文件关闭、锁解锁等。defer语句通常用于确保某些操作在函数返回前一定会被执行，不管函数是否发生了错误或提前返回。

使用defer关键字，可以在函数中的任意位置注册一个需要在函数退出时执行的操作。defer语句后面跟随一个函数调用。

func doSomething() {
    fmt.Println("Doing something...")
    defer fmt.Println("Operation completed.")
}

在上面的例子中，当doSomething函数执行完成时，无论函数是正常结束还是发生了错误，Operation completed.都会被打印出来。

defer 的执行顺序

如果在函数中有多个defer语句，它们的执行顺序与注册的顺序相反。即最后注册的defer语句将最先执行，最先注册的defer语句将最后执行。

func printMessage(msg string) {
    defer fmt.Println("Deferred 2")
    defer fmt.Println("Deferred 1")
    fmt.Println(msg)
}

func main() {
    printMessage("Hello, World!")
}

输出结果为：

Hello, World!
Deferred 1
Deferred 2

defer语句与参数的求值：
在注册defer语句时，会对其参数进行求值，但实际执行是在函数返回前。这可能会导致一些潜在的问题，例如当参数是函数调用时，可能导致不符合预期的结果。

func main() {
    x := 0
    defer fmt.Println(x) // 输出 0，因为此时 x 的值为 0
    x++
}

常见用途：

• 关闭文件：在打开文件后使用defer语句关闭文件，确保文件在函数返回前被关闭，从而避免资源泄漏。
• 释放锁：在使用锁时，可以在加锁后使用defer语句来释放锁，确保锁的正确使用。
• 数据库连接的关闭：在使用数据库连接时，使用defer语句关闭连接，确保连接得到释放。

总之，defer语句是Go语言中一种非常有用的机制，它能够帮助我们在函数返回前执行一些必要的清理和收尾操作，提高代码的健壮性和可维护性。

更多关于 defer 语句的信息，请阅读Defer, Panic, and Recover - Go 语言博客 (go-zh.org)

参考资料

Go 语言之旅 (go-zh.org)

Go 语言教程 | 菜鸟教程 (runoob.com)