161 |
--------------------------------------------------------------------------------
/content/zh/docs/20-Importing_Packages_in_Go_DigitalOcean.md:
--------------------------------------------------------------------------------
1 | # 在 Go 中导入包
2 |
3 | ## 介绍
4 |
5 | 有时，你的代码需要当前程序的基础上增加更多的功能。在这些情况下，你可以使用软件包来丰富你的程序。在 Go 中, 一个包表示磁盘上单个目录中的所有文件。包可以定义可以在其他 Go 文件或包中引用的函数、类型和接口。
6 |
7 | 本教程将带你来完成软件包的安装, 导入和重命名。
8 |
9 | ## 标准库包
10 |
11 | 标准库是 Go 附带的一组软件包。这些软件包包含许多用于编写现代软件的基本模块。例如， [`fmt`](https://golang.org/pkg/fmt) 软件包包含用于格式和打印字符串的基本功能。 [`net/http`](https://golang.org/pkg/net/http/) 软件包包含允许开发人员创建 Web 服务，通过`HTTP` 协议发送和检索数据的功能，等等。
12 |
13 | 为了利用软件包中的功能，你需要使用 `import` 语句访问软件包。`import` 语句由 `import` 关键字以及软件包的名称组成。
14 |
15 | 例如，在 GO 程序中 `random.go` 文件。你可以导入 `math/rand` 包来生成随机数：
16 |
17 | ``` go
18 | import "math/rand"
19 | ```
20 |
21 | 当我们导入一个包时，我们把它在当前程序中作为一个单独 namespace 命名空间来使用。这意味着我们必须像 `package.function` 调用其中的函数。
22 |
23 | 实际上，`math/rand` 软件包的功能看起来像这些示例：
24 |
25 | - `rand.Int()` 调用函数返回随机整数。
26 | - `rand.Intn()` 调用函数将随机元素从 `0` 返回到所提供的指定数字。
27 |
28 | 让我们创建一个 `for` 循环，以显示我们如何在随机过程中调用 `math/rand` 软件包的函数。
29 |
30 | random.go
31 |
32 | ``` go
33 | package main
34 |
35 | import "math/rand"
36 |
37 | func main() {
38 | for i := 0; i < 10; i++ {
39 | println(rand.Intn(25))
40 | }
41 | }
42 | ```
43 |
44 | 该程序首先在第三行中导入 `math/rand` 软件包，然后移至将运行10次的循环中。在循环中，程序将打印一个在 `0` 到 `25` 范围内的随机整数。其中, 整数 `25` 是作为其参数传递给 `rand.Intn()`。
45 |
46 | 当我们使用 `go run random.go` 来运行程序时，我们将收到 10 个随机整数作为输出。因为这些是随机的，所以每次运行程序时，你都可能会获得不同的整数。输出看起来像这样：
47 |
48 | ``` shell
49 | # Output
50 | 6
51 | 12
52 | 22
53 | 9
54 | 6
55 | 18
56 | 0
57 | 15
58 | 6
59 | 0
60 | ```
61 |
62 | 整数永远不会低于 0 或 24 以上。
63 |
64 | 当需要导入多个包时，你可以使用 `()` 来创建一个块。通过使用块，可以避免在每行上重复 `import` 关键字。这将使你的代码看起来更整洁
65 |
66 | random.go
67 |
68 | ``` go
69 | import (
70 | "fmt"
71 | "math/rand"
72 | )
73 |
74 | ```
75 |
76 | 为了利用新增的软件包，我们现在可以格式化输出并打印出循环中每次迭代生成的随机数：
77 |
78 | random.go
79 |
80 | ``` go
81 | package main
82 |
83 | import (
84 | "fmt"
85 | "math/rand"
86 | )
87 |
88 | func main() {
89 | for i := 0; i < 10; i++ {
90 | fmt.Printf("%d) %d\n", i, rand.Intn(25))
91 | }
92 | }
93 |
94 | ```
95 |
96 | 现在，当我们运行程序时，我们将收到看起来像这样的输出：
97 |
98 | ``` shell
99 | # Output
100 | 0) 6
101 | 1) 12
102 | 2) 22
103 | 3) 9
104 | 4) 6
105 | 5) 18
106 | 6) 0
107 | 7) 15
108 | 8) 6
109 | 9) 0
110 | ```
111 |
112 | 在本节中，我们学会了如何导入软件包并使用它们来编写更复杂的程序。到目前为止，我们只使用了标准库中的软件包。接下来，让我们看看如何安装和使用其他开发人员编写的软件包。
113 |
114 | ## 安装软件包
115 |
116 | 虽然标准库包含了许多出色且有用的软件包，但它们的设计是通用的，本质上不是特定的。这使开发者可以根据自己的特定需求在标准库之上构建自己的软件包。
117 |
118 | GO 工具链带有 `go get` 命令。此命令使你可以将第三方软件包安装到本地开发环境中，并且将这些软件包应用到你的程序中。
119 |
120 | 使用 `go get` 来安装第三方软件包时，通常可以通过其规范路径引用软件包。这个路径也可能是通往公共项目的途径，该项目托管在诸如 GitHub 之类的代码存储库中。因此，如果要导入 [`flect`](https://github.com/gobuffalo/flect) 软件包，则将使用完整的规范路径：
121 |
122 | ``` shell
123 | go get github.com/gobuffalo/flect
124 | ```
125 |
126 | 在这种情况下，使用 `go get` 工具将在 GitHub 上找到软件包，并将其安装到你的 [`$Gopath`]({{< relref "/docs/05-Understanding_the_GOPATH.md" >}}) 中。
127 |
128 | 对于此示例，代码将安装在此目录中：
129 |
130 | ``` shell
131 | $GOPATH/src/github.com/gobuffalo/flect
132 | ```
133 |
134 | 原始作者通常会更新软件包，以解决 bug 或添加新功能。发生这种情况时，你可能需要使用该软件包的最新版本来利用新功能或已解决的 bug。要更新软件包，你可以使用 `go get` 命令使用 `-u` 标志：
135 |
136 | ``` shell
137 | go get -u github.com/gobuffalo/flect
138 | ```
139 |
140 | 如果在本地找不到该软件包，此命令也将安装该软件包。如果已经安装了它，Go 将尝试将软件包更新为最新版本。
141 |
142 | `go get` 命令始终检索可用的包装的最新版本。但是，可能还会对该软件包的之前的版本进行更新，这些版本仍然比你使用的更新，并且对你的程序中的更新非常有用。要检索包装的特定版本，你需要使用一个软件包管理工具，例如[Go Modules](https://github.com/golang/go/wiki/Modules)。
143 |
144 | 从 GO 1.11 开始，使用 Go Modules 来管理要导入的软件包的哪个版本。软件包管理的主题超出了本文的范围，但是你可以在[on the Go Modules GitHub page](https://github.com/golang/go/wiki/Modules)上阅读有关它的更多信息。
145 |
146 | ## 使用别名的方式导入软件包
147 |
148 | 如果你的本地软件包已经命名为与你正在使用的第三方软件包相同的包名时，则可能需要更改软件包名称。当发生这种情况时，使别名导入的方式是处理软件包名冲突的最佳方法。你可以通过将 `alias` 名称放在导入的软件包的前面来修改包装及其功能的名称及其功能。
149 |
150 | 该声明的结构看起来像这样：
151 |
152 | ``` go
153 | import another_name "package"
154 | ```
155 |
156 | 在此示例中，在 `random.go` 程序文件中修改 `fmt` 软件包的名称。我们将 `fmt` 的包名称更改为 `f`，以缩写它。我们的修改程序看起来像这样：
157 |
158 | random.go
159 |
160 | ``` go
161 | package main
162 |
163 | import (
164 | f "fmt"
165 | "math/rand"
166 | )
167 |
168 | func main() {
169 | for i := 0; i < 10; i++ {
170 | f.Printf("%d) %d\n", i, rand.Intn(25))
171 | }
172 | }
173 | ```
174 |
175 | 在程序中，我们现在将 `Printf` 函数称为 `f.Printf`，而不是 `fmt.Printf`。
176 |
177 | 虽然其他语言喜欢以别名的方式命名包以便于在程序中更加容易使用，但 GO 却不是。例如，与 `fmt` 软件包与 `f` 相反， [style guide](https://github.com/golang/go/wiki/CodeReviewComments#import-dot) 更加倾向于一致。
178 |
179 | 在重命名导入包以避免命名冲突时，你应该重命名本地导入的软件包或特定的项目中导入的包。例如，如果你有一个名为 `Strings` 的本地软件包，并且还需要导入称为 `strings` 的系统软件包，你应该重命名本地软件包而不是系统软件包。只要有可能，最好避免完全命名冲突。
180 |
181 | 在本节中，我们了解了如何以别名的方式导入软件包以避免与我们计划中的其他导入冲突。重要的是要记住，程序的可读性和清晰度很重要，因此你只能使用别名使代码更可读或何时需要避免命名冲突。
182 |
183 | ## 格式化导入
184 |
185 | 通过格式化导入，你可以将软件包分为特定的顺序，以使你的代码更加一致。此外，当惟一改变的是导入的排序顺序时，这将防止发生随机提交。由于格式化导入将防止随机提交，因此这将防止不必要的代码混乱和混淆代码审查。
186 |
187 | 大多数编辑器将自动为你格式化导入，或者让你配置编辑器以使用 [goimports](https://godoc.org/golang.org/x/tools/cmd/goimports) 工具。在编辑器中使用 `goimports` 被认为是标准实践，因为尝试手动维护导入的排序顺序可能是乏味的，而且容易出错。此外，如果进行了任何样式更改，则将更新 `goimports` 以反映这些样式更改。这样可以确保你和任何在代码上工作的人都将在你的 import 块中具有一致的样式。
188 |
189 | 这是格式化之前的示例导入块可能的样子：
190 |
191 | ``` go
192 | import (
193 | "fmt"
194 | "os"
195 | "github.com/digital/ocean/godo"
196 | "github.com/sammy/foo"
197 | "math/rand"
198 | "github.com/sammy/bar"
199 | )
200 |
201 | ```
202 |
203 | 运行 `goimport` 工具(或使用已安装它的大多数编辑器，保存文件将为你运行)，现在你将具有以下格式：
204 |
205 | ``` go
206 | import (
207 | "fmt"
208 | "math/rand"
209 | "os"
210 |
211 | "github.com/sammy/foo"
212 | "github.com/sammy/bar"
213 |
214 | "github.com/digital/ocean/godo"
215 | )
216 | ```
217 |
218 | 请注意，它首先将所有标准库软件包分组，然后将第三方软件包与空白行分组。这使得更容易阅读和了解正在使用哪些软件包。
219 |
220 | 在本节中，我们了解到，使用 `goimports` 将保持我们所有导入块的正确格式，并防止在处理相同文件在开发人员之间产生不必要的代码混乱。
221 |
222 | ## 总结
223 |
224 | 当我们导入软件包时，我们可以调用未内置的功能。有些软件包是随着 GO 安装的标准库的一部分，有些软件包将通过 `go get` 来安装。
225 |
226 | 使用软件包可以使我们在利用现有代码时使程序更加健壮和强大。我们还可以为自己和其他程序员 [创建自己的软件包]({{< relref "/docs/21-How_To_Write_Packages_in_Go.md" >}})，以便将来使用。
227 |
--------------------------------------------------------------------------------
/content/zh/docs/04-How_To_Write_Your_First_Program_in_Go_DigitalOcean.md:
--------------------------------------------------------------------------------
1 | # 如何用 Go 编写你的第一个程序
2 |
3 | ## 前言
4 |
5 | “Hello, World!” 程序是计算机编程中的经典且历史悠久的传统。 对于初学者来说，这是一个简单而完整的第一个程序，它是一个确保你的环境配置正确的好方法。
6 |
7 | 本教程将引导你在 Go 中创建此程序。 但是，为了使程序更有趣，你将修改传统的 “Hello, World!” 程序，以便它可以询问用户的姓名。 然后，你将在回复中使用该姓名。 完成本教程后，你将拥有一个运行起来如下所示的程序：
8 |
9 | ```text
10 | output
11 | Please enter your name.
12 | Sammy
13 | Hello, Sammy! I'm Go!
14 | ```
15 |
16 | ## 安装前提
17 |
18 | 在开始本教程之前，你需要一个本地的 Go 开发环境。你可以按照下面其中一个教程在你的计算机上进行设置：
19 |
20 | - [如何在 macOS 上安装 Go 和设置本地编程环境](https://gocn.github.io/How-To-Code-in-Go/docs/02-How_To_Install_Go_and_Set_Up_a_Local_Programming_Environment_on_macOS_DigitalOcean/)
21 | - [如何在 Ubuntu 18.04 上安装 Go 和设置本地编程环境](https://gocn.github.io/How-To-Code-in-Go/docs/01-How_To_Install_Go_and_Set_Up_a_Local-Programming_Environment_on_Ubuntu_18.04_DigitalOcean/)
22 | - [如何在 Windows 10 上安装 Go 和设置本地编程环境](https://gocn.github.io/How-To-Code-in-Go/docs/03-How_To_Install_Go_and_Set_Up_a_Local_Programming_Environment_on_Windows_10_DigitalOcean/)
23 |
24 | ## 第一步 — 编写最基本的 “Hello, World!” 程序
25 |
26 | 为了编写 Hello, World!” 程序，请打开一个命令行文本编辑器，例如 `nano`，然后创建一个新文件：
27 |
28 | ```bash
29 | nano hello.go
30 | ```
31 |
32 | 在 nano 中打开文本文件后，输入你的程序代码：
33 |
34 | ```go
35 | hello.go
36 | package main
37 |
38 | import "fmt"
39 |
40 | func main() {
41 | fmt.Println("Hello, World!")
42 | }
43 | ```
44 |
45 | 让我们分解下代码的各个部分。
46 |
47 | `package` 是一个 Go 关键字，它定义了这个文件属于哪个代码包。 每个文件夹只能有一个包，并且文件夹中每个 `.go` 文件必须在其文件顶部声明相同的包名。 在这个例子中，代码属于 `main` 包。
48 |
49 | `import` 是一个 Go 关键字，它告诉 Go 编译器你想在这个文件中使用哪些其他包。 在这里，你导入标准库附带的 `fmt` 包。 `fmt` 包提供了在开发时很有用的格式化和打印功能。
50 |
51 | `fmt.Println` 是一个 Go 函数，位于 `fmt` 包中，它告诉计算机将一些文本打印到屏幕上。
52 |
53 | 在 `fmt.Println` 函数后面跟着一系列字符，例如 `"Hello, World!"`，用引号括起来。 引号内的任何字符都称为 _string_。 `fmt.Println` 函数会在程序运行时将此字符串打印到屏幕上。
54 |
55 | 按 `CTRL` 和 `X` 键退出 `nano`。 当提示保存文件时，按 `Y`，然后按 `ENTER` 退出。
56 |
57 | 现在你可以试试你的程序了。
58 |
59 | ## 第二步 — 运行 Go 程序
60 |
61 | 你的 “Hello, World!” 程序写好之后，你就可以运行程序了。你可以用 `go` 命令然后后面跟着你刚刚创建的文件名。
62 |
63 | ```bash
64 | go run hello.go
65 | ```
66 |
67 | 程序执行后会显示以下输出：
68 |
69 | ```text
70 | output
71 | Hello, World!
72 | ```
73 |
74 | 让我们来探索下实际发生了什么。
75 |
76 | Go 程序在运行之前必须要先编译。当你使用文件名调用 `go run` 时，在本例中为 `hello.go`，`go` 命令将 _编译_ 应用程序，然后运行生成的二进制文件。 对于用 _编译型_ 编程语言编写的程序，编译器将获取程序的源代码并生成另一种类型的低级代码（例如机器代码）来生成可执行程序。
77 |
78 | Go 应用程序需要一个 `main` 包和一个确切的 **唯一** `main()` 函数，作为应用程序的入口点。 `main` 函数不接受任何参数并且不返回任何值。 相反，它告诉 Go 编译器应该将包编译为可执行包。
79 |
80 | 编译后，代码通过在 `main` 包中输入 `main()` 函数来执行。 它通过_调用_ `fmt.Println` 函数来执行`fmt.Println("Hello, World!")` 行。 `Hello, World!` 的字符串值被传递给函数。 在此示例中，字符串 `Hello, World!` 也称为 _参数_，因为它是传递给方法的值。
81 |
82 | `Hello, World!` 两边的引号不会打印到屏幕上，因为你用它们告诉 Go 你的字符串在哪里开始和结束。
83 |
84 | 在这一步中，你已经用 Go 编程创建了一个有效的“Hello, World！” 。 在下一步中，你将探索如何使程序更具交互性。
85 |
86 | ## 第三步 — 提示用户输入
87 |
88 | 每次运行程序时，它都会产生相同的输出。 在此步骤中，你可以把提示用户输入他们的姓名添加到程序中。 然后，你将在输出中使用他们的名字。
89 |
90 | 不要修改现有程序，而是使用 `nano` 编辑器创建一个名为 `greeting.go` 的新程序：
91 |
92 | ```bash
93 | nano greeting.go
94 | ```
95 |
96 | 首先，添加这段代码，提示用户输入他们的姓名：
97 |
98 | ```go
99 | package main
100 |
101 | import (
102 | "fmt"
103 | )
104 |
105 | func main() {
106 | fmt.Println("Please enter your name.")
107 | }
108 | ```
109 |
110 | 再一次，你使用 `fmt.Println` 函数将一些文本打印到屏幕上。
111 |
112 | 现在添加下面高亮行代码来存储用户的输入：
113 |
114 | ```go
115 | package main
116 |
117 | import (
118 | "fmt"
119 | )
120 |
121 | func main() {
122 | fmt.Println("Please enter your name.")
123 | var name string
124 | }
125 | ```
126 |
127 | `var name string` 行将使用 `var` _关键字_ 创建一个新变量。 你将变量命名为 “name” ，它的类型为 “string” 。
128 |
129 | 然后添加下面高亮行代码来捕捉用户的输入：
130 |
131 | ```go
132 | package main
133 |
134 | import (
135 | "fmt"
136 | )
137 |
138 | func main() {
139 | fmt.Println("Please enter your name.")
140 | var name string
141 | fmt.Scanln(&name)
142 | }
143 | ```
144 |
145 | `fmt.Scanln` 方法告诉计算机等待以换行符或 (`\n`) 字符结尾的键盘输入。 该方法会暂停程序，允许用户输入他们想要的任何文本。 当用户按下键盘上的 `ENTER` 键时，程序将继续。 然后捕获所有点击，包括 `ENTER` ，然后将其转换为字符串。
146 |
147 | 你想在程序中使用这些字符输出，因此你通过将这些字符 _写入_ 到被称为 `name` 的字符串 _变量_ 中来保存这些字符。 Go 将该字符串存储在计算机的内存中，直到程序完成运行。
148 |
149 | 最后，在程序中添加以下高亮行来打印输出：
150 |
151 | ```go
152 | package main
153 |
154 | import (
155 | "fmt"
156 | )
157 |
158 | func main() {
159 | fmt.Println("Please enter your name.")
160 | var name string
161 | fmt.Scanln(&name)
162 | fmt.Printf("Hi, %s! I'm Go!", name)
163 | }
164 | ```
165 |
166 | 这一次，你使用的是 `fmt.Printf`，而不是再次使用 `fmt.Println` 方法。 `fmt.Printf` 函数接受一个字符串，并使用特殊的打印 _占位符_, (`%s`)，将 `name` 的值注入到字符串中。 你这样做是因为 Go 不支持 _字符串插值_ ，它可以让你获取分配给变量的值并将其插入在字符串中。
167 |
168 | 按 `CTRL` 和 `X` 键退出 `nano`。 当提示保存文件时，按 `Y`。
169 |
170 | 现在运行程序。 系统将提示你输入你的姓名，因此请输入并按 `ENTER`。 输出可能不完全符合你的预期：
171 |
172 | ```text
173 | output
174 | Please enter your name.
175 | Sammy
176 | Hi, Sammy
177 | ! I'm Go!
178 | ```
179 |
180 | 而不是 `Hi, Sammy! I'm Go!`，名字后面有一个换行符。
181 |
182 | 该程序捕获了我们 **所有** 的点击，包括我们按下以告诉程序继续的 `ENTER` 键。 在字符串中，按 `ENTER` 键会创建一个特殊字符，该字符会创建一个新行。 该程序的输出完全按照你的要求执行； 它正在显示你输入的文本，包括新行。 这不是你期望的输出，但你可以使用其他功能对其进行修复。
183 |
184 | 在你的编辑器里面打开 `greeting.go`
185 |
186 | ```bash
187 | nano greeting.go
188 | ```
189 |
190 | 在你的程序里定位到下面这一行：
191 |
192 | ```go
193 | ...
194 | fmt.Scanln(&name)
195 | ...
196 | ```
197 |
198 | 在其后面增加下面一行：
199 |
200 | ```go
201 | name = strings.TrimSpace(name)
202 | ```
203 |
204 | 上面使用了 Go 标准库 `strings` 包中的 `TrimSpace` 函数，来处理你使用 `fmt.Scanln` 捕获的字符串。 `strings.TrimSpace` 函数从字符串的开头和结尾删除任何空格字符，包括换行符。 在这种情况下，它会删除你按下 `ENTER` 时创建的字符串末尾的换行符。
205 |
206 | 要使用 `strings` 包，你需要在程序顶部导入它。
207 |
208 | 在你的程序找到下面这几行代码：
209 |
210 | ```go
211 | import (
212 | "fmt"
213 | )
214 | ```
215 |
216 | 增加下面几行来导入 `strings` 包：
217 |
218 | ```go
219 | import (
220 | "fmt"
221 | "strings"
222 | )
223 | ```
224 |
225 | 你的程序现在包含了以下代码：
226 |
227 | ```go
228 | package main
229 |
230 | import (
231 | "fmt"
232 | "strings"
233 | )
234 |
235 | func main() {
236 | fmt.Println("Please enter your name.")
237 | var name string
238 | fmt.Scanln(&name)
239 | name = strings.TrimSpace(name)
240 | fmt.Printf("Hi, %s! I'm Go!", name)
241 | }
242 | ```
243 |
244 | 按 `CTRL` 和 `X` 键退出 `nano`。 当提示保存文件时，按 `Y`。
245 |
246 | 再次运行程序：
247 |
248 | ```bash
249 | go run greeting.go
250 | ```
251 |
252 | 这一次，在你输入你的名字并按 `ENTER` 后，你会得到预期的输出：
253 |
254 | ```text
255 | output
256 | Please enter your name.
257 | Sammy
258 | Hi, Sammy! I'm Go!
259 | ```
260 |
261 | 你现在有一个 Go 程序，它接受用户的输入并将其打印回屏幕。
262 |
263 | ## 总结
264 |
265 | 在本教程中，你编写了 一个 “Hello, World！” 程序，可以从用户那里获取输入、处理结果并显示输出。 既然你有一个基本程序可以使用，请尝试进一步扩展你的程序。 例如，询问用户最喜欢的颜色，让程序说它最喜欢的颜色是红色。 你甚至可以尝试使用相同的技术来创建一个简单的 Mad-Lib 程序。
--------------------------------------------------------------------------------
/content/zh/docs/18-Creating_Custom_Errors_in_Go_DigitalOcean.md:
--------------------------------------------------------------------------------
1 | # 在 Go 中创建自定义错误
2 |
3 | ## 介绍
4 |
5 | GO 标准库提供了[`errors.New`and`fmt.Errorf`](https://gocn.github.io/How-To-Code-in-Go/docs/17-Handling_Errors_in_Go_DigitalOcean/#%E5%88%9B%E5%BB%BA%E9%94%99%E8%AF%AF) 这两种方法来在创建错误。但是这两种方法并不能满足你的用户或者后期调试时提供更加复杂的错误信息或者报告发生了什么。为了传递这种更复杂的错误信息并获得更多功能，我们可以实现标准库 `error` 接口类型。
6 |
7 | `error` 接口定义如下：
8 |
9 | ```go
10 | type error interface {
11 | Error() string
12 | }
13 |
14 | ```
15 |
16 | [`内置`](https://golang.org/pkg/builtin/) 软件包将 `error` 定义为具有单个 `Error()` 方法的接口，该接口将错误消息字符串作为返回。通过实现此方法，我们可以将定义的任何类型转换为自己的错误。
17 |
18 | 让我们尝试运行以下示例以查看 `error` 接口的实现：
19 |
20 | ```go
21 | package main
22 |
23 | import (
24 | "fmt"
25 | "os"
26 | )
27 |
28 | // 定义一个 MyError 的接口体
29 | type MyError struct{}
30 |
31 | // 实现 error 接口的 Error 方法
32 | func (m *MyError) Error() string {
33 | return "boom"
34 | }
35 |
36 | // 定义 sayHello 函数
37 | // 函数返回类型为 string 和 error
38 | func sayHello() (string, error) {
39 | // 由于 *MyError 实现了 error 接口
40 | // 所以 &MyError{} 可以作为 error 对象返回
41 | return "", &MyError{}
42 | }
43 |
44 | func main() {
45 | s, err := sayHello()
46 | if err != nil {
47 | fmt.Println("unexpected error: err:", err)
48 | os.Exit(1)
49 | }
50 | fmt.Println("The string:", s)
51 | }
52 |
53 | ```
54 |
55 | 我们将看到以下输出：
56 |
57 | ```shell
58 | # Output
59 | unexpected error: err: boom
60 | exit status 1
61 | ```
62 |
63 | 在这里，我们创建了一个新的空结构类型 `MyError`，并在其上定义了 `Error()` 方法。`Error()` 方法返回字符串 `"Boom"`。
64 |
65 | 在 `main()` 中，我们调用 `sayhello` 函数，该函数返回一个空字符串和一个新 `MyError` 实例。由于 `sayhello` 将始终返回错误，因此在`main()` 中的 `if` 语句主体内的 `fmt.Println` 调用将始终执行。我们使用 `fmt.Println` 来打印短前缀字符串 `"unexpected error:"`以及在保存`MyError` 实例中的在 `err` 变量。
66 |
67 | > 值得注意的是，我们不必直接调用 `Error()`，因为 `fmt` 包能够自动检测到已经实现了 `error` 接口。它 [透明](
78 | 
85 | 
92 | 
99 | 
106 | 
113 | 
121 | 
128 | 
135 | 
142 | 
149 | 
156 |