Golang 学习日记 on ifanticの小屋

Go 萌新的初学之路 V

Tue, 29 Apr 2025 10:00:20 +0800

Gin 的简单入门：基于 Gin 框架的登录 / 注册表单验证实例，Gin 中间件的原理分析，Gin 返回 html，静态文件的挂载和 Gin 优雅的退出。

介绍

Gin 是一个用 Go 编写的 HTTP Web 框架。它具有类似 Martini 的 API，但性能比 Martini 快 40 倍。它运行速度快，具有分组的路由器，良好的崩溃捕获和错误处理，非常好的支持中间件和json。如果你需要极好的性能，使用 Gin 吧。

用以下命令安装：

1D:\user\go>go get -u github.com/gin-gonic/gin
2
3go: module github.com/gin-gonic/gin: Get "https://proxy.golang.org/github.com/gin-gonic/gin/@v/list": dial tcp 142.250.69.209:443: connectex: A connection attempt failed because the connected party did not properly respond after a period of time, or established connection failed because connected host has failed to respond.

但是我在安装的时候碰到了上面这个报错。我的解决办法：

1go env -w GOPROXY=https://goproxy.cn/

快速入门

 1package main
 2
 3import (
 4    "net/http"
 5
 6    "github.com/gin-gonic/gin"
 7)
 8
 9//handle方法
10func Pong(c *gin.Context) {
11    c.JSON(http.StatusOK, gin.H{
12        "name":   "ice_moss",
13        "age":    18,
14        "school": "家里蹲大学",
15    })
16}
17
18func main() {
19    //初始化一个gin的server对象
20    //Default实例化对象具有日志和返回状态功能
21    r := gin.Default()
22  //注册路由，并编写处理方法
23    r.GET("/ping", Pong)
24    //监听端口：默认端口listen and serve on 0.0.0.0:8080
25    r.Run(":8083")
26}

c.JSON()c.JSON() 方法用于发送 JSON 格式的响应:
- 第一个参数 http.StatusOK 表示返回 200 状态码
- 第二个参数 gin.H{} 是 map[string]interface{} 的简写，用于构造 JSON 对象
- 响应包含三个字段：name、age 和 school
gin.Default() 初始化带默认中间件的 Gin 引擎，包括日志记录和错误恢复功能
r.GET("/ping", Pong) 注册一个 GET 类型的路由，当访问 “/ping” 路径时，调用 Pong 函数处理请求
r.Run(":8083") 启动 HTTP 服务器并监听 8083 端口，默认情况下 Gin 会监听 0.0.0.0:8080

这是一个简单的 RESTful API 示例，当用户向 http://localhost:8083/ping 发送 GET 请求时，服务器会返回一个包含 name、age 和 school 信息的 JSON 响应。这种模式是构建 Web API 的基础，可以轻松扩展为更复杂的应用程序。

Gin 的 GET 和 POST 方法

 1package main
 2
 3import (
 4    "net/http"
 5
 6    "github.com/gin-gonic/gin"
 7)
 8
 9func GinGet(c *gin.Context) {
10    c.JSON(http.StatusOK, map[string]interface{}{
11        "name": "ice_moss",
12    })
13}
14
15func GinPost(c *gin.Context) {
16    c.JSON(http.StatusOK, gin.H{
17        "token": "您好",
18    })
19}
20func main() {
21    router := gin.Default()
22    router.GET("/GinGet", GinGet)
23    router.POST("/GinPost", GinPost)
24    router.Run(":8083")
25}

我们看到 GinGet 和 GinPost 这两个方法中的 c.JSON () 第二个参数不一样，原因：gin.H{} 本质就是一个 map[string]interface{}

1//H is a shortcut for map[string]interface{}
2type H map[string]any

然后我们就可以在浏览器中访问：localhost:8083/GinGet

这里需要注意我们不能直接在浏览器中访问：localhost:8083/GinPost，因为他用的是 POST 方法。可以使用 postman 来发送 POST 请求：

路由分组

Gin 为我们做了很好的路由分组，这样我们可以方便，对路由进行管理：

 1package main
 2
 3import (
 4    "net/http"
 5
 6    "github.com/gin-gonic/gin"
 7)
 8
 9func ProductLists(c *gin.Context) {
10    c.JSON(http.StatusOK, gin.H{
11        "矿泉水":  [5]string{"娃哈哈", "2元", "500"},
12        "功能饮料": [3]string{"红牛", "6元", "200"},
13    })
14}
15
16func Prouduct1(c *gin.Context) {
17    req := c.Param("haha")
18
19    c.JSON(http.StatusOK, gin.H{
20        "矿泉水":   [5]string{"娃哈哈矿泉水", "2元", "500"},
21        "token": req,
22    })
23}
24
25func CreateProduct(c *gin.Context) {}
26
27//路由分组
28func main() {
29    router := gin.Default()
30
31    //未使用路由分组
32    //获取商品列表
33    //router.GET("/ProductList", ProductLists)
34    //获取某一个具体商品信息
35    //router.GET("/ProductList/1", Prouduct1)
36    //添加商品
37    //router.POST("ProductList/Add", CreateProduct)
38
39    //路由分组
40    ProductList := router.Group("/Produc")
41    {
42        ProductList.GET("/list", ProductLists)
43        ProductList.GET("/1", Prouduct1)
44        ProductList.POST("/Add", CreateProduct)
45    }
46    router.Run(":8083")
47}

ProductLists 函数:

1func ProductLists(c *gin.Context) {
2    c.JSON(http.StatusOK, gin.H{
3        "矿泉水":  [5]string{"娃哈哈", "2元", "500"},
4        "功能饮料": [3]string{"红牛", "6元", "200"},
5    })
6}

返回了一个JSON格式的商品列表，包含矿泉水和功能饮料的信息。

Prouduct1 函数:

1func Prouduct1(c *gin.Context) {
2    req := c.Param("haha")
3    c.JSON(http.StatusOK, gin.H{
4        "矿泉水":   [5]string{"娃哈哈矿泉水", "2元", "500"},
5        "token": req,
6    })
7}

通过c.Param()获取URL中名为"haha"的路径参数，并返回特定商品信息和该参数值。（参考下一节）

CreateProduct 函数: 一个空函数，预留用于创建商品的功能实现。

使用路由分组后，所有路由都共享"/Produc"前缀，最终生成的API路径为:

GET /Produc/list - 调用ProductLists处理函数
GET /Produc/1 - 调用Prouduct1处理函数
POST /Produc/Add - 调用CreateProduct处理函数

URL 值的提取

很多时候我们需要对 URL 中数据的提取，或者动态的 URL，我们不可能将 URL 写成固定的。

 1package main
 2
 3import (
 4    "net/http"
 5
 6    "github.com/gin-gonic/gin"
 7)
 8
 9func ProductLists(c *gin.Context) {
10    c.JSON(http.StatusOK, gin.H{
11        "矿泉水":  [5]string{"娃哈哈矿泉水", "2元", "500"},
12        "功能饮料": [3]string{"红牛", "6元", "200"},
13    })
14}
15
16func Prouduct1(c *gin.Context) {
17    //获取url中的参数
18    id := c.Param("id")
19    action := c.Param("action")
20    c.JSON(http.StatusOK, gin.H{
21        "矿泉水":    [5]string{"娃哈哈矿泉水", "2元", "500"},
22        "id":     id,
23        "action": action,
24    })
25}
26
27func CreateProduct(c *gin.Context) {}
28
29//url取值
30func main() {
31    router := gin.Default()
32    //路由分组
33    ProductList := router.Group("/Product")
34    {
35        ProductList.GET("", ProductLists)
36        //使用"/:id"动态匹配参数
37        ProductList.GET("/:id/:action", Prouduct1)
38        ProductList.POST("", CreateProduct)
39    }
40    router.Run(":8083")
41}

访问 localhost:8083/Product/01/product1

{"action":"product1","id":"01","矿泉水":["娃哈哈矿泉水","2元","500","",""]}

访问 localhost:8083/Product/100/product2000

{"action":"product2000","id":"100","矿泉水":["娃哈哈矿泉水","2元","500","",""]}

关键部分是路由注册，使用了 冒号语法 ( :parameter ) 来定义动态路由参数:

1ProductList.GET("/:id/:action", Prouduct1)

:id - 匹配 URL 中的第一个路径段
:action - 匹配 URL 中的第二个路径段

任何形如 /Product/任意值/任意值 的请求都会被路由到 Prouduct1 处理函数。而在 Prouduct1 处理函数中，使用 c.Param() 方法提取路由参数值:

1id := c.Param("id")
2action := c.Param("action")

这种方式可以获取 URL 路径中对应位置的实际值，并将其赋给变量以便在处理函数中使用。

其他 URL 参数提取方式

除了路径参数外，Gin 还支持其他方式获取 URL 数据:

查询参数：使用 c.Query() 获取 URL 查询字符串中的参数。例如: /products?category=electronics&sort=price
表单数据：使用 c.PostForm() 获取表单提交的数据

结构体声明并做约束

 1package main
 2
 3import (
 4    "net/http"
 5
 6    "github.com/gin-gonic/gin"
 7)
 8
 9//结构体声明，并做一些约束
10type Porsen struct {
11    ID   int    `uri:"id" binding:"required"`    //uri指在client中的名字为id，binding:"required指必填
12    Name string `uri:"name" binding:"required"`  //同理
13}
14
15//url参数获取
16func main() {
17    router := gin.Default()
18    router.GET("/:name/:id", func(c *gin.Context) {
19        //使用porsen对数据进行解组
20        var porsen Porsen
21        if err := c.ShouldBindUri(&porsen); err != nil {
22            c.Status(404)
23            return
24        }
25        c.JSON(http.StatusOK, gin.H{
26            "name": porsen.Name,
27            "id":   porsen.ID,
28        })
29    })
30    router.Run(":8083")
31}

访问 localhost:8083/test100/2000

{"id":2000,"name":"test100"}

但是访问 localhost:8083/100/test2000

1找不到 localhost 的网页找不到与以下网址对应的网页：http://localhost:8083/100/test2000
2HTTP ERROR 404

这和我们约束条件一致。

结构体声明与标签

1type Porsen struct {
2    ID   int    `uri:"id" binding:"required"`
3    Name string `uri:"name" binding:"required"`
4}

这里，结构体定义了两个重要的标签注解：

uri:"id" 和 uri:"name" 指定这些字段对应哪些 URL 参数
binding:"required" 表示这些字段在请求中必须存在

路由处理器设置

1router.GET("/:name/:id", func(c *gin.Context) {
2    var porsen Porsen
3    if err := c.ShouldBindUri(&porsen); err != nil {
4        c.Status(404)
5        return
6    }
7    // 返回 JSON 响应
8})

路由模式是 /:name/:id，所以 URL 路径的第一部分映射到 name，第二部分映射到 id
c.ShouldBindUri(&porsen) 尝试解析 URL 参数并将它们绑定到结构体字段

为什么一个 URL 可以工作而另一个失败

可工作的 URL：localhost:8083/test100/2000

在这个 URL 中，“test100” 被绑定到 Name 字段（字符串类型），“2000” 被绑定到 ID 字段（整数类型），两个值都符合它们预期的类型因此绑定成功。

失败的 URL：localhost:8083/100/test2000

“100” 被绑定到 Name 字段（字符串），但是 “test2000” 被绑定到 ID 字段（整数），因为 “test2000” 无法转换为整数所以绑定失败。

错误处理

当绑定失败时，代码返回 404 状态码：

1if err := c.ShouldBindUri(&porsen); err != nil {
2    c.Status(404)
3    return
4}

c.ShouldBindUri(&porsen)：尝试从请求的 URI 中解析参数，并将它们绑定到 porsen 结构体中。它会根据结构体中定义的标签(uri:"id", uri:"name")来匹配 URL 参数，并进行类型验证。
if err := ... ; err != nil：这是 Go 中常见的写法，将 ShouldBindUri 的返回值赋给 err，然后检查它是否为 nil（即是否有错误）。
c.Status(404)：如果存在错误（例如，参数无法正确绑定），此代码将响应的 HTTP 状态码设置为 404（资源未找到）。
return：提前退出处理函数，防止执行后续代码（也就不会返回正常的 JSON 响应）。

Gin 还提供了 BindUri 方法，它在绑定失败时会自动中止请求并返回 400 状态码。

URL 参数的提取

GET 请求参数获取

URL 参数的提取是 GET 方法常用的方法，URL 中有需要的参数，例如我们访问这个百度图片：

图片链接

https://image.baidu.com/search/index?ct=201326592&tn=baiduimage&word=%E5%9B%BE%E7%89%87%E5%A3%81%E7%BA%B8&pn=&spn=&ie=utf-8&oe=utf-8&cl=2&lm=-1&fr=ala&se=&sme=&cs=&os=&objurl=&di=&gsm=1e&dyTabStr=MCwzLDYsMSw0LDIsNSw3LDgsOQ%3D%3D

? 以后的都是参数，用 & 分隔：?ct=201326592 &tn=baiduimage &word=%E5...

 1package main
 2
 3import (
 4    "net/http"
 5
 6    "github.com/gin-gonic/gin"
 7)
 8
 9func Welcom(c *gin.Context) {
10    //DefaultQuery根据字段名获取client请求的数据，client未提供数据则可以设置默认值
11    first_name := c.DefaultQuery("first_name", "未知")
12    last_mame := c.DefaultQuery("last_name", "未知")
13    c.JSON(http.StatusOK, gin.H{
14        "firstname": first_name,
15        "lastname":  last_mame,
16        "work":      [...]string{"公司：Tencent", "职位：Go开发工程师", "工资：20000"},
17    })
18}
19
20//url参数获取
21func main() {
22    //实例化server对象
23    router := gin.Default()
24    router.GET("/welcom", Welcom)
25    router.Run(":8083")
26}

访问 localhost:8083/welcom?first_name=moss&last_name=ice

{"firstname":"moss","lastname":"ice","work":["公司：Tencent","职位：Go开发工程师","工资：20000"]}

这样我们的后台就拿到了 client 提供的参数并做业务处理。

POST 表单提交及其数据获取

在很多时候我们都需要使用 post 方法来传输数据，例如用户登录/注册都需要提交表单等。下面我们来看看简单的表单提交：

 1package main
 2
 3import (
 4    "net/http"
 5
 6    "github.com/gin-gonic/gin"
 7)
 8
 9func Postform(c *gin.Context) {
10    UserName := c.DefaultPostForm("username", "unkown")
11    PassWord := c.DefaultPostForm("password", "unkown")
12    if UserName == "ice_moss@163.com" && PassWord == "123456" {
13        c.JSON(http.StatusOK, gin.H{
14            "name":        "ice_moss",
15            "username":    UserName,
16            "tokenstatus": "认证通过",
17        })
18    } else {
19        c.JSON(http.StatusInternalServerError, gin.H{
20            "tokenstatus": "认证未通过",
21        })
22    }
23}
24
25//url参数获取
26func main() {
27    //实例化server对象
28    router := gin.Default()
29    router.POST("/Postform", Postform)
30    router.Run(":8083")
31}

由于是 post 请求我们使用 postman 提交表单：localhost:8083/Postform

记住是 post 请求。后台输出：

1username ice_moss password 18dfdf
2[GIN] 2022/06/23 - 19:24:24 | 500 |     108.029µs |             ::1 | POST     "/Postform"

表单提交处理函数解释：

 1func Postform(c *gin.Context) {
 2    UserName := c.DefaultPostForm("username", "unkown")
 3    PassWord := c.DefaultPostForm("password", "unkown")
 4    if UserName == "ice_moss@163.com" && PassWord == "123456" {
 5        c.JSON(http.StatusOK, gin.H{
 6            "name":        "ice_moss",
 7            "username":    UserName,
 8            "tokenstatus": "认证通过",
 9        })
10    } else {
11        c.JSON(http.StatusInternalServerError, gin.H{
12            "tokenstatus": "认证未通过",
13        })
14    }
15}

表单数据获取

c.DefaultPostForm("username", "unkown") 从 POST 表单数据中获取"username"字段的值。如果该字段不存在，则返回默认值"unkown"。
c.DefaultPostForm("password", "unkown") 同样方式获取密码字段，有默认值作为备选。

认证逻辑

函数检查用户名是否为 ice_moss@163.com 且密码是否为 123456。如果凭证匹配，返回 200 OK 状态码和包含用户信息的 JSON；如果凭证不匹配，返回 500 Internal Server Error 状态码。

1func main() {
2    //实例化server对象
3    router := gin.Default()
4    router.POST("/Postform", Postform)
5    router.Run(":8083")
6}

创建一个默认的 Gin 路由器( gin.Default() )，它预先配置了 Logger 和 Recovery 中间件；
在"/Postform"路径注册一个 POST 路由，由 Postform 函数处理；
在 8083 端口启动 HTTP 服务器。

GET 和 POST 混合使用

 1package main
 2
 3import (
 4    "net/http"
 5
 6    "github.com/gin-gonic/gin"
 7)
 8
 9func GetPost(c *gin.Context) {
10    id := c.Query("id")
11    page := c.DefaultQuery("page", "未知的")
12    name := c.DefaultPostForm("name", "未知的")
13    password := c.PostForm("password")
14    c.JSON(http.StatusOK, gin.H{
15        "id":       id,
16        "page":     page,
17        "name":     name,
18        "password": password,
19    })
20}
21
22//url参数获取
23func main() {
24    //实例化server对象
25    router := gin.Default()
26
27    //GET和POST混合使用
28    router.POST("/Post", GetPost)
29    router.Run(":8083")
30}

因为是 post 方法使用，访问：localhost:8083/Post?id=1&page=2

 1func GetPost(c *gin.Context) {
 2    id := c.Query("id")
 3    page := c.DefaultQuery("page", "未知的")
 4    name := c.DefaultPostForm("name", "未知的")
 5    password := c.PostForm("password")
 6    c.JSON(http.StatusOK, gin.H{
 7        "id":       id,
 8        "page":     page,
 9        "name":     name,
10        "password": password,
11    })
12}

这个函数演示了四种不同的参数获取方法

获取 GET 参数:

c.Query("id"): 获取 URL 中的 id 参数，如果不存在则返回空字符串
c.DefaultQuery("page", "未知的"): 获取 URL 中的 page 参数，如果不存在则返回默认值"未知的"

获取 POST 表单数据:

c.DefaultPostForm("name", "未知的"): 获取 POST 表单中的 name 字段，如果不存在则返回默认值"未知的"
c.PostForm("password"): 获取 POST 表单中的 password 字段，如果不存在则返回空字符串

返回响应:

使用 c.JSON() 将所有参数组合成 JSON 格式返回给客户端

1func main() {
2    //实例化server对象
3    router := gin.Default()
4
5    //GET和POST混合使用
6    router.POST("/Post", GetPost)
7    router.Run(":8083")
8}

主函数的作用

创建一个 Gin 默认路由器实例
注册 POST 路由 “/Post”，由 GetPost 函数处理
启动 HTTP 服务器并监听 8083 端口

数据格式 JSON 和 ProtoBuf

我们知道前后端数据交互大多数都是以 json 的格式，Go 也同样满足。我们知道 GRPC 的数据交互是以 ProtoBuf 格式的，这里我们用到了 proto 文件夹下的代码，结构如下：

1proto
2├── user.pb.go
3└── user.proto

可参考 proto 相关代码： GoWeb框架Gin学习总结proto文件 | Go 技术论坛，把对应的 proto 文件夹放在 Go/src 根目录下。

下面我们来看看 Go 是如何处理 json 的，如何处理 ProtoBuf 的。

 1package main
 2
 3import (
 4    "net/http"
 5
 6    "StudyGin/HolleGin/ch07/proto"
 7
 8    "github.com/gin-gonic/gin"
 9)
10
11func moreJSON(c *gin.Context) {
12    var msg struct {
13        Nmae    string `json:"UserName"`
14        Message string
15        Number  int
16    }
17    msg.Nmae = "ice_moss"
18    msg.Message = "This is a test of JSOM"
19    msg.Number = 101
20
21    c.JSON(http.StatusOK, msg)
22}
23
24//使用ProtoBuf
25func returnProto(c *gin.Context) {
26    course := []string{"python", "golang", "java", "c++"}
27    user := &proto.Teacher{
28        Name:   "ice_moss",
29        Course: course,
30    }
31    //返回protobuf
32    c.ProtoBuf(http.StatusOK, user)
33}
34
35//使用结构体和JSON对结构体字段进行标签，使用protobuf返回值
36func main() {
37    router := gin.Default()
38    router.GET("/moreJSON", moreJSON)
39    router.GET("/someProtoBuf", returnProto)
40    router.Run(":8083")
41}

访问 localhost:8083/moreJSON

{"UserName":"ice_moss","Message":"This is a test of JSOM","Number":101}

当访问 http://localhost:8083/someProtoBuf 的时候，会返回 someProtoBuf 数据的下载文件，当然我们可以使用 GRPC 中的方法将数据接收解析出来。

主要区别解释

数据格式

JSON： 一种基于文本、人类可读的格式，广泛用于网络 API 和前后端通信。
ProtoBuf： 由 Google 开发的二进制序列化格式，更加紧凑高效。

可读性与效率对比

JSON： 当访问 /moreJSON 时，得到的是人类可读的响应：{"UserName":"ice_moss","Message":"This is a test of JSOM","Number":101}
ProtoBuf： 当访问 /someProtoBuf 时，得到的是二进制数据，会被下载而不是直接显示，因为它是设计给程序解析的，而非直接阅读。

工作原理

JSON： Go 通过结构体标签如 json:"UserName" 内置支持 JSON 序列化，允许自定义字段名。
ProtoBuf： 需要在 .proto 文件中定义数据结构，然后编译成特定语言的代码（此例中是 user.pb.go 文件）。

Gin 解析特殊字符

我们很多时候需要处理特殊的字符，比如：JSON 会将特殊的 HTML 字符替换为对应的 unicode 字符，比如 < 替换为 \u003c，如果想原样输出 html，则使用 PureJSON。

 1package main
 2
 3import (
 4    "net/http"
 5
 6    "github.com/gin-gonic/gin"
 7)
 8
 9//通常情况下，JSON会将特殊的HTML字符替换为对应的unicode字符，比如<替换为\u003c，如果想原样输出html，则使用PureJSON
10func main() {
11    router := gin.Default()
12    router.GET("/json", func(c *gin.Context) {
13        c.JSON(http.StatusOK, gin.H{
14            "html": "<b>您好，世界!</b>",
15        })
16    })
17
18    router.GET("/pureJSON", func(c *gin.Context) {
19        c.PureJSON(http.StatusOK, gin.H{
20            "html": "<div><b>您好，世界!</b></div>",
21        })
22    })
23    router.Run(":8083")
24}

访问 localhost:8083/json

{"html":"\u003cb\u003e您好，世界!\u003c/b\u003e"}

访问 localhost:8083/pureJSON

{"html":"<div><b>您好，世界!</b></div>"}

Gin 翻译器的实现

在这段代码中，我们是将注册代码实现翻译功能：在 Go web 应用程序中使用 Gin 框架结合 go-playground/validator 包实现表单验证，并提供验证错误消息的国际化(i18n)支持。

  1package main
  2
  3import (
  4    "fmt"
  5    "net/http"
  6    "reflect"
  7    "strings"
  8
  9    "github.com/gin-gonic/gin/binding"
 10    "github.com/go-playground/locales/en"
 11    "github.com/go-playground/locales/zh"
 12    ut "github.com/go-playground/universal-translator"
 13    "github.com/go-playground/validator/v10"
 14    enTranslations "github.com/go-playground/validator/v10/translations/en"
 15    zhTranslations "github.com/go-playground/validator/v10/translations/zh"
 16
 17    "github.com/gin-gonic/gin"
 18)
 19
 20// 定义一个全局翻译器T
 21var trans ut.Translator
 22
 23//Login登录业务，字段添加tag约束条件
 24type Login struct {
 25    User     string `json:"user" binding:"required"`     //必填
 26    Password string `json:"password" binding:"required"` //必填
 27}
 28
 29//SignUp注册业务，字段添加tag约束条件
 30type SignUp struct {
 31    Age        int    `json:"age" binding:"gte=18"`                            //gte大于等于
 32    Name       string `json:"name" binding:"required"`                         //必填
 33    Email      string `json:"email" binding:"required,email"`                  //必填邮件
 34    Password   string `json:"password" binding:"required"`                     //必填
 35    RePassword string `json:"re_password" binding:"required,eqfield=Password"` //RePassword和Password值一致
 36}
 37
 38//RemoveTopStruct去除以"."及其左部分内容
 39func RemoveTopStruct(fields map[string]string) map[string]string {
 40    res := map[string]string{}
 41    for field, value := range fields {
 42        res[field[strings.Index(field, ".")+1:]] = value
 43    }
 44    return res
 45}
 46
 47// InitTrans 初始化翻译器
 48func InitTrans(locale string) (err error) {
 49    // 修改gin框架中的Validator引擎属性，实现自定制
 50    if v, ok := binding.Validator.Engine().(*validator.Validate); ok {
 51        //注册一个获取json的自定义方法
 52        v.RegisterTagNameFunc(func(field reflect.StructField) string {
 53            name := strings.SplitN(field.Tag.Get("json"), ",", 2)[0]
 54            if name == "-" {
 55                return ""
 56            }
 57            return name
 58        })
 59        zhT := zh.New() // 中文翻译器
 60        enT := en.New() // 英文翻译器
 61
 62        // 第一个参数是备用（fallback）的语言环境
 63        // 后面的参数是应该支持的语言环境（支持多个）
 64        // uni := ut.New(zhT, zhT) 也是可以的
 65        uni := ut.New(enT, zhT, enT)
 66
 67        // locale 通常取决于 http 请求头的 'Accept-Language'
 68        var ok bool
 69        // 也可以使用 uni.FindTranslator(...) 传入多个locale进行查找
 70        trans, ok = uni.GetTranslator(locale)
 71        if !ok {
 72            return fmt.Errorf("uni.GetTranslator(%s) failed", locale)
 73        }
 74
 75        // 注册翻译器
 76        switch locale {
 77        case "en":
 78            err = enTranslations.RegisterDefaultTranslations(v, trans)
 79        case "zh":
 80            err = zhTranslations.RegisterDefaultTranslations(v, trans)
 81        default:
 82            err = enTranslations.RegisterDefaultTranslations(v, trans)
 83        }
 84        return
 85    }
 86    return
 87}
 88
 89func main() {
 90    res := map[string]string{
 91        "ice_moss.habbit": "打球",
 92        "ice_moss.from":   "贵州 中国",
 93    }
 94    fmt.Println(RemoveTopStruct(res))
 95
 96    //初始化翻译器, 翻译器代码看不懂不要紧，我们只需知道这样使用就行
 97    if err := InitTrans("zh"); err != nil {
 98        fmt.Println("初始化翻译器失败", err)
 99        return
100    }
101
102    router := gin.Default()
103    router.POST("/loginJSON", func(c *gin.Context) {
104        var login Login
105        if err := c.ShouldBind(&login); err != nil {
106            fmt.Println(err.Error())
107            errs, ok := err.(validator.ValidationErrors)
108            if !ok {
109                c.JSON(http.StatusOK, gin.H{
110                    "msg": err.Error(),
111                })
112            }
113            c.JSON(http.StatusInternalServerError, gin.H{
114                "error": errs.Translate(trans),
115            })
116            return
117        }
118        c.JSON(http.StatusOK, gin.H{
119            "msg": "验证通过",
120        })
121    })
122
123    router.POST("/signupJSON", func(c *gin.Context) {
124        var signup SignUp
125         //ShouldBind()对数据进行绑定，解组
126        if err := c.ShouldBind(&signup); err != nil {
127            fmt.Println(err.Error())
128            //获取validator.ValidationErrors类型的error
129            errs, ok := err.(validator.ValidationErrors)
130            if !ok {
131                c.JSON(http.StatusOK, gin.H{
132                    "msg": err.Error(),
133                })
134            }
135            //validator.ValidationErrors类型错误则进行翻译
136            c.JSON(http.StatusInternalServerError, gin.H{
137                "error": RemoveTopStruct(errs.Translate(trans)),
138            })
139            return
140        }
141
142        c.JSON(http.StatusOK, gin.H{
143            "msg": "注册成功",
144        })
145    })
146    router.Run(":8083")
147}

我们 POST 访问：localhost:8083/signupJSON：

如果参数不满足 tag 中的条件，则会返回如下结果

当我们输入如下满足 tag 中的条件

1{
2    "age":20,
3    "name":"ifantic",
4    "email":"uasm@linux.do",
5    "password":"123456",
6    "re_password":"123456"
7}

结构体标签验证

代码定义了两个带有验证规则的结构体，使用结构体标签设置规则：

 1type Login struct {
 2    User     string `json:"user" binding:"required"`     //必填
 3    Password string `json:"password" binding:"required"` //必填
 4}
 5
 6type SignUp struct {
 7    Age        int    `json:"age" binding:"gte=18"`                            //gte大于等于
 8    Name       string `json:"name" binding:"required"`                         //必填
 9    Email      string `json:"email" binding:"required,email"`                  //必填邮件
10    Password   string `json:"password" binding:"required"`                     //必填
11    RePassword string `json:"re_password" binding:"required,eqfield=Password"` //RePassword和Password值一致
12}

这些标签定义了如下验证规则：

required：字段不能为空
gte=18：值必须大于等于18
email：必须是有效的邮箱格式
eqfield=Password：必须与Password字段的值相等

翻译器设置

InitTrans 函数初始化了验证错误消息的翻译

1func InitTrans(locale string) (err error) {
2    // ...
3    zhT := zh.New() // 中文翻译器
4    enT := en.New() // 英文翻译器
5    uni := ut.New(enT, zhT, enT)
6    // ...
7}

这允许验证错误消息以不同语言显示（本例中为中文或英文）。

错误消息中的自定义JSON字段名

代码注册了一个自定义函数，用于在错误消息中使用JSON字段名

1v.RegisterTagNameFunc(func(field reflect.StructField) string {
2    name := strings.SplitN(field.Tag.Get("json"), ",", 2)[0]
3    if name == "-" {
4        return ""
5    }
6    return name
7})

错误消息清理

RemoveTopStruct 函数从错误消息中删除结构体名称前缀

1func RemoveTopStruct(fields map[string]string) map[string]string {
2    res := map[string]string{}
3    for field, value := range fields {
4        res[field[strings.Index(field, ".")+1:]] = value
5    }
6    return res
7}

例如，它将错误消息中的SignUp.name转换为仅name。

请求处理流程

定义了两个端点

1router.POST("/loginJSON", func(c *gin.Context) {
2    // 登录验证逻辑
3})
4
5router.POST("/signupJSON", func(c *gin.Context) {
6    // 注册验证逻辑
7})

验证工作流程：

使用c.ShouldBind(&struct)将传入的JSON绑定到结构体
检查验证错误
将错误转换为适当的类型（validator.ValidationErrors）
使用配置的翻译器翻译错误
将干净、翻译好的错误消息返回给客户端

错误响应示例

对于无效输入，API返回翻译后的验证错误

1{
2  "error": {
3    "age": "Age必须大于等于18",
4    "email": "Email为必填字段",
5    "re_password": "Re_password必须等于Password"
6  }
7}

这些验证规则来自 github.com/go-playground/validator 包，这是一个专门用于Go语言结构体和字段验证的开源库。

Validator 提供了大量内置的验证标签，可以直接在结构体标签（struct tags）中使用。

Validator 内置验证标签

比较验证

eq: 等于
ne: 不等于
gt: 大于
gte: 大于等于
lt: 小于
lte: 小于等于

字段间比较

eqfield: 与另一个字段相等
nefield: 与另一个字段不相等
gtfield: 大于另一个字段
gtefield: 大于等于另一个字段
ltfield: 小于另一个字段
ltefield: 小于等于另一个字段

字符串验证

alpha: 仅包含字母
alphanum: 仅包含字母和数字
numeric: 仅包含数字字符
number: 有效数字值
email: 有效电子邮件格式
url: 有效URL格式
uri: 有效URI格式
contains=xyz: 包含指定文本
containsany: 包含任何指定字符
excludes: 不包含指定文本
startswith: 以指定文本开头
endswith: 以指定文本结尾
lowercase: 全部为小写字符
uppercase: 全部为大写字符

长度验证

len: 精确长度
min: 最小长度
max: 最大长度

格式验证

json: 有效的JSON
jwt: 有效的JWT令牌
uuid: 有效的UUID
uuid3/4/5: 特定版本的UUID
base64: 有效的base64字符串
isbn/isbn10/isbn13: 有效的ISBN

网络验证

ip: 有效IP地址(v4或v6)
ipv4: 有效IPv4地址
ipv6: 有效IPv6地址
cidr: 有效CIDR表示法
mac: 有效MAC地址

条件验证

required: 字段必须存在且不为空
required_if: 当另一个字段等于某值时必填
required_unless: 除非另一个字段等于某值否则必填
required_with: 当任一指定字段存在时必填
required_without: 当任一指定字段不存在时必填

其他验证

oneof: 值必须是指定的多个值之一
dive: 深入切片、数组或映射并验证元素
unique: 切片/数组中的元素必须唯一
datetime: 根据给定格式的有效日期时间字符串
latitude: 有效纬度坐标
longitude: 有效经度坐标
file: 有效文件路径
iscolor: 是有效的颜色

自定义验证

validator还支持注册自定义验证函数，可以通过RegisterValidation方法添加自己的验证规则。
这些验证标签可以组合使用，例如 required,min=3,max=10 表示字段必填且长度在3到10之间。

Gin 中间件原理及自定义中间件

中间件系统会在 HTTP 请求到达路由处理器之前或生成响应后对其进行处理。

在此之前我们先来看一下 Gin 实例化 server, 我们在之前是使用 router := gin.Default()，但其实我们是可以直接使用 router := gin.New(), 那么在之前是实例中我们为什么不使用 gin.New() 呢？

别急，我们先来看看 gin.Default() 的源码：

1// Default returns an Engine instance with the Logger and Recovery middleware already attached.
2func Default() *Engine {
3    debugPrintWARNINGDefault()
4    engine := New()
5    engine.Use(Logger(), Recovery())
6    return engine
7}

我们可以看到 Default () 其实是对 gin.New() 做了一层封装，并且做了其他事情，这里的其他事情就有 “中间件”。

即：engine.Use(Logger(), Recovery()) 创建了一个新的 Gin 引擎，并已附带两个内置中间件：

Logger 中间件：输出请求日志
Recovery 中间件：从任何恐慌（panic）中恢复 (recovers) 并返回 500 错误响应

如果要使用 gin.New() 代替，那你获得的是没有附加任何中间件的干净引擎，在你想要完全控制要使用哪些中间件时很有用。

Gin 中间件原理

我们来看看：engine.Use ()：

1func (engine *Engine) Use(middleware ...HandlerFunc) IRoutes {
2    engine.RouterGroup.Use(middleware...)
3    engine.rebuild404Handlers()
4    engine.rebuild405Handlers()
5    return engine
6}

入参是 HandlerFunc 类型，Use 方法接受一个或多个类型为 HandlerFunc 的中间件函数。那么我们接着往下看 HandlerFunc：

1// HandlerFunc defines the handler used by gin middleware as return value.
2type HandlerFunc func(*Context)

其实 HandlerFunc 是 func(*Context) 类型，到这里中间件我们就可以自定义了。

自定义中间件

我们定义一个监控服务运行时间，运行状态的中间件：

 1//自定义中间件，这里我们以函数调用的形式，对中间件进一步封装
 2func MyTimeLogger() gin.HandlerFunc {
 3    return func(c *gin.Context) {          //真正的中间件类型
 4        t := time.Now()
 5        c.Set("msg", "This is a test of middleware")
 6        //它执行调用处理程序内链中的待处理处理程序
 7        //让原本执行的逻辑继续执行
 8        c.Next()
 9
10        end := time.Since(t)
11        fmt.Printf("耗时：%D\n", end.Seconds())
12        status := c.Writer.Status()
13        fmt.Println("状态监控:", status)
14    }
15}

我们在 main 函数中：

 1func main() {
 2    router := gin.Default()
 3    router.Use(MyTimeLogger())   //这里使用函数调用
 4    router.GET("/ping", func(c *gin.Context) {
 5        c.JSON(http.StatusOK, gin.H{
 6            "msg": "Pong",
 7        })
 8    })
 9    router.Run(":8083")
10}

访问 localhost:8083/ping

{"msg":"Pong"}

完整代码

 1package main
 2
 3import (
 4    "fmt"
 5    "net/http"
 6    "time"
 7    
 8    "github.com/gin-gonic/gin"
 9)
10
11// 自定义中间件，记录执行时间和状态
12func MyTimeLogger() gin.HandlerFunc {
13    return func(c *gin.Context) {
14        // 预处理：请求处理前的操作
15        t := time.Now()
16        c.Set("msg", "This is a test of middleware")
17        
18        // 将控制权传递给下一个中间件/处理程序
19        c.Next()
20        
21        // 后处理：请求处理后的操作
22        duration := time.Since(t)
23        fmt.Printf("请求耗时: %v 秒\n", duration.Seconds())
24        status := c.Writer.Status()
25        fmt.Printf("响应状态: %d\n", status)
26    }
27}
28
29func main() {
30    // 创建带有默认中间件的 Gin 路由器
31    router := gin.Default()
32    
33    // 添加我们的自定义中间件
34    router.Use(MyTimeLogger())
35    
36    // 定义路由
37    router.GET("/ping", func(c *gin.Context) {
38        // 如果需要，获取中间件数据
39        msg, exists := c.Get("msg")
40        if exists {
41            fmt.Println("来自中间件的消息:", msg)
42        }
43        
44        // 模拟一些工作
45        time.Sleep(200 * time.Millisecond)
46        
47        // 返回响应
48        c.JSON(http.StatusOK, gin.H{
49            "msg": "Pong",
50        })
51    })
52    
53    // 启动服务器
54    fmt.Println("服务器在 :8083 端口启动...")
55    router.Run(":8083")
56}

中间件工作步骤详解

当您访问 localhost:8083/ping 时:

请求首先通过 Gin 的默认中间件（Logger 和 Recovery）;
然后通过我们的自定义 MyTimeLogger 中间件，记录当前时间、向上下文添加消息、调用 c.Next()，暂停中间件并将控制权传递给后续处理程序；
/ping 的路由处理程序执行并返回 JSON 响应;
控制权返回到我们的中间件，然后计算经过的时间，持续时间和响应状态
响应被发送到客户端：{"msg":"Pong"}。

关键概念

中间件链：多个中间件可以一起使用，形成一个链，每个中间件按顺序处理请求。
c.Next()：这个函数至关重要 - 它暂停当前中间件，执行剩余的链，然后返回继续在当前中间件中执行。
上下文（Context）：Context 对象允许中间件相互之间以及与处理程序共享数据。

这种方法提供了一种干净的方式来将关注点（如日志记录、身份验证和错误处理）与主应用程序逻辑分开。

中间件实际应用

中间件非常适合用来实现身份验证逻辑，因为它可以在请求到达业务处理逻辑之前进行拦截和验证。下面的例子展示了如何使用自定义中间件来验证请求头中的令牌(Token)，即基于中间件模拟登录：

 1//自定义中间件
 2func TokenRequired() gin.HandlerFunc {
 3    return func(c *gin.Context) {
 4        var token string
 5    //从请求头中获取数据
 6        for k, v := range c.Request.Header {
 7            if k == "X-Token" {
 8                token = v[0]
 9            } else {
10                fmt.Println(k, v)
11            }
12        }
13        fmt.Println(token)
14        if token != "ice_moss" {
15            c.JSON(http.StatusUnauthorized, gin.H{
16                "msg": "认证未通过",
17            })
18
19      //return在这里不会有被执行
20            c.Abort()   //这里先不用理解，后面会讲解，这里先理解为return
21        }
22    //继续往下执行该执行的逻辑
23        c.Next()
24    }
25}

将中间件加入 gin 中：

 1func main() {
 2    router := gin.Default()
 3    //中间件
 4    router.Use(TokenRequired())
 5    router.GET("/ping", func(c *gin.Context) {
 6        c.JSON(http.StatusOK, gin.H{
 7            "msg": "Pong",
 8        })
 9    })
10    router.Run(":8083")
11}

我们在 postman 中进行请求：localhost:8083/ping，在 Headers 中增加字段：

Key	Value
X-Token	ice_moss

正确参数返回

1{
2    "msg": "Pong"
3}

不正确参数返回

1{
2    "msg": "认证未通过"
3}

这里我们围绕 c.Abort() 和 c.Next() 两个方法来对中间件原理进一步剖析。

c.Abort()

在上面的例子中我们看到：

 1func TokenRequired() gin.HandlerFunc {
 2   return func(c *gin.Context) {
 3      var token string
 4 for k, v := range c.Request.Header {
 5         if k == "X-Token" {
 6            token = v[0]
 7         } else {
 8            fmt.Println(k, v)
 9         }
10      }
11      fmt.Println(token)
12      if token != "ice_moss" {
13         c.JSON(http.StatusUnauthorized, gin.H{
14            "msg": "认证未通过",
15  })
16         //return 不会被执行，需要使用c.Abort()来结束当前
17         c.Abort()
18      }
19      //继续执行该执行的逻辑
20      c.Next()
21   }
22}

为什么 return 不能直接返回，而是使用 c.Abort()？

当我们启动服务后，Gin 会有一个类似于任务队列将所有配置的中间件和在注册处理方法压入队列中：

在处理业务代码之前，会将所有注册路由中的中间件以队列的执行方式执行，比如上面我们：

当我们在上面的例子中执行 return 时，他只是将当前函数返回，但是后面的方法仍然是按逻辑执行的，很显然这不是我们想要的结果，不满足验证条件的情况，应该将对此时的 client 终止服务。如果要终止服务就应该将图中的箭头跳过所有方法：

这样整个服务才是真正的终止。

下面来看看 c.Abort() 的代码：

1func (c *Context) Abort() {
2   c.index = abortIndex
3}

当代码执行到 Abort() 时，index 被赋值为 abortIndex。

abortIndex 是什么？

const abortIndex int8 = math.MaxInt8 >> 1

可以看到，最后 index 指向任务末端，这就是 const abortIndex int8 = math.MaxInt8 >> 1 作用的效果。

c.Next()

理解了 Abort()，Next() 自然就好理解了，我们来看看它的定义

1func (c *Context) Next() {
2   c.index++
3   for c.index < int8(len(c.handlers)) {
4      c.handlers[c.index](c)
5      c.index++
6   }
7}

执行过程

Gin 返回 html 模板

我们使用 html 模板，将后端获取到的数据，直接填充至 html 中。我们先来编写一个 html (实例为 tmpl, 无影响)：

 1<!DOCTYPE html>
 2<html lang="en">
 3<head>
 4 <meta charset="UTF-8">
 5 <title>{{ .title }}</title>
 6</head>
 7<body>
 8<h1>{{ .menu }}</h1>
 9</body>
10</html>

其中数据以 {{ .title }} 从 web 层填充进来。

1ch11
2├─ main.go
3└─ templates
4         └─ index.tmpl

我们需要注意目录结构，程序的执行入口 main 需要和模板 templates 放置同一目录下，这样保证 main 能读取文件 html：

 1package main
 2
 3import (
 4 "net/http"
 5 "github.com/gin-gonic/gin")
 6
 7func main() {
 8   router := gin.Default()
 9   //读取文件
10   router.LoadHTMLFiles("templates/index.tmpl")
11   router.GET("/index", func(c *gin.Context) {
12       //写入数据，  key必须要tmpl一致
13      c.HTML(http.StatusOK, "index.tmpl", gin.H{
14         "title": "购物网",  
15         "menu":  "菜单栏",
16  })
17   })
18   router.Run(":8085")
19}

访问 localhost:8085/index

当然 router.LoadHTMLFiles() 方法可以加载多个 html 文件：

 1package main
 2
 3import (
 4 "net/http"
 5 "github.com/gin-gonic/gin")
 6
 7func main() {
 8   router := gin.Default()
 9
10   //读取模板文件，按指定个读取
11  router.LoadHTMLFiles("templates/index.tmpl", "templates/goods.html")
12   router.GET("/index", func(c *gin.Context) {
13      c.HTML(http.StatusOK, "index.tmpl", gin.H{
14         "title": "shop",
15         "menu":  "菜单栏",
16  })
17   })
18
19   router.GET("goods", func(c *gin.Context) {
20      c.HTML(http.StatusOK, "goods.html", gin.H{
21         "title": "goods",
22         "goods": [4]string{"矿泉水", "面包", "薯片", "冰淇淋"},
23  })
24   })
25   router.Run(":8085")
26}

这样就可以访问：localhost:8085/goods 或者 localhost:8085/index 了。返回结果略

当然如果 html 文件很多，Gin 还提供了：

1func (engine *Engine) LoadHTMLGlob(pattern string) {……}

我们只需要这样调用：

1//将"templates文件夹下所有文件加载
2router.LoadHTMLGlob("templates/*")

对应二级目录，我们又是如何处理的呢？

1//加载templates目录下的目录中的所有文件
2router.LoadHTMLGlob("templates/**/*")

实例十六：

 1package main
 2
 3import (
 4 "net/http"
 5 "github.com/gin-gonic/gin")
 6
 7func main() {
 8   router := gin.Default()
 9 router.LoadHTMLGlob("templates/**/*")
10   router.GET("user/list", func(c *gin.Context) {
11      c.HTML(http.StatusOK, "list.html", gin.H{
12         "title": "shop",
13         "list":  "用户列表",
14  })
15   })
16
17   router.GET("goods/list", func(c *gin.Context) {
18      c.HTML(http.StatusOK, "list.html", gin.H{
19        "title": "shop",
20        "list":  "商品列表",
21  })
22   })
23   router.Run(":8085")
24}

与上节相似，创建 list.html：

1<!DOCTYPE html>
2<html>
3<head>
4    <title>{{ .title }}</title>
5</head>
6<body>
7    <h1>{{ .list }}</h1>
8</body>
9</html>

这样我们访问：localhost:8085/goods/list 或者 localhost:8085/user/list 都能访问到。

Gin 静态文件的挂载

在 web 开发中经常需要将 js 文件和 css 文件，进行挂载，来满足需求。目录结构：

1ch11
2├─ main.go
3├─ static
4│      └─ style.css
5└─ templates
6        └─ user
7                └─ list.html

html 文件

 1<!DOCTYPE html>
 2<html lang="en">
 3<head>
 4 <meta charset="UTF-8">
 5 <title>{{ .title }}</title>
 6 <link rel="stylesheet" href="/static/style.css">
 7</head>
 8<body>
 9<h1>{{ .list }}</h1>
10</body>
11</html>

css 文件

1*{
2    background-color: aquamarine;
3}

静态文件挂载方法：router.Static("/static", "./static")：
该方法会去在 html 文件中 <link> 标签中找到以 static 开头的链接，然后去找在当前 main 所在的目录下找到以第二个参数 ./static 名称的目录下找到静态文件，然后挂载。

实例十七：

 1package main
 2
 3import (
 4 "net/http"
 5 "github.com/gin-gonic/gin")
 6
 7func main() {
 8   router := gin.Default()
 9   //挂载静态文件
10   router.Static("/static", "./static")
11   router.LoadHTMLGlob("templates/**/*")
12   router.GET("user/list", func(c *gin.Context) {
13      c.HTML(http.StatusOK, "list.html", gin.H{
14         "title": "shop",
15  "list":  "用户列表",
16  })
17   })
18
19   router.Run(":8085")
20}

访问 localhost:8085/user/list

Gin 优雅退出

在业务中，我们很多时候涉及到服务的退出，如：各种订单处理中，用户突然退出，支付费用时，程序突然退出，这里我们是需要是我们的服务合理的退出，进而不造成业务上的矛盾。实例十八：

 1package main
 2
 3import (
 4 "net/http"
 5 "github.com/gin-gonic/gin")
 6
 7func main() {
 8   router := gin.Default()
 9   router.GET("ping", func(c *gin.Context) {
10      c.JSON(http.StatusOK, gin.H{
11         "msg": "ping",
12  })
13   })
14
15   go func() {
16      router.Run(":8085")
17   }()
18
19   qiut := make(chan os.Signal)
20   //接收control+c
21   //当接收到退出指令时，我们向chan收数据
22  signal.Notify(qiut, syscall.SIGINT, syscall.SIGTERM)
23   <-qiut
24
25 //服务退出前做处理
26   fmt.Println("服务退出中")
27   fmt.Println("服务已退出")
28}

在 terminal 中运行：go run main.go。服务启动后在 terminal 中退出 (control+c) 就可以看到:

1[GIN-debug] Listening and serving HTTP on :8085
2服务退出中
3服务已退出

小记

累 ~

Go 萌新的初学之路 IV

Mon, 21 Apr 2025 20:12:11 +0800

`Go` 协程

Go 程（goroutine）是由 Go 运行时管理的轻量级线程：go f(x, y, z)，会启动一个新的 Go 协程并执行 f(x, y, z)。
f, x, y 和 z 的求值发生在当前的 Go 协程中，而 f 的执行发生在新的 Go 协程中。

Go 程在相同的地址空间中运行，因此在访问共享的内存时必须进行同步。sync 包提供了这种能力，不过在 Go 中并不经常用到，因为还有其它的办法（见下一页）。

 1package main
 2
 3import (
 4	"fmt"
 5	"time"
 6)
 7
 8func say(s string) {
 9	for i := 0; i < 5; i++ {
10		time.Sleep(100 * time.Millisecond)
11		fmt.Println(s)
12	}
13}
14
15func main() {
16	go say("world")
17	say("hello")
18}

输出

hello
world
world
hello
hello
world
world
hello
hello

主程序完成 say("hello")（打印 5 次后）后，程序退出。此时，say("world") 例行程序只来得及打印 4 次。

信道

信道（Channel）是带有类型的（通信）管道，你可以通过它用信道操作符 <- 来发送或者接收值，“箭头”就是数据流的方向，允许数据在不同的 Go 协程（goroutine）之间流动。信道是 Go 语言并发编程的核心工具之一，使得不同的并发任务能够安全地交换数据。

1ch <- v // 将 v 发送至信道 ch。
2v := <-ch // 从 ch 接收值并赋予 v。

和映射与切片一样，信道在使用前必须创建：ch := make(chan int)。默认情况下，发送和接收操作在另一端准备好之前都会阻塞。这使得 Go 程可以在没有显式的锁或竞态变量的情况下进行同步。以下示例对切片中的数进行求和，将任务分配给两个 Go 程。一旦两个 Go 程完成了它们的计算，它就能算出最终的结果。

 1package main
 2
 3import "fmt"
 4
 5func sum(s []int, c chan int) {
 6	sum := 0
 7	for _, v := range s {
 8		sum += v
 9	}
10	c <- sum // 发送 sum 到 c
11}
12
13func main() {
14	s := []int{7, 2, 8, -9, 4, 0}
15
16	c := make(chan int)
17	go sum(s[:len(s)/2], c)
18	go sum(s[len(s)/2:], c)
19	x, y := <-c, <-c // 从 c 接收
20
21	fmt.Println(x, y, x+y)
22}

输出

-5 17 12

有一组数字 {7, 2, 8, -9, 4, 0}，将它分成两半。第一个计算 {7, 2, 8} 的和，第二个计算 {-9, 4, 0} 的和；
创建一个信道 c；
两个通道（用 go 关键字启动）同时独立工作，计算各自负责部分的总和；
main 函数在 x, y := <-c, <-c 处等待，直到信道 c 传回各自的结果。

带缓冲的信道

信道可以是带缓冲的。将缓冲长度作为第二个参数提供给 make 来初始化一个带缓冲的信道。
ch := make(chan int, 100) 创建了一个可以存储100个整数的缓冲区。
仅当信道的缓冲区填满后，向其发送数据时才会阻塞。当缓冲区为空时，接受方会阻塞。

 1package main
 2
 3import "fmt"
 4
 5func main() {
 6	ch := make(chan int, 2)
 7	ch <- 1
 8	ch <- 2
 9	fmt.Println(<-ch)
10	fmt.Println(<-ch)
11}

信道有2个空位，所以前两次发送操作都不会阻塞
如果尝试发送第三个值 ch <- 3（当缓冲区已满），程序会阻塞直到有人从信道接收值
当缓冲区有值时，接收操作不会阻塞
如果缓冲区为空时尝试接收，程序会阻塞直到有新值发送到信道

带缓冲的信道提供了一种异步通信机制，让发送方和接收方不必同时准备好，提高了程序的并发效率。

range 和 close

发送者可通过 close 关闭一个信道来表示没有需要发送的值了。接收者可以通过为接收表达式分配第二个参数来测试信道是否被关闭：若没有值可以接收且信道已被关闭，那么在执行完 v, ok := <-ch，此时 ok 会被设置为 false。

当从 channel 接收数据时，可以使用两个返回值的形式来检查 channel 是否已关闭：

1v, ok := <-ch

如果 ok 是 true：成功接收到值，v 是接收到的值
如果 ok 是 false：channel 已关闭且没有更多值可接收，v 是该类型的零值

信息

只应由发送者关闭信道，而不应油接收者关闭。向一个已经关闭的信道发送数据会引发程序 panic。

信息

信道与文件不同，通常情况下无需关闭它们。只有在必须告诉接收者不再有需要发送的值时才有必要关闭，例如终止一个 range 循环。

 1package main
 2
 3import (
 4	"fmt"
 5)
 6
 7func fibonacci(n int, c chan int) {
 8    x, y := 0, 1
 9    for i := 0; i < n; i++ {
10        c <- x         // 将斐波那契数列的值发送到 channel
11        x, y = y, x+y  // 计算下一个斐波那契数
12    }
13    close(c)  // 发送完毕后关闭 channel
14}
15
16func main() {
17    c := make(chan int, 10)  // 创建一个容量为 10 的缓冲 channel
18    `Go` fibonacci(cap(c), c)  // 启动一个协程，生成斐波那契数并发送到 channel
19    for i := range c {       // 不断从 channel 接收值，直到它被关闭
20        fmt.Println(i)
21    }
22}

输出

0
1
1
2
3
5
8
13
21
34

创建一个缓冲容量为 10 的 channel
启动一个新的 goroutine 来计算斐波那契数列
fibonacci 函数向 channel 中发送 10 个斐波那契数
发送完后，fibonacci 函数关闭 channel
main 函数中的 range 循环接收 channel 中的所有值并打印
当 channel 关闭且没有更多值时，range 循环结束

range 与 channel

for i := range c 循环提供了一种更简洁的方式来不断从 channel 接收值，直到它被关闭：

1for i := range c {
2    fmt.Println(i)
3}

这相当于：

1for {
2    i, ok := <-c
3    if !ok {
4        break  // channel 已关闭，退出循环
5    }
6    fmt.Println(i)
7}

select 语句

select 语句使一个 Go 程可以等待多个通信操作。它会阻塞到某个分支可以继续执行为止，这时就会执行该分支。当多个分支都准备好时会随机选择一个执行。

 1package main
 2
 3import "fmt"
 4
 5func fibonacci(c, quit chan int) {
 6	x, y := 0, 1
 7	for {
 8		select {
 9		case c <- x:
10			x, y = y, x+y
11		case <-quit:
12			fmt.Println("quit")
13			return
14		}
15	}
16}
17
18func main() {
19	c := make(chan int)
20	quit := make(chan int)
21	go func() {
22		for i := 0; i < 10; i++ {
23			fmt.Println(<-c)
24		}
25		quit <- 0
26	}()
27	fibonacci(c, quit)
28}

输出

0
1
1
2
3
5
8
13
21
34
quit

有两个通道：c（用于发送斐波那契数）和 quit（用于结束程序）
无限循环中的 select 语句在等待两种可能的操作：
- 发送操作：将当前的斐波那契数发送到 c 通道
- 接收操作：从 quit 通道接收退出信号

 1func main() {
 2    c := make(chan int)
 3    quit := make(chan int)
 4    `Go` func() {
 5        for i := 0; i < 10; i++ {
 6            fmt.Println(<-c)
 7        }
 8        quit <- 0
 9    }()
10    fibonacci(c, quit)
11}

主函数中：

创建了两个通道：c 和 quit；
启动了一个匿名 goroutine，接收并打印 10 个斐波那契数，发送退出信号到 quit 通道；
调用 fibonacci 函数。

select 的特殊情况

多个通道就绪：如果多个 case 同时准备好，select 会随机选择一个执行 没有通道就绪：select 会阻塞，直到某个通道可以操作。
default 分支：如果包含 default 分支，当没有其他通道操作可以进行时会执行 default，使 select 变成非阻塞的。

默认选择

当 select 中的其它分支都没有准备好时，default 分支就会执行。为了在尝试发送或者接收时不发生阻塞，可使用 default 分支：

1select {
2    case i := <-c:
3        // 使用 i
4    default:
5        // 从 c 中接收会阻塞时执行
6}

 1package main
 2
 3import (
 4	"fmt"
 5	"time"
 6)
 7
 8func main() {
 9	tick := time.Tick(100 * time.Millisecond)
10	boom := time.After(500 * time.Millisecond)
11	for {
12		select {
13		case <-tick:
14			fmt.Println("tick.")
15		case <-boom:
16			fmt.Println("BOOM!")
17			return
18		default:
19			fmt.Println("    .")
20			time.Sleep(50 * time.Millisecond)
21		}
22	}
23}

输出

 1    .
 2    .
 3tick.
 4    .
 5    .
 6tick.
 7    .
 8    .
 9tick.
10    .
11    .
12tick.
13    .
14    .
15BOOM!

在 Go 语言中，select 是一种处理多个通道(channel)操作的机制。它类似于 switch 语句，但专门用于通道操作。select 语句会监听多个通道，并在某个通道准备好时执行相应的代码块。

default 分支的核心作用是：当 select 中的其他条件分支都没有准备好时，default 分支会被执行。这是实现非阻塞操作的关键。

如果没有 default：select 会一直等待，直到某个通道可以操作
有 default：如果所有通道都不能立即操作，就执行 default 分支代码

 1func main() {
 2    tick := time.Tick(100 * time.Millisecond)
 3    boom := time.After(500 * time.Millisecond)
 4    for {
 5        select {
 6        case <-tick:
 7            fmt.Println("tick.")
 8        case <-boom:
 9            fmt.Println("BOOM!")
10            return
11        default:
12            fmt.Println("    .")
13            time.Sleep(50 * time.Millisecond)
14        }
15    }
16}

这个例子生动展示了 select 和 default 的使用场景：

tick 通道每 100 毫秒产生一个信号
boom 通道在 500 毫秒后产生一个信号
程序在无限循环中：

如果 tick 通道有数据，打印 “tick.”
如果 boom 通道有数据，打印 “BOOM!” 并结束程序
如果两个通道都没准备好，执行 default：打印 " ." 并等待 50 毫秒

程序运行效果大致是：

刚开始，两个通道都没数据，所以执行 default（约每 50ms 打印一个点）
每 100ms，tick 通道会准备好，此时打印 “tick.”
500ms 后，boom 通道准备好，打印 “BOOM!” 并退出

select 的一个重要特点是：整个 select 代码段只执行一次，如果没有可用的通道操作，就会执行 default 分支。这里因为有 for 循环，所以 select 会被反复执行，使我们能看到不同时间点的行为。

练习：等价二叉查找树

不同二叉树的叶节点上可以保存相同的值序列。例如，以下两个二叉树都保存了序列 1，1，2，3，5，8，13。

在大多数语言中，检查两个二叉树是否保存了相同序列的函数都相当复杂。我们将使用 Go 的并发和信道来编写一个简单的解法。

本例使用了 tree 包，它定义了类型：

1type Tree struct {
2    Left  *Tree
3    Value int
4    Right *Tree
5}

1. 实现 Walk 函数。
2. 测试 Walk 函数。

函数 tree.New(k) 用于构造一个随机结构的已排序二叉查找树，它保存了值 k, 2k, 3k, …, 10k。
创建一个新的信道 ch 并且对其进行步进：go Walk(tree.New(1), ch)；然后从信道中读取并打印 10 个值。应当是数字 1, 2, 3, …, 10.

3. 用 Walk 实现 Same 函数来检测 t1 和 t2 是否存储了相同的值。
4. 测试 Same 函数。

Same(tree.New(1), tree.New(1)) 应当返回 true，而 Same(tree.New(1), tree.New(2)) 应当返回 false。

Tree 的文档可在这里找到。

Walk 函数实现

Walk 函数需要遍历二叉树并将所有值发送到信道。我们可以使用中序遍历（左子树-节点-右子树）实现这一点：

范例

 1// Walk 遍历树 t，将树中所有的值发送到信道 ch
 2func Walk(t *tree.Tree, ch chan int) {
 3    // 定义一个递归的辅助函数进行树的遍历
 4    var walkTree func(t *tree.Tree)
 5    walkTree = func(t *tree.Tree) {
 6        if t == nil {
 7            return
 8        }
 9        // 先遍历左子树
10        walkTree(t.Left)
11        // 发送当前节点的值
12        ch <- t.Value
13        // 再遍历右子树
14        walkTree(t.Right)
15    }
16    
17    walkTree(t)
18    close(ch) // 遍历结束后关闭信道
19}

Same 函数实现

Same 函数用于检查两个二叉树是否包含相同的值序列：

范例

 1// Same 判断 t1 和 t2 是否包含相同的值
 2func Same(t1, t2 *tree.Tree) bool {
 3    ch1 := make(chan int)
 4    ch2 := make(chan int)
 5    
 6    `Go` Walk(t1, ch1)
 7    `Go` Walk(t2, ch2)
 8    
 9    // 比较两个树的遍历结果
10    for {
11        v1, ok1 := <-ch1
12        v2, ok2 := <-ch2
13        
14        // 如果通道状态不同或值不同，则树不相等
15        if ok1 != ok2 || v1 != v2 {
16            return false
17        }
18        
19        // 如果两个通道都已关闭，并且所有值都匹配，则树相等
20        if !ok1 {
21            break
22        }
23    }
24    
25    return true
26}

主函数（测试）

范例

 1func main() {
 2    // 测试 Walk 函数
 3    fmt.Println("测试 Walk 函数:")
 4    ch := make(chan int)
 5    `Go` Walk(tree.New(1), ch)
 6    
 7    // 应该打印出 1 到 10 的数字
 8    for i := 0; i < 10; i++ {
 9        fmt.Printf("%d ", <-ch)
10    }
11    fmt.Println()
12    
13    // 测试 Same 函数
14    fmt.Println("测试 Same 函数:")
15    fmt.Println("Same(tree.New(1), tree.New(1)):", Same(tree.New(1), tree.New(1)))
16    fmt.Println("Same(tree.New(1), tree.New(2)):", Same(tree.New(1), tree.New(2)))
17}

完整代码

代码

 1package main
 2
 3import (
 4    "fmt"
 5    "golang.org/x/tour/tree"
 6)
 7
 8// Walk 遍历树 t，将树中所有的值发送到信道 ch
 9func Walk(t *tree.Tree, ch chan int) {
10    var walkTree func(t *tree.Tree)
11    walkTree = func(t *tree.Tree) {
12        if t == nil {
13            return
14        }
15        walkTree(t.Left)
16        ch <- t.Value
17        walkTree(t.Right)
18    }
19    
20    walkTree(t)
21    close(ch)
22}
23
24// Same 判断 t1 和 t2 是否包含相同的值
25func Same(t1, t2 *tree.Tree) bool {
26    ch1 := make(chan int)
27    ch2 := make(chan int)
28    
29    `Go` Walk(t1, ch1)
30    `Go` Walk(t2, ch2)
31    
32    for {
33        v1, ok1 := <-ch1
34        v2, ok2 := <-ch2
35        
36        if ok1 != ok2 || v1 != v2 {
37            return false
38        }
39        
40        if !ok1 {
41            break
42        }
43    }
44    
45    return true
46}
47
48func main() {
49    // 测试 Walk 函数
50    fmt.Println("测试 Walk 函数:")
51    ch := make(chan int)
52    `Go` Walk(tree.New(1), ch)
53    
54    for i := 0; i < 10; i++ {
55        fmt.Printf("%d ", <-ch)
56    }
57    fmt.Println()
58    
59    // 测试 Same 函数
60    fmt.Println("测试 Same 函数:")
61    fmt.Println("Same(tree.New(1), tree.New(1)):", Same(tree.New(1), tree.New(1)))
62    fmt.Println("Same(tree.New(1), tree.New(2)):", Same(tree.New(1), tree.New(2)))
63}

测试 Walk 函数:
1 2 3 4 5 6 7 8 9 10
测试 Same 函数:
Same(tree.New(1), tree.New(1)): true
Same(tree.New(1), tree.New(2)): false

注意：这个实现使用了中序遍历，确保了我们从二叉查找树中获取的值是按顺序排列的，这对于比较两棵树是否包含相同的值序列非常重要。

sync.Mutex

我们已经看到信道非常适合在各个 Go 程间进行通信。但是如果我们并不需要通信呢？比如说，若我们只是想保证每次只有一个 Go 程能够访问一个共享的变量，从而避免冲突？

这里涉及的概念叫做 互斥（mutualexclusion）* ，我们通常使用 互斥锁（Mutex） 这一数据结构来提供这种机制。Go 标准库中提供了 sync.Mutex 互斥锁类型及其两个方法：

Lock
Unlock

我们可以通过在代码前调用 Lock 方法，在代码后调用 Unlock 方法来保证一段代码的互斥执行。参见 Inc 方法。我们也可以用 defer 语句来保证互斥锁一定会被解锁。参见 Value 方法。

 1package main
 2
 3import (
 4	"fmt"
 5	"sync"
 6	"time"
 7)
 8
 9// SafeCounter 是并发安全的
10type SafeCounter struct {
11	mu sync.Mutex
12	v  map[string]int
13}
14
15// Inc 对给定键的计数加一
16func (c *SafeCounter) Inc(key string) {
17	c.mu.Lock()
18	// 锁定使得一次只有一个 `Go` 协程可以访问映射 c.v。
19	c.v[key]++
20	c.mu.Unlock()
21}
22
23// Value 返回给定键的计数的当前值。
24func (c *SafeCounter) Value(key string) int {
25	c.mu.Lock()
26	// 锁定使得一次只有一个 `Go` 协程可以访问映射 c.v。
27	defer c.mu.Unlock()
28	return c.v[key]
29}
30
31func main() {
32	c := SafeCounter{v: make(map[string]int)}
33	for i := 0; i < 1000; i++ {
34		go c.Inc("somekey")
35	}
36
37	time.Sleep(time.Second)
38	fmt.Println(c.Value("somekey"))
39}

输出

1000

SafeCounter 结构体：包含一个互斥锁和一个映射（Go 中的 map 不是并发安全的）
Inc 方法：

在增加计数器前锁定互斥锁
操作完成后解锁

Value 方法：

在读取前锁定互斥锁
使用 defer 确保函数返回时互斥锁始终会被解锁

互斥锁（Mutex）

互斥锁（Mutex，“mutual exclusion"的缩写）是并发编程中的一种同步机制，用于防止多个 goroutine 同时访问共享资源。在 Go 语言中，sync.Mutex 是最常用的同步原语之一为什么我们需要互斥锁？

Go 的 goroutine 让并发编程变得简单——只需在函数调用前添加 go 关键字即可启动并发执行。然而，当多个 goroutine 访问相同数据时：

没有保护：会发生数据竞争，导致不可预测的行为
使用互斥锁保护：goroutine 会轮流安全地访问共享资源

sync.Mutex 的工作原理

Go 中的互斥锁提供两个基本方法：

Lock()：获取独占访问权（如果已被锁定则阻塞）
Unlock()：释放互斥锁的独占访问权就像是一把房间的钥匙——只有持有钥匙的 goroutine 才能进入，其他 goroutine 必须等待钥匙被归还。

main() 函数启动了 1000 个 goroutine，它们都试图增加同一个计数器。如果没有互斥锁，这会导致竞态条件。

练习：Web 爬虫

在这个练习中，我们将会使用 Go 的并发特性来并行化一个 Web 爬虫。修改 Crawl 函数来并行地抓取 URL，使爬虫能够并行地爬取多个网页，同时确保不重复爬取同一个页面。

提示： 你可以用一个 map 来缓存已经获取的 URL，但是要注意 map 本身并不是并发安全的！

 1package main
 2
 3import (
 4	"fmt"
 5)
 6
 7type Fetcher interface {
 8	// Fetch 返回 URL 所指向页面的 body 内容，
 9	// 并将该页面上找到的所有 URL 放到一个切片中。
10	Fetch(url string) (body string, urls []string, err error)
11}
12
13// Crawl 用 fetcher 从某个 URL 开始递归的爬取页面，直到达到最大深度。
14func Crawl(url string, depth int, fetcher Fetcher) {
15	// TODO: 并行地爬取 URL。
16	// TODO: 不重复爬取页面。
17	// 下面并没有实现上面两种情况：
18	if depth <= 0 {
19		return
20	}
21	body, urls, err := fetcher.Fetch(url)
22	if err != nil {
23		fmt.Println(err)
24		return
25	}
26	fmt.Printf("found: %s %q\n", url, body)
27	for _, u := range urls {
28		Crawl(u, depth-1, fetcher)
29	}
30	return
31}
32
33func main() {
34	Crawl("https://golang.org/", 4, fetcher)
35}
36
37// fakeFetcher 是待填充结果的 Fetcher。
38type fakeFetcher map[string]*fakeResult
39
40type fakeResult struct {
41	body string
42	urls []string
43}
44
45func (f fakeFetcher) Fetch(url string) (string, []string, error) {
46	if res, ok := f[url]; ok {
47		return res.body, res.urls, nil
48	}
49	return "", nil, fmt.Errorf("not found: %s", url)
50}
51
52// fetcher 是填充后的 fakeFetcher。
53var fetcher = fakeFetcher{
54	"https://golang.org/": &fakeResult{
55		"The `Go` Programming Language",
56		[]string{
57			"https://golang.org/pkg/",
58			"https://golang.org/cmd/",
59		},
60	},
61	"https://golang.org/pkg/": &fakeResult{
62		"Packages",
63		[]string{
64			"https://golang.org/",
65			"https://golang.org/cmd/",
66			"https://golang.org/pkg/fmt/",
67			"https://golang.org/pkg/os/",
68		},
69	},
70	"https://golang.org/pkg/fmt/": &fakeResult{
71		"Package fmt",
72		[]string{
73			"https://golang.org/",
74			"https://golang.org/pkg/",
75		},
76	},
77	"https://golang.org/pkg/os/": &fakeResult{
78		"Package os",
79		[]string{
80			"https://golang.org/",
81			"https://golang.org/pkg/",
82		},
83	},
84}

思路：

使用 goroutines 实现并行爬取：为每个URL创建一个goroutine来并行爬取
使用 map 跟踪已访问的URL：创建一个映射表来记录已经爬取过的URL
使用 mutex 保护共享数据：因为多个goroutine会同时访问映射表，需要使用互斥锁保护它
使用 WaitGroup 等待所有爬取完成：确保所有并行的爬取任务都完成后再结束程序实现示例

Fetcher 接口：定义了如何获取网页内容的方法

1type Fetcher interface {
2    // 获取URL内容并返回页面上的所有链接
3    Fetch(url string) (body string, urls []string, err error)
4}

Crawl 函数：目前是按顺序爬取网页的函数，需要使其并行工作

1func Crawl(url string, depth int, fetcher Fetcher) {
2    // 需要修改的部分
3}

fakeFetcher：一个模拟的网页获取器，用于测试我们的爬虫程序

输出

  1package main
  2
  3import (
  4	"fmt"
  5	"sync"
  6)
  7
  8type Fetcher interface {
  9	Fetch(url string) (body string, urls []string, err error)
 10}
 11
 12// SafeCache provides thread-safe access to the visited URLs map
 13type SafeCache struct {
 14	visited map[string]bool
 15	mux     sync.Mutex
 16}
 17
 18// CheckAndMark checks if URL was visited and marks it as visited
 19func (c *SafeCache) CheckAndMark(url string) bool {
 20	c.mux.Lock()
 21	defer c.mux.Unlock()
 22	if c.visited[url] {
 23		return true // Already visited
 24	}
 25	c.visited[url] = true
 26	return false // First time visiting
 27}
 28
 29// Crawl uses fetcher to recursively crawl pages starting with url, to a maximum of depth.
 30func Crawl(url string, depth int, fetcher Fetcher) {
 31	// Create a cache for tracking visited URLs
 32	cache := &SafeCache{visited: make(map[string]bool)}
 33	
 34	// WaitGroup to track all goroutines
 35	var wg sync.WaitGroup
 36	
 37	// Define crawl function to use in goroutines
 38	var crawler func(string, int)
 39	crawler = func(url string, depth int) {
 40		defer wg.Done()
 41		
 42		// Stop if we've reached max depth
 43		if depth <= 0 {
 44			return
 45		}
 46		
 47		// Check if we've already visited this URL
 48		if cache.CheckAndMark(url) {
 49			return
 50		}
 51		
 52		body, urls, err := fetcher.Fetch(url)
 53		if err != nil {
 54			fmt.Println(err)
 55			return
 56		}
 57		fmt.Printf("found: %s %q\n", url, body)
 58		
 59		// Create a goroutine for each URL
 60		for _, u := range urls {
 61			wg.Add(1)
 62			go crawler(u, depth-1)
 63		}
 64	}
 65	
 66	// Start the first crawl
 67	wg.Add(1)
 68	go crawler(url, depth)
 69	
 70	// Wait for all crawling to complete
 71	wg.Wait()
 72}
 73
 74func main() {
 75	Crawl("https://golang.org/", 4, fetcher)
 76}
 77
 78// fakeFetcher is Fetcher that returns canned results.
 79type fakeFetcher map[string]*fakeResult
 80
 81type fakeResult struct {
 82	body string
 83	urls []string
 84}
 85
 86func (f fakeFetcher) Fetch(url string) (string, []string, error) {
 87	if res, ok := f[url]; ok {
 88		return res.body, res.urls, nil
 89	}
 90	return "", nil, fmt.Errorf("not found: %s", url)
 91}
 92
 93// fetcher is a populated fakeFetcher.
 94var fetcher = fakeFetcher{
 95	"https://golang.org/": &fakeResult{
 96		"The Go Programming Language",
 97		[]string{
 98			"https://golang.org/pkg/",
 99			"https://golang.org/cmd/",
100		},
101	},
102	"https://golang.org/pkg/": &fakeResult{
103		"Packages",
104		[]string{
105			"https://golang.org/",
106			"https://golang.org/cmd/",
107			"https://golang.org/pkg/fmt/",
108			"https://golang.org/pkg/os/",
109		},
110	},
111	"https://golang.org/pkg/fmt/": &fakeResult{
112		"Package fmt",
113		[]string{
114			"https://golang.org/",
115			"https://golang.org/pkg/",
116		},
117	},
118	"https://golang.org/pkg/os/": &fakeResult{
119		"Package os",
120		[]string{
121			"https://golang.org/",
122			"https://golang.org/pkg/",
123		},
124	},
125}

1found: https://golang.org/ "The Go Programming Language"
2not found: https://golang.org/cmd/
3found: https://golang.org/pkg/ "Packages"
4found: https://golang.org/pkg/os/ "Package os"
5found: https://golang.org/pkg/fmt/ "Package fmt"

小记

没有小记

进阶教程：

build-web-application-with-golang

《Go入门指南》

GoWeb框架Gin学习总结 | Go 技术论坛

Go 萌新的初学之路 III

Fri, 18 Apr 2025 11:18:57 +0800

方法

在 Go 语言中，方法是一种特殊的函数，它与特定类型相关联。与其他面向对象语言不同，Go 没有类的概念，但允许你在任何自定义类型上定义方法。方法接收者在它自己的参数列表内，位于 func 关键字和方法名之间。在此例中，Abs 方法拥有一个名字为 v，类型为 Vertex 的接收者。

 1package main
 2
 3import (
 4    "fmt"
 5    "math"
 6)
 7
 8type Vertex struct {
 9    X, Y float64
10}
11
12func (v Vertex) Abs() float64 {
13    return math.Sqrt(v.X*v.X + v.Y*v.Y)
14}
15
16func main() {
17    v := Vertex{3, 4}
18    fmt.Println(v.Abs())
19}

输出

什么是方法？

在 Go 语言中，方法其实就是一种特殊的函数，只不过这个函数和某个特定的数据类型关联在一起了，可以把它想象成是"某种类型专属的函数"。
接收者就是那个拥有这个方法的具体对象。你可以把它理解为：

普通函数是独立的，任何人都可以调用
方法是"专属"的，只有特定类型的对象才能调用

实际例子

 1package main
 2
 3import (
 4    "fmt"
 5    "math"
 6)
 7
 8type Circle struct {
 9    radius float64
10}
11
12// 这是一个方法，属于Circle类型
13func (c Circle) Area() float64 {
14    return math.Pi * c.radius * c.radius
15}
16
17func main() {
18    myCircle := Circle{radius: 5}
19    
20    // 调用方法
21    circleArea := myCircle.Area()
22    fmt.Println("圆的面积是:", circleArea)
23}

输出

圆的面积是: 78.53981633974483

在这个例子中：

我们创建了一个 Circle 类型
给这个类型定义了一个计算面积的方法 Area
(c Circle) 是接收者，表示这个方法只属于 Circle 类型
当我们创建一个圆 myCircle 后，可以用点号调用它的方法：myCircle.Area()

值接收者与指针接收者的区别

Go 语言中方法的接收者可以是值也可以是指针，这有点类似于：

值接收者：你给朋友看照片，他只能看不能改指针接收者：你把实物给朋友，他可以修改它

1// 值接收者 - 不会修改原始数据
2func (c Circle) Double() {
3    c.radius = c.radius * 2  // 这个修改不会影响到原始的Circle
4}
5
6// 指针接收者 - 会修改原始数据
7func (c *Circle) RealDouble() {
8    c.radius = c.radius * 2  // 这个修改会真正改变Circle的radius
9}

方法即函数

如上所说，方法只是个带接收者参数的函数。现在这个 Abs 的写法就是个正常的函数，功能并没有什么变化。

 1package main
 2
 3import (
 4    "fmt"
 5    "math"
 6)
 7
 8type Vertex struct {
 9    X, Y float64
10}
11
12func Abs(v Vertex) float64 {
13    return math.Sqrt(v.X*v.X + v.Y*v.Y)
14}
15
16func main() {
17    v := Vertex{3, 4}
18    fmt.Println(Abs(v))
19}

输出

你也可以为非结构体类型声明方法。在下面的例子里，我们看到了一个带 Abs 方法的数值类型 MyFloat。
你只能为在同一个包中定义的接收者类型声明方法，而不能为其它别的包中定义的类型（包括 int 之类的内置类型）声明方法。
就是说接收者的类型定义和方法声明必须在同一包内。因此下面的例子是创建了 MyFloat 类型，而不是直接为 float64 添加方法。

 1package main
 2
 3import (
 4    "fmt"
 5    "math"
 6)
 7
 8type MyFloat float64
 9
10func (f MyFloat) Abs() float64 {
11    if f < 0 {
12        return float64(-f)
13    }
14    return float64(f)
15}
16
17func main() {
18    f := MyFloat(-math.Sqrt2)
19    fmt.Println(f.Abs())
20}

输出

1.4142135623730951

指针类型的接收者

你可以为指针类型的接收者声明方法。

这意味着对于某类型 T，接收者的类型可以用 *T 的文法。（此外，T 本身不能是指针，比如不能是 *int。）
指针接收者的方法可以修改接收者指向的值。由于方法经常需要修改它的接收者，指针接收者比值接收者更常用。
例如，下面为 *Vertex 定义了 Scale 方法。

 1package main
 2
 3import (
 4    "fmt"
 5    "math"
 6)
 7
 8type Vertex struct {
 9    X, Y float64
10}
11
12func (v Vertex) Abs() float64 {
13    return math.Sqrt(v.X*v.X + v.Y*v.Y)
14}
15
16func (v *Vertex) Scale(f float64) {
17    v.X = v.X * f
18    v.Y = v.Y * f
19}
20
21func main() {
22    v := Vertex{3, 4}
23    v.Scale(10)
24    fmt.Println(v.Abs())
25}

输出

试着移除第 16 行 Scale 函数声明中的 *，观察此程序的行为如何变化。

若使用值接收者，那么 Scale 方法会对原始 Vertex 值的副本进行操作。（对于函数的其它参数也是如此。）Scale 方法必须用指针接收者来更改 main 函数中声明的 Vertex 的值。

 1package main
 2
 3import (
 4    "fmt"
 5    "math"
 6)
 7
 8type Vertex struct {
 9    X, Y float64
10}
11
12func (v Vertex) Abs() float64 {
13    return math.Sqrt(v.X*v.X + v.Y*v.Y)
14}
15
16func (v Vertex) Scale(f float64) {
17    v.X = v.X * f
18    v.Y = v.Y * f
19}
20
21func main() {
22    v := Vertex{3, 4}
23    v.Scale(10)
24    fmt.Println(v.Abs()) // output: 5
25}

输出

指针与函数

现在我们要把 Abs 和 Scale 方法重写为函数。

 1package main
 2
 3import (
 4    "fmt"
 5    "math"
 6)
 7
 8type Vertex struct {
 9    X, Y float64
10}
11
12func Abs(v Vertex) float64 {
13    return math.Sqrt(v.X*v.X + v.Y*v.Y)
14}
15
16func Scale(v *Vertex, f float64) {
17    v.X = v.X * f
18    v.Y = v.Y * f
19}
20
21func main() {
22    v := Vertex{3, 4}
23    Scale(&v, 10)
24    fmt.Println(Abs(v))
25}

输出

方法与指针重定向

 1package main
 2
 3import "fmt"
 4
 5type Vertex struct {
 6    X, Y float64
 7}
 8
 9func (v *Vertex) Scale(f float64) {
10    v.X = v.X * f
11    v.Y = v.Y * f
12}
13
14func ScaleFunc(v *Vertex, f float64) {
15    v.X = v.X * f
16    v.Y = v.Y * f
17}
18
19func main() {
20    v := Vertex{3, 4}
21    v.Scale(2)
22    ScaleFunc(&v, 10)
23
24    p := &Vertex{4, 3}
25    p.Scale(3)
26    ScaleFunc(p, 8)
27
28    fmt.Println(v, p)
29}

输出

{60 80} &{96 72}

比较前两个程序，你大概会注意到带指针参数的函数必须接受一个指针：

1var v Vertex
2ScaleFunc(v, 5) // 编译错误！
3ScaleFunc(&v, 5) // OK

而接收者为指针的的方法被调用时，接收者既能是值又能是指针：

1var v Vertex
2v.Scale(5) // OK
3p := &v
4p.Scale(10) // OK

对于语句 v.Scale(5) 来说，即便 v 是一个值而非指针，带指针接收者的方法也能被直接调用。也就是说，由于 Scale 方法有一个指针接收者，为方便起见，Go 会将语句 v.Scale(5) 解释为 (&v).Scale(5)。

 1package main
 2
 3import (
 4    "fmt"
 5    "math"
 6)
 7
 8type Vertex struct {
 9    X, Y float64
10}
11
12func (v Vertex) Abs() float64 {
13    return math.Sqrt(v.X*v.X + v.Y*v.Y)
14}
15
16func AbsFunc(v Vertex) float64 {
17    return math.Sqrt(v.X*v.X + v.Y*v.Y)
18}
19
20func main() {
21    v := Vertex{3, 4}
22    fmt.Println(v.Abs())
23    fmt.Println(AbsFunc(v))
24
25    p := &Vertex{4, 3}
26    fmt.Println(p.Abs())
27    fmt.Println(AbsFunc(*p))
28}

输出

5
5
5
5

这种情况下，方法调用 p.Abs() 会被解释为 (*p).Abs()。

1var v Vertex
2fmt.Println(AbsFunc(v)) // OK
3fmt.Println(AbsFunc(&v)) // 编译错误！

而以值为接收者的方法被调用时，接收者既能为值又能为指针：

1var v Vertex
2fmt.Println(v.Abs()) // OK
3p := &v
4fmt.Println(p.Abs()) // OK

选择值或指针作为接收者

使用指针接收者的原因有二：方法能够修改其接收者指向的值，还可以避免在每次调用方法时复制该值。若值的类型为大型结构体时，这样会更加高效。

在本例中，Scale 和 Abs 接收者的类型为 *Vertex，即便 Abs 并不需要修改其接收者。

通常来说，所有给定类型的方法都应该有值或指针接收者，但并不应该二者混用。（我们会在接下来几页中明白为什么。）

 1package main
 2
 3import (
 4    "fmt"
 5    "math"
 6)
 7
 8type Vertex struct {
 9    X, Y float64
10}
11
12func (v *Vertex) Scale(f float64) {
13    v.X = v.X * f
14    v.Y = v.Y * f
15}
16
17func (v *Vertex) Abs() float64 {
18    return math.Sqrt(v.X*v.X + v.Y*v.Y)
19}
20
21func main() {
22    v := &Vertex{3, 4}
23    fmt.Printf("缩放前：%+v，绝对值：%v\n", v, v.Abs())
24    v.Scale(5)
25    fmt.Printf("缩放后：%+v，绝对值：%v\n", v, v.Abs())
26}

输出

缩放前：&{X:3 Y:4}，绝对值：5
缩放后：&{X:15 Y:20}，绝对值：25

接口

接口类型是由一组方法签名定义的集合。简单来说，接口就像是一份"合同"，它只规定了"要做什么"，但不关心"怎么做"。
任何类型只要实现了接口中定义的所有方法，就被认为满足了这个接口。在 Go 中，不需要显式声明某个类型实现了某个接口，只要一个类型实现了接口要求的所有方法，它就自动满足了这个接口。这与其他语言如 Java 不同，Java 需要明确声明实现关系。

警告

示例代码的第 22 行存在一个错误。由于 Abs 方法只为 *Vertex （指针类型）定义，因此 Vertex（值类型）并未实现 Abser。

 1package main
 2
 3import (
 4    "fmt"
 5    "math"
 6)
 7
 8type Abser interface {
 9    Abs() float64
10}
11
12func main() {
13    var a Abser
14    f := MyFloat(-math.Sqrt2)
15    v := Vertex{3, 4}
16
17    a = f  // a MyFloat 实现了 Abser
18    a = &v // a *Vertex 实现了 Abser
19
20    // 下面一行，v 是一个 Vertex（而不是 *Vertex）
21    // 所以没有实现 Abser。
22    // a = v
23
24    fmt.Println(a.Abs())
25}
26
27type MyFloat float64
28
29func (f MyFloat) Abs() float64 {
30    if f < 0 {
31        return float64(-f)
32    }
33    return float64(f)
34}
35
36type Vertex struct {
37    X, Y float64
38}
39
40func (v *Vertex) Abs() float64 {
41    return math.Sqrt(v.X*v.X + v.Y*v.Y)
42}

输出

Abser接口只定义了一个方法：Abs() float64，意思是任何想要实现这个接口的类型都必须有一个名为Abs的方法，该方法不接受参数且返回一个float64值.

在代码中，有两个类型与这个接口相关：

MyFloat类型 - 直接实现了Abs()方法

1func (f MyFloat) Abs() float64 {
2     // 方法实现... 
3}

Vertex结构体 - 但这里有个关键点：Abs()方法是为*Vertex(指针类型)定义的，而不是Vertex(值类型)

1func (v *Vertex) Abs() float64 {
2    return math.Sqrt(v.X*v.X + v.Y*v.Y)
3}

那为什么 Vertex 值类型没有实现 Abser 接口，而 *Vertex 指针类型实现了呢？因为 Abs() 方法的接收者是 *Vertex（指针类型），而不是 Vertex（值类型）。这意味着：

指针接收者：当 Abs() 方法定义在 *Vertex 上时，只有 *Vertex 类型实现了 Abser 接口。
值不能自动转为指针：Go 语言不会自动将 Vertex 值转换为 *Vertex 指针来调用方法。

在示例代码中：

a = f 有效，因为 MyFloat 类型实现了 Abs() 方法；
a = &v 有效，因为 *Vertex 类型实现了 Abs() 方法；
a = v 无效，因为 Vertex 类型没有实现 Abs() 方法 - 这行被注释掉了，因为它会导致编译错误。

可以这样理解：

假设接口 Abser 是一个"会计算绝对值的东西"的规范
MyFloat 类型本身就知道如何计算自己的绝对值
但对于 Vertex 结构体，只有拿到它的地址(*Vertex)才能计算绝对值，而值本身(Vertex)不具备这个能力

这就是为什么 Go 的接口被称为"隐式接口"，它通过实现方法而不是声明来满足接口要求。

运行逻辑

首先，8~10 行定义了一个接口 Abser：

type Abser interface { Abs() float64 }

还有两个实现该接口的类型：MyFloat 和 *Vertex：

1. MyFloat 类型及其方法

1type MyFloat float64
2
3func (f MyFloat) Abs() float64 {
4    if f < 0 {
5        return float64(-f)
6    }
7    return float64(f)
8}

这里 MyFloat 是一个基于 float64 的自定义类型，它实现了 Abs() 方法，返回该浮点数的绝对值。在 Go 中，这被称为值接收者的方法。

2. Vertex 类型及其方法

1type Vertex struct {
2    X, Y float64
3}
4
5func (v *Vertex) Abs() float64 {
6    return math.Sqrt(v.X*v.X + v.Y*v.Y)
7}

Vertex 是一个包含 X 和 Y 坐标的结构体，它的 Abs() 方法使用指针接收者，计算从原点到该点的欧几里得距离。

 1func main() {
 2    var a Abser
 3    f := MyFloat(-math.Sqrt2)
 4    v := Vertex{3, 4}
 5
 6    a = f  // a MyFloat 实现了 Abser
 7    a = &v // a *Vertex 实现了 Abser
 8
 9    fmt.Println(a.Abs())
10}

执行过程：

变量声明：

var a Abser 声明一个 Abser 接口类型的变量 a
f := MyFloat(-math.Sqrt2) 创建一个值为 -√2 的 MyFloat 变量
v := Vertex{3, 4} 创建一个坐标为 (3,4) 的 Vertex 结构体

接口赋值：

a = f -> 将 MyFloat 类型的变量赋值给接口变量 a。这是合法的，因为 MyFloat 类型实现了 Abs() 方法，满足了 Abser 接口的要求。
a = &v -> 将 Vertex 的指针赋值给接口变量 a。注意这里必须是指针，因为 Abs() 方法是定义在 *Vertex 上的，而不是 Vertex 上。换句话说，*Vertex 类型实现了 Abser 接口，但 Vertex 类型没有。

方法调用：

fmt.Println(a.Abs()) -> 通过接口调用 Abs() 方法。虽然 a 是接口类型，但实际上它指向的是一个 *Vertex 类型的值（因为最后一次赋值是 a = &v），所以调用的是 *Vertex 的 Abs() 方法。
这将输出 5（即 √(3² + 4²)），这是点 (3,4) 到原点的距离。

这个简短的程序展示了 Go 语言面向接口编程的核心概念。

接口的隐式实现

类型通过实现一个接口的所有方法来实现该接口。既然无需专门显式声明，也就没有 implements 关键字。隐式接口从接口的实现中解耦了定义，这样接口的实现可以出现在任何包中，无需提前准备。因此，也就无需在每一个实现上增加新的接口名称，这样同时也鼓励了明确的接口定义。

 1package main
 2
 3import "fmt"
 4
 5type I interface {
 6    M()
 7}
 8
 9type T struct {
10    S string
11}
12
13// 此方法表示类型 T 实现了接口 I，不过我们并不需要显式声明这一点。
14func (t T) M() {
15    fmt.Println(t.S)
16}
17
18func main() {
19    var i I = T{"hello"}
20    i.M()
21}

答案

hello

接口是一种特殊的类型，它定义了一组方法的集合，但不提供具体实现。与其他编程语言不同的是，Go 采用了隐式接口实现的方式。这意味着类型通过实现一个接口的所有方法来自动实现该接口，而无需显式声明。你的代码示例中:

 1type I interface {
 2    M()
 3}
 4
 5type T struct {
 6    S string
 7}
 8
 9func (t T) M() {
10    fmt.Println(t.S)
11}

这里，结构体 T 实现了方法 M()，因此它自动实现了接口 I，尽管代码中没有明确声明这一点。

“implements” 关键字是什么？

在 Java 等其他面向对象语言中，当一个类实现一个接口时需要使用 implements 关键字来显式声明。例如在 Java 中:

1interface I {
2    void M();
3}
4
5class T implements I {
6    public void M() {
7        // 实现
8    }
9}

但 Go 没有 “implements” 关键字，只要一个类型实现了接口中定义的所有方法，它就自动实现了该接口，无需显式声明。

通俗理解：可以把 Go 的接口理解为一份"能力清单"。只要一个类型具备了这份清单上所列的所有"能力"(方法)，它就自动获得了这个接口的"资格证"，而不需要特意去申请或声明。

在上面的例子中，接口 I 要求有一个 M() 方法，结构体 T 正好有这个方法，所以 T 自动满足了接口 I 的要求，可以被当作接口 I 类型来使用，如 var i I = T{"hello"} 所示。

这种设计使得代码更加简洁灵活，并且允许开发者为现有类型"追加"接口实现，即使是对标准库或第三方库中的类型。

接口值

接口也是值，它们可以像其它值一样传递；接口值可以用作函数的参数或返回值。
在内部，接口值可以看做包含值和具体类型的元组：(value, type)。
接口值保存了一个具体底层类型的具体值，接口值调用方法时会执行其底层类型的同名方法。

 1package main
 2
 3import (
 4    "fmt"
 5    "math"
 6)
 7
 8type I interface {
 9    M()
10}
11
12type T struct {
13    S string
14}
15
16func (t *T) M() {
17    fmt.Println(t.S)
18}
19
20type F float64
21
22func (f F) M() {
23    fmt.Println(f)
24}
25
26func main() {
27    var i I
28
29    i = &T{"Hello"}
30    describe(i)
31    i.M()
32
33    i = F(math.Pi)
34    describe(i)
35    i.M()
36}
37
38func describe(i I) {
39    fmt.Printf("(%v, %T)\n", i, i)
40}

输出

(&{Hello}, *main.T)
Hello
(3.141592653589793, main.F)
3.141592653589793

底层值为 nil 的接口值

即便接口内的具体值为 nil，方法仍然会被 nil 接收者调用。

在一些语言中，这会触发一个空指针异常，但在 Go 中通常会写一些方法来优雅地处理它（如本例中的 M 方法）。

注意: 保存了 nil 具体值的接口其自身并不为 nil。

 1package main
 2
 3import "fmt"
 4
 5type I interface {
 6    M()
 7}
 8
 9type T struct {
10    S string
11}
12
13func (t *T) M() {
14    if t == nil {
15        fmt.Println("<nil>")
16        return
17    }
18    fmt.Println(t.S)
19}
20
21func main() {
22    var i I
23
24    var t *T
25    i = t
26    describe(i)
27    i.M()
28
29    i = &T{"hello"}
30    describe(i)
31    i.M()
32}
33
34func describe(i I) {
35    fmt.Printf("(%v, %T)\n", i, i)
36}

输出

(<nil>, *main.T)
<nil>
(&{hello}, *main.T)
hello

nil 接口值

nil 接口值既不保存值也不保存具体类型。但为 nil 接口调用方法会产生运行时错误，因为接口的元组内并未包含能够指明该调用哪个具体方法的类型。

 1package main
 2
 3import "fmt"
 4
 5type I interface {
 6    M()
 7}
 8
 9func main() {
10    var i I
11    describe(i)
12    i.M()
13}
14
15func describe(i I) {
16    fmt.Printf("(%v, %T)\n", i, i)
17}

输出

(<nil>, <nil>)
panic: runtime error: invalid memory address or nil pointer dereference
[signal SIGSEGV: segmentation violation code=0x1 addr=0x0 pc=0x492b99]

goroutine 1 [running]:
main.main()
/tmp/sandbox1833746970/prog.go:12 +0x19

空接口

指定了零个方法的接口值被称为空接口：interface{}。
空接口可保存任何类型的值。（因为每个类型都至少实现了零个方法。）
空接口被用来处理未知类型的值。例如，fmt.Print 可接受类型为 interface{} 的任意数量的参数。

 1package main
 2
 3import "fmt"
 4
 5func main() {
 6    var i interface{}
 7    describe(i)
 8
 9    i = 42
10    describe(i)
11
12    i = "hello"
13    describe(i)
14}
15
16func describe(i interface{}) {
17    fmt.Printf("(%v, %T)\n", i, i)
18}

输出

(<nil>, <nil>)
(42, int)
(hello, string)

类型断言

总结

类型断言提供了访问接口值底层具体值的方式：t := i.(T)

该语句断言接口值 i 保存了具体类型 T，并将其底层类型为 T 的值赋予变量 t。若 i 并未保存 T 类型的值，该语句就会触发一个 panic。

为了判断一个接口值是否保存了一个特定的类型，类型断言可返回两个值：其底层值以及一个报告断言是否成功的布尔值：

t, ok := i.(T)

若 i 保存了一个 T，那么 t 将会是其底层值，而 ok 为 true。否则，ok 将为 false 而 t 将为 T 类型的零值，程序并不会产生 panic。

请注意这种语法和读取一个映射时的相同之处。

这说的什么玩意。。
通俗点说，类型断言是 Go 语言中的一种机制，它允许我们检查并访问接口值中存储的具体类型值。

 1package main
 2
 3import "fmt"
 4
 5func main() {
 6    var i interface{} = "hello"
 7
 8    s := i.(string)
 9    fmt.Println(s)
10
11    s, ok := i.(string)
12    fmt.Println(s, ok)
13
14    f, ok := i.(float64)
15    fmt.Println(f, ok)
16
17    f = i.(float64) // panic
18    fmt.Println(f)
19}

输出

hello
hello true
0 false
panic: interface conversion: interface {} is string, not float64

goroutine 1 [running]:
main.main()
/tmp/sandbox2560958058/prog.go:17 +0x13f

类型断言有两种主要形式：

简单形式：t := i.(T)

这种形式直接断言接口值i中保存的是T类型的值。
如果断言正确，t将获得i中存储的值。
如果断言错误（即i中不是T类型的值），程序会触发panic。

安全形式：t, ok := i.(T)

这种形式返回两个值：可能的转换结果和一个布尔值。
如果i中确实保存了T类型的值，那么t会获得该值，ok为true。
如果i中不是T类型的值，t会是T类型的零值，ok为false，但程序不会panic。

类型断言就像是打开盒子检查里面到底是什么。

简单形式(t := i.(T))就像是你确信盒子里装的是某样东西，直接拿出来用
安全形式(t, ok := i.(T))就像是你不确定盒子里是什么，所以先小心地看一眼，确认是你想要的东西再使用

以上面提供的代码示例：

 1var i interface{} = "hello"  // 创建一个接口变量i，存入字符串"hello"
 2
 3s := i.(string)  // 断言i中存储的是字符串，获取该字符串值
 4fmt.Println(s)   // 输出: "hello"
 5
 6s, ok := i.(string)  // 安全方式断言i中存储的是字符串
 7fmt.Println(s, ok)   // 输出: "hello true"
 8
 9f, ok := i.(float64)  // 安全方式断言i中存储的是float64
10fmt.Println(f, ok)    // 输出: "0 false"（断言失败，f得到float64的零值0，ok为false）
11
12f = i.(float64)  // 直接断言i中存储的是float64（但实际上不是）
13fmt.Println(f)   // 不会执行，因为上一行会触发panic

类型断言的安全形式（t, ok := i.(T)）语法与Go中读取映射的语法非常相似：

1value, exists := someMap[key]

两者都是返回两个值，第一个值是获取到的实际值（如果存在/断言成功），第二个值是一个布尔值，表示操作是否成功。

当我们需要访问接口值中存储的具体类型特有的方法或属性时，就需要使用类型断言将接口值"还原"为其原始类型。

类型选择

类型选择是一种按顺序从几个类型断言中选择分支的结构。与一般的 switch 语句相似，不过类型选择中的 case 为类型（而非值），它们针对给定接口值所存储的值的类型进行比较。

1switch v := i.(type) {
2    case T:
3        // v 的类型为 T
4    case S:
5        // v 的类型为 S
6    default:
7        // 没有匹配，v 与 i 的类型相同
8}

说人话：它可以查明一个接口变量里面藏着什么具体类型的值，然后根据不同类型执行不同的代码。

类型选择中的声明与类型断言 i.(T) 的语法相同，只是具体类型 T 被替换成了关键字 type。

此选择语句判断接口值 i 保存的值类型是 T 还是 S。在 T 或 S 的情况下，变量 v 会分别按 T 或 S 类型保存 i 拥有的值。在默认（即没有匹配）的情况下，变量 v 与 i 的接口类型和值相同。

 1package main
 2
 3import "fmt"
 4
 5func do(i interface{}) {
 6    switch v := i.(type) {
 7    case int:
 8        fmt.Printf("二倍的 %v 是 %v\n", v, v*2)
 9    case string:
10        fmt.Printf("%q 长度为 %v 字节\n", v, len(v))
11    default:
12        fmt.Printf("我不知道类型 %T!\n", v)
13    }
14}
15
16func main() {
17    do(21)
18    do("hello")
19    do(true)
20}

输出

二倍的 21 是 42
“hello” 长度为 5 字节
我不知道类型 bool!

普通的 switch：根据值来选择执行哪个分支
类型选择：根据类型来选择执行哪个分支

类型选择只能用于接口值，因为只有接口值才能容纳不同类型的数据。

Stringer

fmt 包中定义的 Stringer 是最普遍的接口之一。

1type Stringer interface {
2    String() string
3}

Stringer 是一个可以用字符串描述自己的类型。fmt 包（还有很多包）都通过此接口来打印值。

 1package main
 2
 3import "fmt"
 4
 5type Person struct {
 6    Name string
 7    Age  int
 8}
 9
10func (p Person) String() string {
11    return fmt.Sprintf("%v (%v years)", p.Name, p.Age)
12}
13
14func main() {
15    a := Person{"Arthur Dent", 42}
16    z := Person{"Zaphod Beeblebrox", 9001}
17    fmt.Println(a, z) // output: Arthur Dent (42 years) Zaphod Beeblebrox (9001 years)
18}

练习：Stringer

通过让 IPAddr 类型实现 fmt.Stringer 来打印点号分隔的地址。

例如，IPAddr{1, 2, 3, 4} 应当打印为 "1.2.3.4"。

例题

 1package main
 2
 3import "fmt"
 4
 5type IPAddr [4]byte
 6
 7// TODO: 为 IPAddr 添加一个 "String() string" 方法。
 8
 9func main() {
10    hosts := map[string]IPAddr{
11        "loopback":  {127, 0, 0, 1},
12        "googleDNS": {8, 8, 8, 8},
13    }
14    for name, ip := range hosts {
15        fmt.Printf("%v: %v\n", name, ip)
16    }
17}

loopback: [127 0 0 1]
googleDNS: [8 8 8 8]

为 String() 类型添加了 IPAddr 方法，该方法可将 IP 地址格式化为以点分隔的字符串；
使用 fmt.Sprintf 将每个字节转换为十进制数，并用点将它们连接起来；
就能将 IPAddr{1, 2, 3, 4} 打印为 1.2.3.4，以标准点阵格式显示 IP 地址。

答案

 1package main
 2
 3import (
 4    "fmt"
 5)
 6
 7type IPAddr [4]byte
 8
 9// Add String method to implement fmt.Stringer interface
10func (ip IPAddr) String() string {
11    return fmt.Sprintf("%d.%d.%d.%d", ip[0], ip[1], ip[2], ip[3])
12}
13
14func main() {
15    hosts := map[string]IPAddr{
16        "loopback":  {127, 0, 0, 1},
17        "googleDNS": {8, 8, 8, 8},
18    }
19    for name, ip := range hosts {
20        fmt.Printf("%v: %v\n", name, ip)
21    }
22}

loopback: 127.0.0.1
googleDNS: 8.8.8.8

错误

Go 程序使用 error 值来表示错误状态。与 fmt.Stringer 类似，error 类型是一个内建接口：

1type error interface {
2    Error() string
3}

与 fmt.Stringer 类似，fmt 包也会根据对 error 的实现来打印值。通常函数会返回一个 error 值，调用它的代码应当判断这个错误是否等于 nil 来进行错误处理。

1i, err := strconv.Atoi("42")
2if err != nil {
3    fmt.Printf("couldn't convert number: %v\n", err)
4    return
5}
6fmt.Println("Converted integer:", i)

error 为 nil 时表示成功；非 nil 的 error 表示失败。

 1package main
 2
 3import (
 4    "fmt"
 5    "time"
 6)
 7
 8type MyError struct {
 9    When time.Time
10    What string
11}
12
13func (e *MyError) Error() string {
14    return fmt.Sprintf("at %v, %s",
15        e.When, e.What)
16}
17
18func run() error {
19    return &MyError{
20        time.Now(),
21        "it didn't work",
22    }
23}
24
25func main() {
26    if err := run(); err != nil {
27        fmt.Println(err)
28    }
29}

输出

at 2009-11-10 23:00:00 +0000 UTC m=+0.000000001, it didn’t work

Readers

io 包指定了 io.Reader 接口，它表示数据流的读取端。Go 标准库包含了该接口的许多实现，包括文件、网络连接、压缩和加密等等。

io.Reader 接口有一个 Read 方法：func (T) Read(b []byte) (n int, err error)。Read 用数据填充给定的字节切片并返回填充的字节数和错误值。在遇到数据流的结尾时，它会返回一个 io.EOF 错误。

示例代码创建了一个 strings.Reader 并以每次 8 字节的速度读取它的输出。

 1package main
 2
 3import (
 4    "fmt"
 5    "io"
 6    "strings"
 7)
 8
 9func main() {
10    r := strings.NewReader("Hello, Reader!")
11
12    b := make([]byte, 8)
13    for {
14        n, err := r.Read(b)
15        fmt.Printf("n = %v err = %v b = %v\n", n, err, b)
16        fmt.Printf("b[:n] = %q\n", b[:n])
17        if err == io.EOF {
18            break
19        }
20    }
21}

输出

n = 8 err = b = [72 101 108 108 111 44 32 82]
b[:n] = “Hello, R”
n = 6 err = b = [101 97 100 101 114 33 32 82]
b[:n] = “eader!”
n = 0 err = EOF b = [101 97 100 101 114 33 32 82]
b[:n] = ""

练习：Reader

实现一个 Reader 类型，它产生一个 ASCII 字符 'A' 的无限流。io.Reader 要求实现如下方法：

1Read(p []byte) (n int, err error)

例题

 1package main
 2
 3import "golang.org/x/tour/reader"
 4
 5type MyReader struct{}
 6
 7// TODO: 为 MyReader 添加一个 Read([]byte) (int, error) 方法。
 8
 9func main() {
10	reader.Validate(MyReader{})
11}

此方法要将数据写入切片 p，返回写入的字节数，和可能的错误。这里题目的要求是产生无限个字符 'A' 的流，所以你写多少就返回多少，全写成 'A' 就可以了，不需要返回 io.EOF。

答案

 1package main
 2
 3import "golang.org/x/tour/reader"
 4
 5type MyReader struct{}
 6
 7// 实现 Read 方法
 8func (r MyReader) Read(p []byte) (n int, err error) {
 9    // 填满 p，全部赋值为 'A'
10    for i := range p {
11        p[i] = 'A'
12    }
13    // 返回填充的长度，不报错
14    return len(p), nil
15}
16
17func main() {
18    reader.Validate(MyReader{})
19}

OK!

要点说明：

for i := range p { p[i] = 'A' } 保证每个元素都写成 'A'
返回值 len(p), nil，说明全部填充，没有出错
MyReader 是结构体，实现了 Read 方法，所以它就是 io.Reader

运行这段代码，reader.Validate 会测试你的实现是否正确。OK!

练习：rot13Reader

有种常见的模式是一个 io.Reader 包装另一个 io.Reader，然后通过某种方式修改其数据流。例如，gzip.NewReader 函数接受一个 io.Reader（已压缩的数据流）并返回一个同样实现了 io.Reader 的 *gzip.Reader（解压后的数据流）。

编写一个实现了 io.Reader 并从另一个 io.Reader 中读取数据的 rot13Reader，通过应用 rot13 代换密码对数据流进行修改。rot13Reader 类型已经提供。实现 Read 方法以满足 io.Reader。

ROT13 是一个简单的加密算法，它将每个字母向前移动13个位置。由于英文字母表有26个字母，所以应用 ROT13 两次会得到原文。这使得它既是加密算法也是解密算法。

例题

 1package main
 2
 3import (
 4	"io"
 5	"os"
 6	"strings"
 7)
 8
 9type rot13Reader struct {
10	r io.Reader
11}
12
13func main() {
14	s := strings.NewReader("Lbh penpxrq gur pbqr!")
15	r := rot13Reader{s}
16	io.Copy(os.Stdout, &r)
17}

其实就是要实现一个 rot13Reader 类型，包装另一个 io.Reader 并应用 ROT13 加密算法处理读取的数据。ROT13 是一种简单的字母替换密码，它将字母表中的每个字母替换为其后的第 13 个字母。

答案

 1package main
 2
 3import (
 4    "io"
 5    "os"
 6    "strings"
 7)
 8
 9type rot13Reader struct {
10    r io.Reader
11}
12
13func (r *rot13Reader) Read(p []byte) (n int, err error) {
14    n, err = r.r.Read(p)
15    for i := 0; i < n; i++ {
16        if p[i] >= 'A' && p[i] <= 'Z' {
17            p[i] = 'A' + (p[i]-'A'+13)%26
18        } else if p[i] >= 'a' && p[i] <= 'z' {
19            p[i] = 'a' + (p[i]-'a'+13)%26
20        }
21    }
22    return
23}
24
25func main() {
26    s := strings.NewReader("Lbh penpxrq gur pbqr!")
27    r := rot13Reader{s}
28    io.Copy(os.Stdout, &r)
29}

You cracked the code!

首先从被包装的 io.Reader 中读取数据到缓冲区 p
然后对读取到的每个字节应用 ROT13 变换:
- 对于大写字母 ('A'-'Z')，应用 ROT13 变换
- 对于小写字母 ('a'-'z')，应用 ROT13 变换
- 其他字符（如空格、标点符号等）保持不变

当程序运行时，它会将 Lbh penpxrq gur pbqr! 通过 ROT13 解码后输出 You cracked the code!

图像

image包定义了 Image 接口：

1package image
2type Image interface {
3    ColorModel() color.Model
4    Bounds() Rectangle
5    At(x, y int) color.Color
6}

注意: Bounds 方法的返回值 Rectangle 实际上是一个image.Rectangle，它在 image 包中声明。（请参阅文档了解全部信息。）

color.Color 和 color.Model 类型也是接口，但是通常因为直接使用预定义的实现 image.RGBA 和 image.RGBAModel 而被忽视了。这些接口和类型由 image/color 包定义。

 1package main
 2
 3import (
 4    "fmt"
 5    "image"
 6)
 7
 8func main() {
 9    m := image.NewRGBA(image.Rect(0, 0, 100, 100))
10    fmt.Println(m.Bounds())
11    fmt.Println(m.At(0, 0).RGBA())
12}

输出

(0,0)-(100,100)
0 0 0 0

练习：图像

还记得之前编写的图片生成器吗？我们再来编写另外一个，不过这次它将会返回一个 image.Image 的实现而非一个数据切片。定义你自己的 Image 类型，实现必要的方法并调用 pic.ShowImage。

Bounds 应当返回一个 image.Rectangle ，例如 image.Rect(0, 0, w, h)；ColorModel 应当返回 color.RGBAModel；At 应当返回一个颜色。上一个图片生成器的值 v 对应于此次的 color.RGBA{v, v, 255, 255}。

例题

 1package main
 2
 3import "golang.org/x/tour/pic"
 4
 5type Image struct{}
 6
 7func main() {
 8	m := Image{}
 9	pic.ShowImage(m)
10}

三步走：

定义一个 Image 类型
实现必要的 image.Image 接口方法
调用 pic.ShowImage 来展示图像

image.Image 接口需要实现三个方法:

Bounds() - 应当返回 image.Rectangle，例如 image.Rect(0, 0, w, h)
ColorModel() - 应当返回 color.RGBAModel
At(x, y int) - 应当返回一个颜色，将上一个图像生成器的值 v 转换为 color.RGBA{v, v, 255, 255}

答案

 1package main
 2
 3import (
 4    "image"
 5    "image/color"
 6    "golang.org/x/tour/pic"
 7)
 8
 9type Image struct{
10    width, height int
11}
12
13func (img Image) Bounds() image.Rectangle {
14    return image.Rect(0, 0, img.width, img.height)
15}
16
17func (img Image) ColorModel() color.Model {
18    return color.RGBAModel
19}
20
21func (img Image) At(x, y int) color.Color {
22    // 这里我们使用之前练习中类似的函数来生成颜色值
23    v := uint8((x + y) / 2)
24    // 返回颜色，将值v转换为color.RGBA{v, v, 255, 255}
25    return color.RGBA{v, v, 255, 255}
26}
27
28func main() {
29    m := Image{256, 256}  // 创建一个256x256的图像
30    pic.ShowImage(m)
31}

Bounds() 方法返回了图像的矩形边界，使用 image.Rect(0, 0, img.width, img.height)；
ColorModel() 方法返回了 color.RGBAModel，表示我们使用RGBA颜色模型；
At(x, y int) 方法根据坐标计算颜色值，将之前图像生成器的值 v 映射到 color.RGBA{v, v, 255, 255}，创建一个蓝色调的图像。

这个代码会生成一个渐变的蓝色图像，因为我们将 RGB 中的蓝色通道值设为了最大值 255，同时根据坐标计算的值来控制红色和绿色通道。你可以尝试不同的函数来计算 v 的值，例如 x*y、(x+y)/2、x^y 等，这会产生不同的图案效果。

泛型

类型参数

可以使用类型参数编写 Go 函数来处理多种类型，可以让你编写更加通用和可复用的代码。函数的类型参数出现在函数参数之前的方括号之间：func Index[T comparable](s []T, x T) int。此声明意味着 s 是满足内置约束 comparable 的任何类型 T 的切片。 x 也是相同类型的值。

comparable 是一个有用的约束，它能让我们对任意满足该类型的值使用 == 和 != 运算符。在此示例中，我们使用它将值与所有切片元素进行比较，直到找到匹配项。该 Index 函数适用于任何支持比较的类型。

 1package main
 2
 3import "fmt"
 4
 5// Index 返回 x 在 s 中的下标，未找到则返回 -1。
 6func Index[T comparable](s []T, x T) int {
 7	for i, v := range s {
 8		// v 和 x 的类型为 T，它拥有 comparable 可比较的约束，
 9		// 因此我们可以使用 ==。
10		if v == x {
11			return i
12		}
13	}
14	return -1
15}
16
17func main() {
18	// Index 可以在整数切片上使用
19	si := []int{10, 20, 15, -10}
20	fmt.Println(Index(si, 15))
21
22	// Index 也可以在字符串切片上使用
23	ss := []string{"foo", "bar", "baz"}
24	fmt.Println(Index(ss, "hello"))
25}

输出

2
-1

类型参数就像是给函数的"类型"留了一个空位，等到真正使用时再填入具体的类型。这样一个函数就能适用于多种数据类型，避免了对于每种不同类型，都需要复制并修改相似的代码的情况。

func Index[T comparable](s []T, x T) int 里的 [T comparable] 可以理解为：

T 是一个"占位符"，表示某种具体的类型
comparable 是一个约束，表示 T 必须是可以用 == 比较的类型 [[2]]

这个 Index 函数可以接受任何类型的切片和相同类型的单个值，并返回该值在切片中的位置（找不到则返回 -1）。

当你调用 Index([]int{10, 20, 15}, 15) 时，Go 会自动将 T 理解为 int 类型。当你调用 Index([]string{"foo", "bar"}, "bar") 时，Go 会自动将 T 理解为 string 类型。

泛型类型

除了泛型函数之外，Go 还支持泛型类型。类型可以使用类型参数进行参数化，这对于实现通用数据结构非常有用，能够保存任意类型值的单链表的简单类型声明。
下面是一个练习，请为此链表的实现添加一些功能。

例题

 1package main
 2
 3// List 表示一个可以保存任何类型的值的单链表。
 4type List[T any] struct {
 5	next *List[T]
 6	val  T
 7}
 8
 9func main() {
10}

Go 从 1.18 版开始增加了对泛型（类型参数）的支持。通过泛型，可以编写适用于多种类型的代码，这对于实现像链接列表这样的泛型数据结构尤其有用。

答案

  1package main
  2
  3import "fmt"
  4
  5// List represents a single linked list that can store values of any type.
  6type List[T any] struct {
  7	next *List[T]
  8	val  T
  9}
 10
 11// NewList creates a new list with the given value.
 12func NewList[T any](val T) *List[T] {
 13	return &List[T]{val: val}
 14}
 15
 16// PushFront adds a new element to the beginning of the list.
 17func (l *List[T]) PushFront(val T) *List[T] {
 18	newHead := &List[T]{
 19		next: l,
 20		val:  val,
 21	}
 22	return newHead
 23}
 24
 25// Append adds a new element to the end of the list.
 26func (l *List[T]) Append(val T) *List[T] {
 27	if l == nil {
 28		return NewList(val)
 29	}
 30	
 31	current := l
 32	for current.next != nil {
 33		current = current.next
 34	}
 35	current.next = &List[T]{val: val}
 36	return l
 37}
 38
 39// Print displays all elements in the list.
 40func (l *List[T]) Print() {
 41	if l == nil {
 42		fmt.Println("Empty list")
 43		return
 44	}
 45	
 46	current := l
 47	for current != nil {
 48		fmt.Printf("%v -> ", current.val)
 49		current = current.next
 50	}
 51	fmt.Println("nil")
 52}
 53
 54// Length returns the number of elements in the list.
 55func (l *List[T]) Length() int {
 56	count := 0
 57	current := l
 58	for current != nil {
 59		count++
 60		current = current.next
 61	}
 62	return count
 63}
 64
 65// Contains checks if a value exists in the list.
 66// This requires that T supports the comparable constraint.
 67func Contains[T comparable](l *List[T], val T) bool {
 68	current := l
 69	for current != nil {
 70		if current.val == val {
 71			return true
 72		}
 73		current = current.next
 74	}
 75	return false
 76}
 77
 78// RemoveFirst removes the first occurrence of a value.
 79// This also requires that T supports the comparable constraint.
 80func RemoveFirst[T comparable](l *List[T], val T) *List[T] {
 81	if l == nil {
 82		return nil
 83	}
 84	
 85	// If head has the value to remove
 86	if l.val == val {
 87		return l.next
 88	}
 89	
 90	// Search for the value in subsequent nodes
 91	current := l
 92	for current.next != nil {
 93		if current.next.val == val {
 94			current.next = current.next.next
 95			break
 96		}
 97		current = current.next
 98	}
 99	
100	return l
101}
102
103func main() {
104	// Create a list of integers
105	intList := NewList(1)
106	intList = intList.Append(2)
107	intList = intList.Append(3)
108	intList = intList.PushFront(0)
109	
110	fmt.Println("Integer list:")
111	intList.Print()
112	fmt.Printf("List length: %d\n", intList.Length())
113	fmt.Printf("Contains 2: %v\n", Contains(intList, 2))
114	
115	// Remove an element
116	intList = RemoveFirst(intList, 2)
117	fmt.Println("After removing 2:")
118	intList.Print()
119	
120	// Create a list of strings
121	strList := NewList("hello")
122	strList = strList.Append("world")
123	strList = strList.Append("go")
124	
125	fmt.Println("\nString list:")
126	strList.Print()
127}

Integer list:
0 -> 1 -> 2 -> 3 -> nil
List length: 4
Contains 2: true
After removing 2:
0 -> 1 -> 3 -> nil

String list:
hello -> world -> go -> nil

NewList 用初始值创建一个新列表， PushFront 将元素添加到开头（O(1) 运算）， Append 在末尾添加元素（O(n) 运算）， Print 显示列表中的所有元素， Length 计算元素个数， Contains 检查列表中是否存在值， RemoveFirst 移除数值的第一次出现。

Contains 和 RemoveFirst 函数要求类型参数 T 是 可比较的 ，这意味着可以使用 == 和 !=。有些操作是作为独立函数而不是方法实现的，因为它们需要额外的类型约束，而这些约束并不是原始结构体定义的一部分。该实现维护了链表结构，每次操作都会在需要时返回新的表头，这是链表操作的常见模式。

小记

终于快把基础的学完了。当然，仅仅看代码没有用，还是要自己写点东西或者找点项目搞一下，不然始终就是纸上谈兵。

Go 萌新的初学之路 II

Thu, 27 Mar 2025 16:42:22 +0800

指针

*T 是指向 T 类型值的指针，其零值为 nil。如：

var p *int

& 操作符会生成一个指向其操作数的指针。如：

i := 42
p = &i

* 操作符表示指针指向的底层值：

fmt.Println(*p) // 通过指针 p 读取
i *p = 21 // 通过指针 p 设置 i

这也就是通常所说的「解引用」或「间接引用」。

注意：Go 没有指针运算。

 1package main
 2
 3import "fmt"
 4
 5func main() {
 6    i, j := 42, 2701
 7
 8    p := &i         // 指向 i
 9    fmt.Println(*p) // 通过指针读取 i 的值
10    // output: 42
11    *p = 21         // 通过指针设置 i 的值
12    fmt.Println(i)  // 查看 i 的值
13    // output: 21
14    p = &j         // 指向 j
15    *p = *p / 37   // 通过指针对 j 进行除法运算
16    fmt.Println(j) // 查看 j 的值
17    // output: 73
18}

结构体（struct）就是一组字段（field）

 1package main
 2
 3import "fmt"
 4
 5type Vertex struct {
 6    X int
 7    Y int
 8}
 9
10func main() {
11    fmt.Println(Vertex{5, 2})  // output: {5, 2}
12}

结构体字段可通过点号 . 来访问。

 1package main
 2
 3import "fmt"
 4
 5type Vertex struct {
 6    X int
 7    Y int
 8}
 9
10func main() {
11    v := Vertex{1, 2}
12    v.X = 4
13    fmt.Println(v.X)  // output: 4
14}

结构体字段可通过结构体指针来访问。如果我们有一个指向结构体的指针 p 那么可以通过 (*p).X 来访问其字段 X。不过这么写太啰嗦了，所以语言也允许我们使用隐式解引用，直接写 p.X 就可以。

 1package main
 2
 3import "fmt"
 4
 5type Vertex struct {
 6    X int
 7    Y int
 8}
 9
10func main() {
11    v := Vertex{1, 2}
12    p := &v
13    p.X = 1e9
14    fmt.Println(v)  // output: {1000000000 2}
15}

使用 Name: 语法可以仅列出部分字段（字段名的顺序无关）；特殊的前缀 & 返回一个指向结构体的指针。以下面的代码为例，v2 = Vertex{X: 1} 里只指定了 X，那么 Y 就会置0。

 1package main
 2
 3import "fmt"
 4
 5type Vertex struct {
 6    X, Y int
 7}
 8
 9var (
10    v1 = Vertex{1, 2}  // 创建一个 Vertex 类型的结构体
11    v2 = Vertex{X: 1}  // Y:0 被隐式地赋予零值
12    v3 = Vertex{}      // X:0 Y:0
13    p  = &Vertex{1, 2} // 创建一个 *Vertex 类型的结构体（指针）
14)
15
16func main() {
17    fmt.Println(v1, p, v2, v3) // output: {1 2} &{1 2} {1 0} {0 0}
18}

类型 [n]T 表示一个数组，它拥有 n 个类型为 T 的值。 var a [10]int 会将变量 a 声明为拥有 10 个整数的数组。数组的长度是其类型的一部分，因此数组不能改变大小。不过没关系，Go 拥有更加方便的使用数组的方式。

 1package main
 2
 3import "fmt"
 4
 5func main() {
 6    var a [2]string
 7    a[0] = "Hello"
 8    // a[1] = "World"
 9    fmt.Println(a[0], a[1]) // output: Hello   
10    fmt.Println(a) // output: [Hello ]
11
12    primes := [6]int{2, 3, 5, 7, 11, 13}
13    fmt.Println(primes) // output: [2 3 5 7 11 13]
14}

切片

每个数组的大小都是固定的。而切片则为数组元素提供了动态大小的、灵活的视角。在实践中，切片比数组更常用。类型 []T 表示一个元素类型为 T 的切片。切片通过两个下标来界定，一个下界和一个上界，二者以冒号分隔： a[low : high]
与python一样，它会选出一个半闭半开区间，包括第一个元素，但排除最后一个元素。以下表达式创建了一个切片，它包含 a 中下标从 1 到 3 的元素： a[1:4]

 1package main
 2
 3import "fmt"
 4
 5func main() {
 6    primes := [6]int{2, 3, 5, 7, 11, 13}
 7
 8    var s []int = primes[1:4]
 9    fmt.Println(s) // output: [3 5 7]
10}

切片就像数组的引用，并不存储任何数据，它只是描述了底层数组中的一段。更改切片的元素会修改其底层数组中对应的元素，和它共享底层数组的切片都会观测到这些修改。

 1package main
 2
 3import "fmt"
 4
 5func main() {
 6    names := [4]string{
 7        "John",
 8        "Paul",
 9        "George",
10        "Ringo",
11    }
12    fmt.Println(names) // output: [John Paul George Ringo]
13
14    a := names[0:2]
15    b := names[1:3]
16    fmt.Println(a, b) // output: [John Paul] [Paul George]
17
18    b[0] = "XXX"
19    fmt.Println(a, b) // output: [John XXX] [XXX George]
20    fmt.Println(names) // output: [John XXX George Ringo]
21}

切片字面量：类似于没有长度的数组字面量。切片字面量的工作机制是：

根据字面量中的元素数量，隐式创建一个对应的数组，数组的长度等于元素数量。
创建一个切片，该切片引用这个隐式创建的数组，切片的长度和容量都等于数组的长度。
这个切片变量可以像其他切片一样操作，比如追加元素、重新切片等，可能会触发底层数组的扩容或修改。

切片字面量的底层数组只能通过该切片来访问，没有其他变量引用这个数组，所以当切片本身被传递时，底层数组不会被复制，而是共享。这和其他切片操作的行为是一致的。这样可以让切片的初始化更加方便，不需要显式创建数组再转换，同时保持了底层数组的引用机制。

 1package main
 2
 3import "fmt"
 4
 5func main() {
 6    q := []int{2, 3, 5, 7, 11, 13}
 7    fmt.Println(q) // output: [2 3 5 7 11 13]
 8
 9    r := []bool{true, false, true, true, false, true}
10    fmt.Println(r) // output: [true false true true false true]
11
12    s := []struct {
13        i int
14        b bool
15    }{
16        {2, true},
17        {3, false},
18        {5, true},
19        {7, true},
20        {11, false},
21        {13, true},
22    }
23    fmt.Println(s) // output: [{2 true} {3 false} {5 true} {7 true} {11 false} {13 true}]
24}

在进行切片时，你可以利用它的默认行为来忽略上下界。切片下界的默认值为 0，上界则是该切片的长度。对于数组 var a [10]int 来说，以下切片表达式和它是等价的：
a[0:10]、a[:10]、a[0:]、a[:]

 1package main
 2
 3import "fmt"
 4
 5func main() {
 6    s := []int{2, 3, 5, 7, 11, 13}
 7
 8    s = s[1:4]
 9    fmt.Println(s) // output: [3 5 7]
10
11    s = s[:2]
12    fmt.Println(s) // output: [3 5]
13
14    s = s[1:]
15    fmt.Println(s) // output: [5]
16}

切片拥有长度和容量：切片的长度就是它所包含的元素个数，切片的容量是从它的第一个元素开始数一直到其底层数组元素末尾的个数。切片 s 的长度和容量可通过表达式 len(s) 和 cap(s) 来获取。
通过重新切片来扩展一个切片，给它提供足够的容量。试着修改示例程序中的切片操作，向外扩展它的长度，看看会发生什么。（当然是会报错啦）

 1package main
 2
 3import "fmt"
 4
 5func main() {
 6    s := []int{2, 3, 5, 7, 11, 13}
 7    printSlice(s) // output: len=6 cap=6 [2 3 5 7 11 13]
 8
 9    // 截取切片使其长度为 0
10    s = s[:0]
11    printSlice(s) // output: len=0 cap=6 []
12
13    // 扩展其长度
14    s = s[:4]
15    printSlice(s) // output: len=4 cap=6 [2 3 5 7]
16
17    // 舍弃前两个值
18    s = s[2:]
19    printSlice(s) // output: len=2 cap=4 [5 7]
20}
21
22func printSlice(s []int) {
23    fmt.Printf("len=%d cap=%d %v\n", len(s), cap(s), s)
24}

切片的零值是 nil，nil 切片的长度和容量为 0 且没有底层数组。

 1package main
 2
 3import "fmt"
 4
 5func main() {
 6    var s []int
 7    fmt.Println(s, len(s), cap(s)) // output: [] 0 0
 8    if s == nil {
 9        fmt.Println("nil!") // output: nil!
10    }
11}

切片可以用内置函数 make 来创建，这也是你创建动态数组的方式。make 函数会分配一个元素为零值的数组并返回一个引用了它的切片：

a := make([]int, 5) // len(a)=5

要指定它的容量，需向 make 传入第三个参数：

b := make([]int, 0, 5) // len(b)=0, cap(b)=5
b = b[:cap(b)] // len(b)=5, cap(b)=5
b = b[1:] // len(b)=4, cap(b)=4

 1package main
 2
 3import "fmt"
 4
 5func main() {
 6    a := make([]int, 5)
 7    printSlice("a", a) // output: a len=5 cap=5 [0 0 0 0 0]
 8
 9    b := make([]int, 0, 5)
10    printSlice("b", b) // output: b len=0 cap=5 []
11
12    c := b[:2]
13    printSlice("c", c) // output: c len=2 cap=5 [0 0]
14
15    d := c[2:5]
16    printSlice("d", d) // output: d len=3 cap=3 [0 0 0]
17}
18
19func printSlice(s string, x []int) {
20    fmt.Printf("%s len=%d cap=%d %v\n",
21        s, len(x), cap(x), x)
22}

切片可以包含任何类型，当然也包括其他切片。

点击显示代码

 1package main
 2
 3import (
 4    "fmt"
 5    "strings"
 6)
 7
 8func main() {
 9    // 创建一个井字棋（经典游戏）
10    board := [][]string{
11        []string{"_", "_", "_"},
12        []string{"_", "_", "_"},
13        []string{"_", "_", "_"},
14    }
15
16    // 两个玩家轮流打上 X 和 O
17    board[0][0] = "X"
18    board[2][2] = "O"
19    board[1][2] = "X"
20    board[1][0] = "O"
21    board[0][2] = "X"
22
23    for i := 0; i < len(board); i++ {
24        fmt.Printf("%s\n", strings.Join(board[i], " "))
25    }
26         // output: X _ X
27         // output: O _ X
28         // output: _ _ O
29}

向切片追加元素时可以用内置的 append 函数：
func append(s []T, vs ...T) []T
内置函数的文档对该函数有详细的介绍。

append 的第一个参数 s 是一个元素类型为 T 的切片，其余类型为 T 的值将会追加到该切片的末尾。append 会返回一个包含原切片所有元素加上新添加元素的切片。当 s 的底层数组太小，不足以容纳所有给定的值时，它就会分配一个更大的数组。返回的切片会指向这个新分配的数组。

（要了解关于切片的更多内容，请阅读文章 Go 切片：用法和本质。）

 1package main
 2
 3import "fmt"
 4
 5func main() {
 6    var s []int
 7    printSlice(s) // output: len=0 cap=0 []
 8
 9    // 可在空切片上追加
10    s = append(s, 0)
11    printSlice(s) // output: len=1 cap=1 [0]
12
13    // 这个切片会按需增长
14    s = append(s, 1)
15    printSlice(s) // output: len=2 cap=2 [0 1]
16
17    // 可以一次性添加多个元素
18    s = append(s, 2, 3, 4)
19    printSlice(s) // output: len=5 cap=6 [0 1 2 3 4]
20}
21
22func printSlice(s []int) {
23    fmt.Printf("len=%d cap=%d %v\n", len(s), cap(s), s)
24}

映射

for 循环的 range 形式可遍历切片或映射，每次迭代都会返回两个值。第一个值为当前元素的下标，第二个值为该下标所对应元素的一份副本。

 1package main
 2
 3import "fmt"
 4
 5var pow = []int{1, 2, 4, 8, 16, 32, 64, 128}
 6
 7func main() {
 8    for i, v := range pow {
 9        fmt.Printf("2**%d = %d\n", i, v)
10    }
11}

点击显示输出结果

20 = 1
21 = 2
22 = 4
23 = 8
24 = 16
25 = 32
26 = 64
27 = 128

可以将下标或值赋予 _ 来忽略 range 遍历的变量：
for i, _ := range pow for _, value := range pow

若你只需要索引，忽略第二个变量即可：
for i := range pow

 1package main
 2
 3import "fmt"
 4
 5func main() {
 6    pow := make([]int, 10)
 7    for i := range pow {
 8        pow[i] = 1 << uint(i) // == 2**i
 9    }
10    for _, value := range pow {
11        fmt.Printf("%d\n", value)
12    }
13}

点击显示输出结果

1
2
4
8
16
32
64
128
256
512

map 映射将键映射到值，映射的零值为 nil 。nil 映射既没有键，也不能添加键。make 函数会返回给定类型的映射，并将其初始化备用。

 1package main
 2
 3import "fmt"
 4
 5type Vertex struct {
 6    Lat, Long float64
 7}
 8
 9var m map[string]Vertex
10
11func main() {
12    m = make(map[string]Vertex)
13    m["Bell Labs"] = Vertex{
14        40.68433, -74.39967,
15    }
16    fmt.Println(m["Bell Labs"]) // output: {40.68433 -74.39967}
17}

映射的字面量和结构体类似，只不过必须有键名。

 1package main
 2
 3import "fmt"
 4
 5type Vertex struct {
 6    Lat, Long float64
 7}
 8
 9var m = map[string]Vertex{
10    "Bell Labs": Vertex{
11        40.68433, -74.39967,
12    },
13    "Google": Vertex{
14        37.42202, -122.08408,
15    },
16}
17
18func main() {
19    fmt.Println(m) // output: map[Bell Labs:{40.68433 -74.39967} Google:{37.42202 -122.08408}]
20}

若顶层类型只是一个类型名，那么你可以在字面量的元素中省略它。

 1package main
 2
 3import "fmt"
 4
 5type Vertex struct {
 6    Lat, Long float64
 7}
 8
 9var m = map[string]Vertex{
10    "Bell Labs": {40.68433, -74.39967},
11    "Google":    {37.42202, -122.08408},
12}
13
14func main() {
15    fmt.Println(m) // output: map[Bell Labs:{40.68433 -74.39967} Google:{37.42202 -122.08408}]
16}

在映射 m 中插入或修改元素：[key] = elem
获取元素：elem = m[key]
删除元素：delete(m, key)
通过双赋值检测某个键是否存在：elem, ok = m[key]
若 key 在 m 中，ok 为 true ；否则，ok 为 false。
若 key 不在映射中，则 elem 是该映射元素类型的零值。
注：若 elem 或 ok 还未声明，你可以使用短变量声明： elem, ok := m[key]

 1package main
 2
 3import "fmt"
 4
 5func main() {
 6    m := make(map[string]int)
 7
 8    m["答案"] = 42
 9    fmt.Println("值：", m["答案"]) // output: 值： 42
10
11    m["答案"] = 48
12    fmt.Println("值：", m["答案"]) // output: 值： 48
13
14    delete(m, "答案")
15    fmt.Println("值：", m["答案"]) // output: 值： 0
16
17    v, ok := m["答案"]
18    fmt.Println("值：", v, "是否存在？", ok) // output: 值： 0 是否存在？ false
19}

函数也是值，可以像其他值一样传递。函数值可以用作函数的参数或返回值。

 1package main
 2
 3import (
 4    "fmt"
 5    "math"
 6)
 7
 8func compute(fn func(float64, float64) float64) float64 {
 9    return fn(3, 4)
10}
11
12func main() {
13    hypot := func(x, y float64) float64 {
14        return math.Sqrt(x*x + y*y)
15    }
16    fmt.Println(hypot(5, 12)) // output: 13
17    fmt.Println(compute(hypot)) // output: 5
18    fmt.Println(compute(math.Pow)) // output: 81
19}

执行流程与输出

直接调用hypot(5,12):

计算：√(5² + 12²) = √169 = 13 → 输出13。

compute(hypot):

传入hypot到compute，执行hypot(3,4) → √(9 + 16) = √25 = 5 → 输出5。

compute(math.Pow):

传入math.Pow到compute，执行3^4 → 81 → 输出81。

Go 函数可以是一个闭包。闭包是一个函数值，它引用了其函数体之外的变量。该函数可以访问并赋予其引用的变量值，换句话说，该函数被“绑定”到了这些变量。

例如，函数 adder 返回一个闭包。每个闭包都被绑定在其各自的 sum 变量上。

 1package main
 2
 3import "fmt"
 4
 5func adder() func(int) int {
 6    sum := 0
 7    return func(x int) int {
 8        sum += x
 9        return sum
10    }
11}
12
13func main() {
14    pos, neg := adder(), adder()
15    for i := 0; i < 10; i++ {
16        fmt.Println(
17            pos(i),
18            neg(-2*i),
19        )
20    }
21}

点击显示输出结果

0 0
1 -2
3 -6
6 -12
10 -20
15 -30
21 -42
28 -56
36 -72
45 -90

小结

还是水水的一篇，只为了证明一下自己还在学（进度好像确实有点慢）。唔，在整其他的东西导致有点忙，希望下周能把新手教程全过完，然后参考一下别人的项目。

Go 萌新的初学之路

Sat, 22 Mar 2025 20:03:52 +0800

包、变量与函数

程序从 main 包开始运行。可以通过导入路径 "math/rand" 来使用这个包，包名与导入路径的最后一个元素一致。例如，"math/rand" 包中的源码均以 package rand 语句开始。

 1package main
 2
 3import (
 4    "fmt"
 5    "math/rand"
 6)
 7
 8func main() {
 9    fmt.Println("我最喜欢的数字是 ", rand.Intn(10))
10}

在 Go 中，只有首字母大写的标识符才会被导出，也就是说小写的标识符在其他包中是不可见的。可以自定义package常量，不过没有必要：

多此一举

 1package main
 2
 3import (
 4    "fmt"
 5    "math"
 6)
 7
 8func main() {
 9    const pi = math.Pi
10    fmt.Println(pi)
11}

输出： 3.141592653589793

萌新的疑问

可以 import "math/rand" ，那么可不可以 import "math/rand" 呢？答案是不可以的，因为 math/rand 是标准库中真实存在的独立子包，而 Pi 是 math 包的导出常量，不属于包。以下是常用的子包：

math/rand：随机数相关
math/big：大数运算
math/cmplx：复数运算

函数可以返回任意数量的返回值。swap 函数返回了两个字符串。

 1package main
 2
 3import "fmt"
 4
 5func swap(x, y string) (string, string) {
 6    return y, x
 7}
 8
 9func main() {
10    a, b := swap("hello", "world")
11    fmt.Println(a, b)
12}

输出： world hello

Go 的返回值可被命名，它们会被视作定义在函数顶部的变量。没有参数的 return 语句会直接返回已命名的返回值，也就是「裸」返回值。裸返回语句在长的函数中它们会影响代码的可读性。

 1package main
 2
 3import "fmt"
 4
 5func split(sum int) (x, y int) {
 6    x = sum * 4 / 9
 7    y = sum - x
 8    return
 9}
10
11func main() {
12    fmt.Println(split(17))
13}

输出：7 10

var 语句用于声明一系列变量，可以出现在包或函数的层级。

 1package main
 2
 3import "fmt"
 4
 5var c, python, java bool
 6
 7func main() {
 8    var i int
 9    fmt.Println(i, c, python, java)
10}

输出：0 false false false

如果声明变量时提供了初始值，则类型可以省略；变量会从初始值中推断出类型。在这里通过fmt.Printf的%T打印变量的类型：

 1package main
 2
 3import "fmt"
 4
 5var i, j = 1, 2
 6
 7func main() {
 8    var c, python, java = true, false, "no!"
 9    fmt.Println(i, j, c, python, java)
10    fmt.Printf("%T, %T, %T, %T, %T", i, j, c, python, java)
11}

输出：

1 2 true false no!

int, int, bool, bool, string

短变量声明操作符:=是用来创建具有适当名称和初始值的变量。使用这个操作符的主要目的是在函数中声明和初始化 局部变量 ，并缩小变量的范围。

 1package main
 2
 3import "fmt"
 4
 5func main() {
 6    var i, j int = 1, 2
 7    k := 3
 8    c, python, java := true, false, "no!"
 9
10    fmt.Println(i, j, k, c, python, java)
11    fmt.Printf("%T, %T, %T, %T, %T, %T", i, j, k, c, python, java)
12}

输出：

1 2 3 true false no!

int, int, int, bool, bool, string

Go 的基本类型有：

bool
string
int int8 int16 int32 int64
uint uint8 uint16 uint32 uint64 uintptr
byte
// uint8 的别名
rune
// int32 的别名，表示一个 Unicode 码位
float32 float64
complex64 complex128
// 复数的64位浮点数表示

 1package main
 2
 3import (
 4    "fmt"
 5    "math/cmplx"
 6)
 7
 8var (
 9    ToBe   bool       = false
10    MaxInt uint64     = 1<<64 - 1
11    z      complex128 = cmplx.Sqrt(-5 + 12i)
12)
13
14func main() {
15    fmt.Printf("类型：%T 值：%v\n", ToBe, ToBe)
16    fmt.Printf("类型：%T 值：%v\n", MaxInt, MaxInt)
17    fmt.Printf("类型：%T 值：%v\n", z, z)
18}

输出：

类型：bool 值：false

类型：uint64 值：18446744073709551615

类型：complex128 值：(2+3i)

rune 类型是 Go 语言的一种特殊数字类型。在 builtin/builtin.go 文件中，它的定义：type rune = int32 ；官方对它的解释是：rune 是类型 int32 的别名，在所有方面都等价于它，用来区分字符值跟整数值。使用单引号定义，返回采用 UTF-8 编码的 Unicode 码点。Go 语言通过 rune 处理中文，支持国际化多语言。

UTF-8 编码规则：

ASCII 字符（0-127）：1 字节
带变音符号的拉丁/希腊/西里尔字母：2 字节
常用汉字（CJK 统一表意文字）：3 字节
生僻字/历史文字/表情符号：4 字节

 1package main
 2
 3import (
 4    "fmt"
 5)
 6
 7func main() {
 8    s := "Go语言编程"
 9    
10    fmt.Println(len("Go语言编程"))  // 输出：14
11    fmt.Println(len([]rune("Go语言编程")))  // 输出：6
12    fmt.Println(s[0:8])  // 输出：Go语言
13    fmt.Println(s[0:7]) // 输出：Go语��
14    fmt.Println(string([]rune(s)[:4])) // 输出：Go语言
15    
16    // byte
17    fmt.Println([]byte(s)) // 输出：[71 111 232 175 173 232 168 128 231 188 150 231 168 139]
18    // rune
19    fmt.Println([]rune(s)) // 输出：[71 111 35821 35328 32534 31243]
20}

字符串由字符组成，字符的底层由字节组成，而一个字符串在底层的表示是一个字节序列。在 Go 语言中，字符可以被分成两种类型处理：对占 1 个字节的英文类字符，可以使用 byte （或者 unit8 ）；对占 1 ~ 4 个字节的其他字符，可以使用 rune （或者 int32 ），如中文、特殊符号等。

Go 语言把字符分 byte 和 rune 两种类型处理。byte 是类型 unit8 的别名，用于存放占 1 字节的 ASCII 字符，如英文字符，返回的是字符原始字节。rune 是类型 int32 的别名，用于存放多字节字符，如占 3 字节的中文字符，返回的是字符 Unicode 码点值。

string、byte、rune三者间的关系：

字符串在底层的表示是由单个字节组成的一个不可修改的字节序列，字节使用 UTF-8[1] 编码标识 Unicode[2] 文本。Unicode 文本意味着 .go 文件内可以包含世界上的任意语言或字符，该文件在任意系统上打开都不会乱码。UTF-8 是 Unicode 的一种实现方式，是一种针对 Unicode 可变长度的字符编码，它定义了字符串具体以何种方式存储在内存中。UFT-8 使用 1 ~ 4 为每个字符编码。

Go 语言把字符分 byte 和 rune 两种类型处理。byte 是类型 unit8 的别名，用于存放占 1 字节的 ASCII 字符，如英文字符，返回的是字符原始字节。rune 是类型 int32 的别名，用于存放多字节字符，如占 3 字节的中文字符，返回的是字符 Unicode 码点值。如下图所示：

常量的声明与变量类似，只不过使用 const 关键字。常量可以是字符、字符串、布尔值或数值，但不能用 := 语法声明。

 1package main
 2
 3import "fmt"
 4
 5const Pi = 3.14
 6
 7func main() {
 8    const world = "世界"
 9    fmt.Println("Hello", world)
10    fmt.Println("Happy", Pi, "Day")
11
12    const Truth = true
13    fmt.Println("Go rules?", Truth)
14    
15    fmt.Printf("%T, %T, %T", world, Truth, Pi)
16}

输出：

Hello 世界

Happy 3.14 Day

Go rules? true

string, bool, float64

数值常量是高精度的值。int 类型可以存储最大 64 位的整数，根据平台不同有时会更小。

 1package main
 2
 3import "fmt"
 4
 5const Pi = 3.14
 6
 7func main() {
 8    const world = "世界"
 9    fmt.Println("Hello", world)
10    fmt.Println("Happy", Pi, "Day")
11
12    const Truth = true
13    fmt.Println("Go rules?", Truth)
14    
15    fmt.Printf("%T, %T, %T", world, Truth, Pi)
16}

输出：

21

0.2

1.2676506002282295e+29

在Go中，单引号括起来的是rune类型，也就是int32的别名，用来表示Unicode码点。而双引号括起来的才是字符串，比如"d"就是string类型。python转过来的真的有好多细节不适应 : (

1package main
2
3import "fmt"
4
5func main() {
6    v := 'd'
7    fmt.Printf("v is of type %T\n", v)
8    // 输出： v is of type int32
9}

流程控制语句：for、if、else、switch 和 defer

Go 只有一种循环结构：for 循环。基本的 for 循环由三部分组成，它们用分号隔开：

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

初始化语句通常为一句短变量声明，该变量声明仅在 for 语句的作用域中可见。一旦条件表达式求值为 false，循环迭代就会终止。

 1package main
 2
 3import "fmt"
 4
 5func main() {
 6    sum := 0
 7    for i := 0; i < 10; i++ {
 8        sum += i
 9    }
10    fmt.Println(sum)
11}

输出：45 （1+2+3+4+5+6+7+8+9）

初始化语句和后置语句是可选的

 1package main
 2
 3import "fmt"
 4
 5func main() {
 6    sum := 1
 7    for ; sum < 1000; {
 8        sum += sum
 9        fmt.Println(sum)
10    }
11    fmt.Println(sum)
12}

输出结果

2

4

8

16

32

64

128

256

512

1024

怎么写 Go 中的「while」语句呢？其实就是 for 循环去掉了分号：

 1package main
 2
 3import "fmt"
 4
 5func main() {
 6    sum := 1
 7    for sum < 1000 {
 8        sum += sum
 9        fmt.Println(sum)
10    }
11    fmt.Println(sum)
12}

输出结果

2

4

8

16

32

64

128

256

512

1024

if 语句与 for 循环类似：

 1package main
 2
 3import (
 4    "fmt"
 5    "math"
 6)
 7
 8func sqrt(x float64) string {
 9    if x < 0 {
10        return sqrt(-x) + "i"
11    }
12    return fmt.Sprint(math.Sqrt(x))
13}
14
15func main() {
16    fmt.Println(sqrt(2), sqrt(-4))
17}

输出：1.4142135623730951 2i

和 for 一样，if 语句可以在条件表达式前执行一个简短语句。该语句声明的变量作用域仅在 if 之内。（在pow最后的 return 语句处使用 v ，会报错 undefined: v ）

 1package main
 2
 3import (
 4    "fmt"
 5    "math"
 6)
 7
 8func pow(x, n, lim float64) float64 {
 9    if v := math.Pow(x, n); v < lim {
10        return v
11    }
12    return lim
13}
14
15func main() {
16    fmt.Println(
17        pow(3, 2, 10),
18        pow(3, 3, 20),
19    )
20}

输出：9 20

在 if 的简短语句中声明的变量同样可以在对应的任何 else 块中使用。（在 main 的 fmt.Println 调用开始前，两次对 pow 的调用均已执行并返回其各自的结果。）

 1package main
 2
 3import (
 4    "fmt"
 5    "math"
 6)
 7
 8func pow(x, n, lim float64) float64 {
 9    if v := math.Pow(x, n); v < lim {
10        return v
11    } else {
12        fmt.Printf("%g >= %g\n", v, lim)
13    }
14    // can't use v here, though
15    return lim
16}
17
18func main() {
19    fmt.Println(
20        pow(3, 2, 10),
21        pow(3, 3, 20),
22    )
23}

输出：

27 >= 20

9 20

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

Go 的 switch 语句类似于 C、C++、Java、JavaScript 和 PHP 中的，不过 Go 只会运行选定的 case，而非之后所有的 case。在效果上，Go 的做法相当于这些语言中为每个 case 后面自动添加了所需的 break 语句。在 Go 中，除非以 fallthrough 语句结束，否则分支会自动终止。 Go 的另一点重要的不同在于 switch 的 case 无需为常量，且取值不限于整数。

 1package main
 2
 3import (
 4    "fmt"
 5    "runtime"
 6)
 7
 8func main() {
 9    fmt.Print("Go 运行的系统环境：")
10    switch os := runtime.GOOS; os {
11    case "darwin":
12        fmt.Println("macOS.")
13    case "linux":
14        fmt.Println("Linux.")
15    default:
16        // freebsd, openbsd,
17        // plan9, windows...
18        fmt.Printf("%s.\n", os)
19    }
20}

输出：Go 运行的系统环境：Linux.

switch 的 case 语句从上到下顺次执行，直到匹配成功时停止。如：

1switch i {    
2    case 0:
3    case f():
4}

注意：在 i==0 时，f 不会被调用。

 1package main
 2
 3import (
 4    "fmt"
 5    "time"
 6)
 7
 8func main() {
 9    fmt.Println("周六是哪天？")
10    today := time.Now().Weekday()
11    switch time.Saturday {
12    case today + 0:
13        fmt.Println("今天。")
14    case today + 1:
15        fmt.Println("明天。")
16    case today + 2:
17        fmt.Println("后天。")
18    default:
19        fmt.Println("很多天后。")
20    }
21}

输出：

周六是哪天？

很多天后。

无条件的 switch 同 switch true 一样。这种形式能将一长串 if-then-else 写得更加清晰。

 1package main
 2
 3import (
 4    "fmt"
 5    "time"
 6)
 7
 8func main() {
 9    t := time.Now()
10    switch {
11    case t.Hour() < 12:
12        fmt.Println("早上好！")
13    case t.Hour() < 17:
14        fmt.Println("下午好！")
15    default:
16        fmt.Println("晚上好！")
17    }
18}

输出：晚上好！

defer 语句会将函数推迟到外层函数返回之后执行。推迟调用的函数其参数会立即求值，但直到外层函数返回前该函数都不会被调用。

1package main
2
3import "fmt"
4
5func main() {
6    defer fmt.Println("world")
7
8    fmt.Println("hello")
9}

输出：

hello

world

推迟调用的函数调用会被压入一个栈中。当外层函数返回时，被推迟的调用会按照后进先出的顺序调用。

 1package main
 2
 3import "fmt"
 4
 5func main() {
 6    fmt.Println("counting")
 7
 8    for i := 0; i < 10; i++ {
 9        defer fmt.Println(i)
10    }
11
12    fmt.Println("done")
13}

输出结果

counting

done

9

8

7

6

5

4

3

2

1

0

小结

作为一个 python 爱好者，转到 go 后在许多小角落都会有些迷茫，比如大小写敏感、单双引号不通用等等。但是还是记录一下自己的学习进程，敦促自己尽快打好 go 的基础，之后打算找几个项目练练手。

Golang 学习日记 on ifanticの小屋

Go 萌新的初学之路 V

介绍

快速入门

Gin 的 GET 和 POST 方法

路由分组

URL 值的提取

结构体声明并做约束

结构体声明与标签

路由处理器设置

为什么一个 URL 可以工作而另一个失败

错误处理

URL 参数的提取

GET 请求参数获取

POST 表单提交及其数据获取

GET 和 POST 混合使用

数据格式 JSON 和 ProtoBuf

Gin 解析特殊字符

Gin 翻译器的实现

结构体标签验证

翻译器设置

错误消息中的自定义JSON字段名

错误消息清理

请求处理流程

错误响应示例

Validator 内置验证标签

Gin 中间件原理及自定义中间件

Gin 中间件原理

自定义中间件

完整代码

中间件工作步骤详解

中间件实际应用

c.Abort()

c.Next()

Gin 返回 html 模板

Gin 静态文件的挂载

Gin 优雅退出

小记

Go 萌新的初学之路 IV

Go 协程

信道

带缓冲的信道

range 和 close

range 与 channel

select 语句

select 的特殊情况

默认选择

练习：等价二叉查找树

Walk 函数实现

Same 函数实现

主函数（测试）

完整代码

sync.Mutex

互斥锁（Mutex）

sync.Mutex 的工作原理

练习：Web 爬虫

小记

Go 萌新的初学之路 III

方法

什么是方法？

实际例子

值接收者与指针接收者的区别

方法即函数

指针类型的接收者

指针与函数

方法与指针重定向

选择值或指针作为接收者

接口

接口的隐式实现

“implements” 关键字是什么？

接口值

底层值为 nil 的接口值

nil 接口值

空接口

类型断言

类型选择

Stringer

练习：Stringer

错误

Readers

`Go` 协程