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

小记

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

Hugo 短代码

Tue, 15 Apr 2025 12:42:25 +0800

合集墙详见这里。如果没有特别说明，css样式都是在 assets/scss/custom.scss 文件里修改，短代码的html文件放在 layouts/shortcodes 文件夹里。

重点标记

新建 mark.html，内容为：

1<mark>{{ .Get "text" }}</mark>

在 custom.scss 中添加：

1//重点标记
2mark{
3    background: hsla(199, 64%, 63%, 0.696);
4}

使用：

1{{< mark text="标记" >}}

指定颜色文本

红色文本橙色文本黄色文本绿色文本深青色文本蓝色文本紫色文本

使用：

1<span style="color:red;">红色文本</span>

147种标准颜色

基础颜色 (16种)

序号	颜色名称	效果
1	`black` ; `#000080`	黑色文本
2	`silver` ; `#C0C0C0`	银色文本
3	`gray` / `grey` ; `#808080`	灰色文本
4	`white` ; `#FFFFFF`	白色文本
5	`maroon` ; `#800000`	栗色/褐红色文本
6	`red` ; `#FF0000`	红色文本
7	`purple` ; `#800080`	紫色文本
8	`fuchsia` (等同于 `magenta`) ; `#FF00FF`	紫红色/洋红色文本
9	`green` ; `#008000`	绿色文本
10	`lime` ; `#00FF00`	酸橙绿文本
11	`olive` ; `#808000`	橄榄绿文本
12	`yellow` ; `#FFFF00`	黄色文本
13	`navy` ; `#000080`	海军蓝文本
14	`blue` ; `#0000FF`	蓝色文本
15	`teal` ; `#008080`	水鸭色/蓝绿色文本
16	`aqua` (等同于 `cyan`) ; `#00FFFF`	水色/浅青色文本

扩展颜色 (131种)

红色系

红色系

序号	颜色名称	效果
1	`indianred`	红色文本
2	`lightcoral`	红色文本
3	`salmon`	红色文本
4	`darksalmon`	红色文本
5	`lightsalmon`	红色文本
6	`crimson`	红色文本
7	`firebrick`	红色文本
8	`darkred`	红色文本

粉红色系

粉红色系

序号	颜色名称	效果
1	`pink`	粉色文本
2	`lightpink`	浅粉色文本
3	`hotpink`	亮粉色文本
4	`deeppink`	深粉色文本
5	`mediumvioletred`	中紫红色文本
6	`palevioletred`	淡紫红色文本

橙色系

橙色系

序号	颜色名称	效果
1	`coral`	珊瑚色文本
2	`tomato`	番茄色文本
3	`orangered`	橙红色文本
4	`darkorange`	暗橙色文本
5	`orange`	橙色文本

黄色系

黄色系

序号	颜色名称	效果
1	`gold`	金色文本
2	`yellow`	黄色文本
3	`lightyellow`	浅黄色文本
4	`lemonchiffon`	柠檬绸色文本
5	`lightgoldenrodyellow`	浅金黄色文本
6	`papayawhip`	番木瓜色文本
7	`moccasin`	鹿皮色文本
8	`peachpuff`	桃肉色文本
9	`palegoldenrod`	苍金棒色文本
10	`khaki`	卡其色文本
11	`darkkhaki`	深卡其色文本

紫色系

紫色系

序号	颜色名称	效果
1	`lavender`	淡紫色文本
2	`thistle`	蓟色文本
3	`plum`	李子色文本
4	`violet`	紫罗兰色文本
5	`orchid`	兰花色文本
6	`fuchsia` (`magenta`)	洋红色文本
7	`mediumorchid`	中兰花色文本
8	`mediumpurple`	中紫色文本
9	`rebeccapurple`	丽贝卡紫色文本
10	`blueviolet`	蓝紫色文本
11	`darkviolet`	深紫罗兰色文本
12	`darkorchid`	深兰花色文本
13	`darkmagenta`	深洋红色文本
14	`purple`	紫色文本
15	`indigo`	靛蓝色文本
16	`slateblue`	板岩蓝文本
17	`darkslateblue`	深板岩蓝文本
18	`mediumslateblue`	中板岩蓝文本

绿色系

绿色系

序号	颜色名称	效果
1	`greenyellow`	绿黄色文本
2	`chartreuse`	黄绿色文本
3	`lawngreen`	草绿色文本
4	`lime`	亮绿色文本
5	`limegreen`	酸橙绿文本
6	`palegreen`	浅绿色文本
7	`lightgreen`	亮绿色文本
8	`mediumspringgreen`	中春绿色文本
9	`springgreen`	春绿色文本
10	`mediumseagreen`	中海绿色文本
11	`seagreen`	海绿色文本
12	`forestgreen`	森林绿文本
13	`green`	绿色文本
14	`darkgreen`	深绿色文本
15	`yellowgreen`	黄绿色文本
16	`olivedrab`	橄榄褐文本
17	`olive`	橄榄色文本
18	`darkolivegreen`	深橄榄绿文本
19	`mediumaquamarine`	中碧绿色文本
20	`darkseagreen`	深海绿色文本
21	`lightseagreen`	亮海绿色文本
22	`darkcyan`	深青色文本
23	`teal`	凫蓝文本

蓝色系

蓝色系

序号	颜色名称	效果
1	`aqua` (`cyan`)	水蓝色文本
2	`lightcyan`	浅青色文本
3	`paleturquoise`	苍绿色文本
4	`aquamarine`	碧绿色文本
5	`turquoise`	青绿色文本
6	`mediumturquoise`	中青绿色文本
7	`darkturquoise`	深青绿色文本
8	`cadetblue`	军蓝色文本
9	`steelblue`	钢蓝色文本
10	`lightsteelblue`	亮钢蓝色文本
11	`powderblue`	粉蓝色文本
12	`lightblue`	浅蓝色文本
13	`skyblue`	天蓝色文本
14	`lightskyblue`	亮天蓝色文本
15	`deepskyblue`	深天蓝色文本
16	`dodgerblue`	闪蓝色文本
17	`cornflowerblue`	矢车菊蓝色文本
18	`royalblue`	皇家蓝色文本
19	`blue`	纯蓝色文本
20	`mediumblue`	中蓝色文本
21	`darkblue`	深蓝色文本
22	`navy`	海军蓝色文本
23	`midnightblue`	午夜蓝色文本

棕色系

棕色系

序号	颜色名称	效果
1	`cornsilk`	浅玉米丝色文本
2	`blanchedalmond`	漂白杏仁色文本
3	`bisque`	乳脂色文本
4	`navajowhite`	纳瓦白文本
5	`wheat`	小麦色文本
6	`burlywood`	硬木色文本
7	`tan`	棕褐色文本
8	`rosybrown`	玫瑰棕色文本
9	`sandybrown`	沙棕色文本
10	`goldenrod`	金菊色文本
11	`darkgoldenrod`	深金菊色文本
12	`peru`	秘鲁色文本
13	`chocolate`	巧克力色文本
14	`saddlebrown`	鞍棕色文本
15	`sienna`	赭色文本
16	`brown`	棕色文本
17	`darkbrown`	深棕色文本

白色系

白色系

序号	颜色名称	效果
1	`white`	白色文本
2	`snow`	雪白文本
3	`honeydew`	蜜露色文本
4	`mintcream`	薄荷奶油色文本
5	`azure`	天蓝色文本
6	`aliceblue`	爱丽丝蓝文本
7	`ghostwhite`	幽灵白文本
8	`whitesmoke`	烟白文本
9	`seashell`	贝壳白文本
10	`beige`	米色文本
11	`oldlace`	旧蕾丝色文本
12	`floralwhite`	花卉白文本
13	`ivory`	象牙白文本
14	`antiquewhite`	古董白文本
15	`linen`	亚麻色文本

灰色系

灰色系

序号	颜色名称	效果
1	`gainsboro`	浅灰文本
2	`lightgray` / `lightgrey`	亮灰文本
3	`silver`	银灰文本
4	`darkgray` / `darkgrey`	暗灰文本
5	`gray` / `grey`	标准灰文本
6	`dimgray` / `dimgrey`	昏灰文本
7	`lightslategray` / `lightslategrey`	亮岩灰文本
8	`slategray` / `slategrey`	岩灰文本
9	`darkslategray` / `darkslategrey`	暗岩灰文本
10	`black`	纯黑文本

文本缩写

这个短代码只在电脑端生效

新建 abbr.html，内容为：

1<abbr title="{{ .Get "title" }}">{{ .Get "text" }}</abbr>

使用：

1{{< abbr title="感觉很神秘" text="这个短代码只在电脑端生效" >}}

文本折叠

点击显示

让我看看！

新建 detail.html，内容为：

1<details>
2    <summary>{{ (.Get 0) | markdownify }}</summary>
3    {{ .Inner | markdownify }}
4</details>

使用：

1{{< spoiler "点击显示" >}}
2让我看看！
3{{< /spoiler >}}

高斯模糊

手动打码效果

在 custom.scss 中添加：

 1//文本高斯模糊
 2.blur {
 3    color: transparent;
 4    text-shadow:0px 0px 8px var(--card-text-color-main)
 5}
 6 
 7.blur:hover {
 8    color: transparent;
 9    text-shadow:0px 0px 0px var(--card-text-color-main)
10   
11}

使用：

1<span class="blur">手动打码效果</span>

文本黑幕

数据删除！

在 custom.scss 中添加：

 1//文本黑幕效果
 2.shady {
 3    color:#000;
 4    font-weight: bold;
 5    box-shadow: 0px -20px 0px rgba(0,0,0,1) inset; 
 6    transition: all 0.3s ease;
 7}
 8.shady:hover{
 9   font-weight: bold;
10    color:#FFF;
11    box-shadow: 0px -20px 0px rgba(0,0,0,1) inset; 
12}

使用：

1<span class="shady">数据删除！</span>

文字抖动

这是基本的摇晃效果。

这个段落持续摇晃。

新建shake.html，内容为：

 1<link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/csshake/1.5.3/csshake.min.css" />
 2
 3<div class="shake {{ .Get "effect" }}">{{ .Inner }}</div>
 4
 5<div class="shake"></div> 
 6<div class="shake shake-hard"></div> 
 7<div class="shake shake-slow"></div> 
 8<div class="shake shake-little"></div> 
 9<div class="shake shake-horizontal"></div> 
10<div class="shake shake-vertical"></div> 
11<div class="shake shake-rotate"></div> 
12<div class="shake shake-opacity"></div> 
13<div class="shake shake-crazy"></div>
14<!-- Freeze the animation at that point when :hover --> 
15<div class="shake shake-freeze"></div> 
16<!-- Continuous animation instead on :hover --> 
17<div class="shake shake-constant"></div>

使用：

1{{< shake effect="shake" >}}这是基本的摇晃效果。{{< /shake >}}

文字渐变

我挑的配色好看吧！

在 custom.scss 中添加：

1//文字颜色渐变
2.colorfulfont {
3    background: linear-gradient(to right, rgb(25, 221, 238), #ed4588); //第一个颜色代码是渐变起始色，第二个颜色代码是渐变结束色；
4    -webkit-background-clip: text;
5    background-clip: text;
6    color: transparent;
7}

使用：

1<font class="colorfulfont"> 我挑的配色好看吧！</font>

文本位置

文字居左

文字居中

文字居右

新建 align.html，内容为：

1<p style="text-align:{{ index .Params 0 }}">{{ index .Params 1 | markdownify }}</p>

使用：

1{{< align left "文字居左" >}}
2{{< align center "文字居中" >}}
3{{< align right "文字居右" >}}

摘录引用

“年复一年，创作的冲动随年衰减，创作的能力逐渐消失——也许两者根本上是一回事，我们常把自己的写作冲动误认为自己的写作才能，自以为要写就意味着会写。”

钱钟书 《围城》重印前记

新建 blockquote.html，内容为：

 1<!-- reset scratch variables at the start -->
 2{{ $.Scratch.Set "bl_author" false }}
 3{{ $.Scratch.Set "bl_source" false }}
 4{{ $.Scratch.Set "bl_link" false }}
 5{{ $.Scratch.Set "bl_title" false }}
 6
 7{{ if .IsNamedParams }}
 8  {{ $.Scratch.Set "bl_author" (.Get "author") }}
 9  {{ $.Scratch.Set "bl_source" (.Get "source") }}
10  {{ $.Scratch.Set "bl_link" (.Get "link") }}
11  {{ $.Scratch.Set "bl_title" (.Get "title") }}
12{{ else }}
13  <!-- for the positional version if any -->
14{{ end }}
15
16<!-- if title is not set explicitly then we need to beautify the link
17     if length of link is more than 32 chars, we will cut it off by 32 and
18     then drop everything after the last / if any and put it in into title -->
19
20{{ with $.Scratch.Get "bl_title" }}
21  <!-- do nothing -->
22{{ else }}
23  {{ with $.Scratch.Get "bl_link" }}    <!-- if link is given -->
24    {{ range last 1 (split ($.Scratch.Get "bl_link" ) "://") }}  <!-- split by :// and then only take the items after it to remove protocol:// -->
25      {{ $.Scratch.Set "title_without_protocol" . }}
26    {{ end }}
27    {{ range last 1 (split ($.Scratch.Get "title_without_protocol" ) "www.")  }} <!-- also remove the www. at the start if any. we are using a second split because all URLS may not start with it -->
28      {{ $.Scratch.Set "title_without_protocol" . }}
29    {{ end }}
30    {{ $.Scratch.Set "bl_title" ($.Scratch.Get "title_without_protocol") }}
31
32    <!-- if link is longer than 32 bytes we should trim it -->
33    {{ if (gt (len ($.Scratch.Get "title_without_protocol") ) 32) }}
34      {{ $title := (slicestr ($.Scratch.Get "title_without_protocol") 0 32) }}   <!-- get the first 32 characters of title_without_protocol -->
35      {{ $split_by_fw_slash := split $title "/" }}   <!-- now split on / because we want to stop after the last forward slash -->
36      {{ $count := (sub (len $split_by_fw_slash) 1) }}   <!-- we want everything but the last part so we adjust the count accordingly -->
37
38      {{ $.Scratch.Set "tempstring" "" }}   <!-- temp variable to hold the concatinated string -->
39      {{ range first $count $split_by_fw_slash  }}  <!-- loop through all parts except last and concat them (add / between halves) -->
40        {{ $.Scratch.Set "tempstring" ( . | printf "%s%s/" ($.Scratch.Get "tempstring") | printf "%s" ) }}
41      {{ end }}
42      {{ $.Scratch.Set "bl_title" ( printf "%s..." ($.Scratch.Get "tempstring") | printf "%s" ) }}
43    {{ end }}
44  {{ end }}
45{{ end }}
46
47<blockquote>
48  <p>{{ .Inner | markdownify }}</p>
49  <footer style="text-align:right">
50    <strong>{{ with $.Scratch.Get "bl_author" }}{{ . }}{{ end }}</strong>
51    {{ with $.Scratch.Get "bl_source" }}
52      <cite>{{ . }}</cite>
53    {{ else }}
54      {{ with $.Scratch.Get "bl_link" }}
55        <cite>
56          <a href="{{ . }}" title="{{ . }}" rel="noopener noreferrer">{{ $.Scratch.Get "bl_title" }}</a> <!-- can't have new lines here -->
57        </cite>
58      {{ else }}
59        {{ with $.Scratch.Get "bl_title" }}
60          <cite>
61            {{ $.Scratch.Get "bl_title" }}</a>
62          </cite>
63        {{ end }}
64      {{ end }}
65    {{ end }}
66  </footer>
67</blockquote>

使用：

1{{< blockquote author="作者" link="#" title="作品名" >}}
2这里写引用内容
3{{< /blockquote >}}

评分样式

新建 rating.html，内容为：

 1<span class="star-rating">
 2    {{- if ge (.Get 0) (.Get 1) -}}
 3        {{- $star_outline := sub (int (.Get 0)) (int (.Get 1)) -}}
 4        {{- range $i, $sequence :=  (seq (.Get 1)) -}}
 5            <i class="star"><svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 576 512"><path d="M381.2 150.3L524.9 171.5C536.8 173.2 546.8 181.6 550.6 193.1C554.4 204.7 551.3 217.3 542.7 225.9L438.5 328.1L463.1 474.7C465.1 486.7 460.2 498.9 450.2 506C440.3 513.1 427.2 514 416.5 508.3L288.1 439.8L159.8 508.3C149 514 135.9 513.1 126 506C116.1 498.9 111.1 486.7 113.2 474.7L137.8 328.1L33.58 225.9C24.97 217.3 21.91 204.7 25.69 193.1C29.46 181.6 39.43 173.2 51.42 171.5L195 150.3L259.4 17.97C264.7 6.954 275.9-.0391 288.1-.0391C300.4-.0391 311.6 6.954 316.9 17.97L381.2 150.3z"/></svg></i>
 6        {{- end -}}
 7        {{- range $i, $sequence :=  (seq $star_outline) -}}
 8            <i class="star-outline"><svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 576 512"><path d="M381.2 150.3L524.9 171.5C536.8 173.2 546.8 181.6 550.6 193.1C554.4 204.7 551.3 217.3 542.7 225.9L438.5 328.1L463.1 474.7C465.1 486.7 460.2 498.9 450.2 506C440.3 513.1 427.2 514 416.5 508.3L288.1 439.8L159.8 508.3C149 514 135.9 513.1 126 506C116.1 498.9 111.1 486.7 113.2 474.7L137.8 328.1L33.58 225.9C24.97 217.3 21.91 204.7 25.69 193.1C29.46 181.6 39.43 173.2 51.42 171.5L195 150.3L259.4 17.97C264.7 6.954 275.9-.0391 288.1-.0391C300.4-.0391 311.6 6.954 316.9 17.97L381.2 150.3z"/></svg></i>
 9        {{- end -}}
10    {{- end -}}
11</span>

在 custom.scss 中添加：

 1//星星评级
 2i.star{
 3    color: hsl(61, 79%, 63%); /*星星的颜色*/
 4  }
 5  
 6  i.star-outline{
 7    color: hsl(211, 31%, 74%);/*空星星的颜色*/
 8  }
 9  
10  i.star svg, i.star-outline svg{
11    width: 20px;
12    fill: currentColor;
13}

使用：

1{{< rating 10 7 >}}

键盘样式

Ctrl+Alt+Del

在 custom.scss 中添加：

 1//键盘标签样式
 2nkbd {
 3  margin: 0 .1em;
 4  padding: .1em .6em;
 5  font-size: .8em;
 6  color: #242729;
 7  background: #fff;
 8  border: 1px solid #adb3b9;
 9  border-radius: 3px;
10  box-shadow: 0px 1px 0 rgba(12, 13, 14, 0.2), 0 0 0 2px #fff inset;
11  white-space: nowrap;
12  vertical-align: middle;
13  font-family: SourceHanSerifSC;
14}

使用：

1<nkbd>Ctrl</nkbd>+<nkbd>Alt</nkbd>+<nkbd>Del</nkbd>

卡片样式

新建 card.html，内容为：

1{{- $raw := (markdownify .Inner | chomp) -}} {{- $block := findRE
2    "(?is)^<(?:address|article|aside|blockquote|canvas|dd|div|dl|dt|fieldset|figcaption|figure|footer|form|h(?:1|2|3|4|5|6)|header|hgroup|hr|li|main|nav|noscript|ol|output|p|pre|section|table|tfoot|ul|video)\\b"
3    $raw 1 -}}
4    <div class="mycard">
5      <div class="content">{{- if or $block (not $raw) }}{{ $raw }}{{ else }} {{ $raw }} {{ end -}}</div>
6    </div>

在 custom.scss 中添加：

 1// 卡片样式
 2.mycard {
 3    padding: 10px 20px;
 4    margin: 20px 0;
 5    border-radius: 4px;
 6    word-break: break-all;
 7    background: #d2e5eb14;
 8    box-shadow: 0 6px 10px 0 #00000033;
 9    .content {
10      line-height: 30px;
11    }
12}

使用：

1{{< card >}}卡片样式{{< /card >}}

仿Github样式

ifanticの小屋

鸳鸯帐里暖芙蓉此生何处不相逢

Hugo

新建 github.html，内容为：

 1<div class="github">
 2    <div class="logo">
 3        {{ replace $.Site.Data.SVG.repository "icon" "icon github-icon" | safeHTML }}
 4        <a class="name" href={{ .Get "link" }} target="_blank">{{ .Get "name" }}</a>
 5    </div>
 6    <div class="description">{{ .Get "description" }}</div>
 7    <div class="language">
 8        <span class="language-color" style="background-color: {{ .Get "color" }}"></span>
 9        <span class="language-name">{{ .Get "language" }}</span>
10    </div>
11</div>

在 custom.scss 中添加：

 1//github样式
 2.github {
 3    border: 1px solid var(--card-text-color-main);
 4    border-radius: 3px;
 5    margin: 0 auto;
 6    margin-bottom: 1em;
 7    padding: 1em;
 8    .github-icon {
 9      width: 1.2em;
10      height: 1.2em;
11      margin-right: 0.5em;
12      margin-bottom: 0.2em;
13      fill: var(--card-text-color-main);
14      transition: all 0.5s;
15    }
16    .name {
17      font-weight: bold;
18      color: #2e97d9;
19      text-decoration: underline;
20      margin-left: 0.5em;
21      position: relative;
22      top: -5px; //加这个属性是因为我的图标和名称无法对齐，实际使用的时候要根据自己的网站修改
23    }
24    .description {
25      margin-top: 0.5em;
26      margin-bottom: 0.5em;
27      color: var(--card-text-color-main);
28      text-align: justify;
29      font-size: 90%;
30      transition: all 0.5s;
31    }
32    .language-color {
33      position: relative;
34      top: 1px;
35      display: inline-block;
36      width: 0.75em;
37      height: 0.75em;
38      border-radius: 50%;
39    }
40    .language-name {
41      color: var(--card-text-color-main);
42      font-size: 90%;
43      margin-left: 0.5em;
44      transition: all 0.5s;
45    }
46}

在 data/SVG.toml 中加入图标（给出的代码是Github自己的图标，我已经换成了自定义的）：

1repository = '<svg xmlns="http://www.w3.org/2000/svg" class="icon" viewBox="0 0 16 16"><path fill-rule="evenodd" clip-rule="evenodd" d="M2 2.5C2 1.83696 2.26339 1.20107 2.73223 0.732233C3.20108 0.263392 3.83696 0 4.5 0L13.25 0C13.4489 0 13.6397 0.0790176 13.7803 0.21967C13.921 0.360322 14 0.551088 14 0.75V13.25C14 13.4489 13.921 13.6397 13.7803 13.7803C13.6397 13.921 13.4489 14 13.25 14H10.75C10.5511 14 10.3603 13.921 10.2197 13.7803C10.079 13.6397 10 13.4489 10 13.25C10 13.0511 10.079 12.8603 10.2197 12.7197C10.3603 12.579 10.5511 12.5 10.75 12.5H12.5V10.5H4.5C4.30308 10.5 4.11056 10.5582 3.94657 10.6672C3.78257 10.7762 3.65442 10.9312 3.57816 11.1128C3.50191 11.2943 3.48096 11.4943 3.51793 11.6878C3.5549 11.8812 3.64816 12.0594 3.786 12.2C3.92524 12.3422 4.0023 12.5338 4.00024 12.7328C3.99818 12.9318 3.91716 13.1218 3.775 13.261C3.63285 13.4002 3.4412 13.4773 3.24222 13.4752C3.04325 13.4732 2.85324 13.3922 2.714 13.25C2.25571 12.7829 1.99929 12.1544 2 11.5V2.5ZM12.5 1.5V9H4.5C4.144 9 3.806 9.074 3.5 9.208V2.5C3.5 2.23478 3.60536 1.98043 3.79289 1.79289C3.98043 1.60536 4.23478 1.5 4.5 1.5H12.5ZM5 12.25V15.5C5 15.5464 5.01293 15.5919 5.03734 15.6314C5.06175 15.6709 5.09667 15.7028 5.1382 15.7236C5.17972 15.7444 5.22621 15.7532 5.27245 15.749C5.31869 15.7448 5.36286 15.7279 5.4 15.7L6.85 14.613C6.89328 14.5805 6.94591 14.563 7 14.563C7.05409 14.563 7.10673 14.5805 7.15 14.613L8.6 15.7C8.63714 15.7279 8.68131 15.7448 8.72755 15.749C8.77379 15.7532 8.82028 15.7444 8.8618 15.7236C8.90333 15.7028 8.93826 15.6709 8.96266 15.6314C8.98707 15.5919 9 15.5464 9 15.5V12.25C9 12.1837 8.97366 12.1201 8.92678 12.0732C8.87989 12.0263 8.81631 12 8.75 12H5.25C5.1837 12 5.12011 12.0263 5.07322 12.0732C5.02634 12.1201 5 12.1837 5 12.25Z"/></svg>'

使用：

1{{< github
2  name="链接标题"
3  link="#"
4  description="内容描述"
5  color="#F48201"
6  language="Go"
7>}}

标签块样式

Warning

info

note

tips

新建 notice.html，内容为：

 1<!-- 文件位置：~/layouts/shortcodes/notice.html -->
 2
 3<!--https://github.com/martignoni/hugo-notice-->
 4{{- $noticeType := .Get 0 -}}
 5
 6{{- $raw := (markdownify .Inner | chomp) -}}
 7
 8{{- $block := findRE "(?is)^<(?:address|article|aside|blockquote|canvas|dd|div|dl|dt|fieldset|figcaption|figure|footer|form|h(?:1|2|3|4|5|6)|header|hgroup|hr|li|main|nav|noscript|ol|output|p|pre|section|table|tfoot|ul|video)\\b" $raw 1 -}}
 9
10{{ $icon := (replace (index $.Site.Data.SVG $noticeType) "icon" "icon notice-icon") }}
11<div class="notice {{ $noticeType }}" {{ if len .Params | eq 2 }} id="{{ .Get 1 }}" {{ end }}>
12    <div class="notice-title">{{ $icon | safeHTML }}</div>
13    {{- if or $block (not $raw) }}{{ $raw }}{{ else }}<p>{{ $raw }}</p>{{ end -}}
14</div>

在 custom.scss 中添加：

 1//增加notice短代码
 2.notice {
 3  position:relative;
 4  padding: 1em 1em 1em 2.5em;
 5  margin-bottom: 1em;
 6  border-radius: 4px;
 7  p:last-child {
 8      margin-bottom: 0;
 9  }
10  .notice-title {
11      position: absolute;
12      left: 0.8em;
13      .notice-icon {
14          width: 1.2em;
15          height: 1.2em;
16      }
17  }
18  &.notice-warning {
19      background: hsla(0, 65%, 65%, 0.15);
20      border-left: 5px solid hsl(0, 65%, 65%);
21      .notice-title {
22          color: hsl(0, 65%, 65%);
23      }
24  }
25  &.notice-info {
26      background: hsla(30, 80%, 70%, 0.15);
27      border-left: 5px solid hsl(30, 80%, 70%);
28      .notice-title {
29          color: hsl(30, 80%, 70%);
30      }
31  }
32  &.notice-note {
33      background: hsla(200, 65%, 65%, 0.15);
34      border-left: 5px solid hsl(200, 65%, 65%);
35      .notice-title {
36          color: hsl(200, 65%, 65%);
37      }
38  }
39  &.notice-tip {
40      background: hsla(140, 65%, 65%, 0.15);
41      border-left: 5px solid hsl(140, 65%, 65%);
42      .notice-title {
43          color: hsl(140, 65%, 65%);
44      }
45  }
46}
47
48[data-theme="dark"] .notice {
49  &.notice-warning {
50      background: hsla(0, 25%, 35%, 0.15);
51      border-left: 5px solid hsl(0, 25%, 35%);
52      .notice-title {
53          color: rgba(224, 108, 108, 0.5);
54      }
55  }
56  &.notice-info {
57      background: hsla(30, 25%, 35%, 0.15);
58      border-left: 5px solid hsl(30, 25%, 35%);
59      .notice-title {
60          color: rgba(240, 178, 117, 0.5);
61      }
62  }
63  &.notice-note {
64      background: hsla(200, 25%, 35%, 0.15);
65      border-left: 5px solid hsl(200, 25%, 35%);
66      .notice-title {
67          color: rgba(108, 185, 224, 0.5);
68      }
69  }
70  &.notice-tip {
71      background: hsla(140, 25%, 35%, 0.15);
72      border-left: 5px solid hsl(140, 25%, 35%);
73      .notice-title {
74          color: rgba(108, 224, 147, 0.5);
75      }
76  }
77}

在 data/SVG.toml 中加入：

1# Notice Icon
2notice-warning = '<svg xmlns="http://www.w3.org/2000/svg" class="icon" viewBox="0 0 576 512" fill="hsl(0, 65%, 65%)"><path d="M256 8C119 8 8 119 8 256s111 248 248 248 248-111 248-248S393 8 256 8zM124 296c-6.6.0-12-5.4-12-12v-56c0-6.6 5.4-12 12-12h264c6.6.0 12 5.4 12 12v56c0 6.6-5.4 12-12 12H124z"/></svg>'
3notice-info = '<svg xmlns="http://www.w3.org/2000/svg" class="icon" viewBox="0 0 512 512" fill="hsl(30, 80%, 70%)"><path d="M256 8a248 248 0 100 496 248 248 0 000-496zm0 110a42 42 0 110 84 42 42 0 010-84zm56 254c0 7-5 12-12 12h-88c-7 0-12-5-12-12v-24c0-7 5-12 12-12h12v-64h-12c-7 0-12-5-12-12v-24c0-7 5-12 12-12h64c7 0 12 5 12 12v100h12c7 0 12 5 12 12v24z"/></svg>'
4notice-note = '<svg xmlns="http://www.w3.org/2000/svg" class="icon" viewBox="0 0 512 512" fill="hsl(200, 65%, 65%)"><path d="M504 256a248 248 0 11-496 0 248 248 0 01496 0zm-248 50a46 46 0 100 92 46 46 0 000-92zm-44-165l8 136c0 6 5 11 12 11h48c7 0 12-5 12-11l8-136c0-7-5-13-12-13h-64c-7 0-12 6-12 13z"/></svg>'
5notice-tip = '<svg xmlns="http://www.w3.org/2000/svg" class="icon" viewBox="0 0 512 512" fill="hsl(140, 65%, 65%)"><path d="M504 256a248 248 0 11-496 0 248 248 0 01496 0zM227 387l184-184c7-6 7-16 0-22l-22-23c-7-6-17-6-23 0L216 308l-70-70c-6-6-16-6-23 0l-22 23c-7 6-7 16 0 22l104 104c6 7 16 7 22 0z"/></svg>'

使用：

1{{< notice notice-warning >}}
2Warning
3{{< /notice >}}

时间轴

2024

我是萌新

2025

我还是萌新

新建 timeline.html，内容为：

  1{{- $date := .Get "date" -}} {{- $title := .Get "title" -}} {{- $description := .Get "description" -}} {{- $tags := .Get "tags" -}}
  2
  3<div class="timeline__row">
  4    <div class="timeline__time">
  5        <div class="timeline__time">{{ $date }}</div>
  6        <div class="timeline__split-line"></div>
  7    </div>
  8    <div class="timeline__content">
  9        <div class="timeline__tags">
 10            {{- with split $tags ", " -}} {{- range . }}{{- if eq . "样式" }}
 11            <span class="timeline__tag timeline__tag-style">{{ . }}</span> {{- else if eq . "文章" }}
 12            <span class="timeline__tag timeline__tag-article">{{ . }}</span> {{- else if eq . "页面" }}
 13            <span class="timeline__tag timeline__tag-page">{{ . }}</span> {{- else }}
 14            <span class="timeline__tag">{{ . }}</span> {{- end }} {{- end }} {{- end }}
 15        </div>
 16            <div class="timeline__title">{{ $title }}</div>
 17        <div class="timeline__description">
 18            {{ $description }}
 19        </div>
 20    </div>
 21</div>
 22
 23<style>
 24    .timeline {
 25        display: flex;
 26        flex-direction: column;
 27    }
 28    
 29    .timeline__row {
 30        display: flex;
 31        padding-left: 4%;
 32        height: 90px;
 33    }
 34    
 35    .timeline__time {
 36        flex: 0 0 110px;
 37        color: #5d5d5d;
 38        font-size: 17px;
 39        text-transform: uppercase;
 40        position: relative;
 41        display: flex;
 42        flex-direction: column;
 43        align-items: center;
 44        padding: 0.5rem 0;
 45    }
 46    
 47    .timeline__time-text {
 48        margin: 0;
 49    }
 50    
 51    .timeline__split-line {
 52        position: absolute;
 53        top: 0.5rem;
 54        right: -20px;
 55        height: 100%;
 56        width: 2px;
 57        background-color: #84c4e240;
 58        z-index: 0;
 59    }
 60    
 61    .timeline__split-line:before {
 62        content: "";
 63        position: absolute;
 64        top: 24%;
 65        right: -4px;
 66        transform: translateY(-50%);
 67        width: 10px;
 68        height: 10px;
 69        background-color: #c9e5f2;
 70        box-shadow: 0 0 0 4px var(--theme);
 71        border-radius: 50%;
 72        border: 0px solid #84c4e2;
 73        z-index: -1;
 74    }
 75    
 76    .timeline__content {
 77        flex: 1;
 78        margin-left: 4.5rem;
 79        padding: 0.5rem 0 1.2rem 0;
 80    }
 81    
 82    .timeline__title {
 83        margin: 0;
 84        margin-bottom: 2px;
 85        padding-top: 3px;
 86        margin-left: 0.5rem;
 87        color: var(--content);
 88        font-family: var(--font-family-teshu);
 89        font-size: 19px;
 90        font-weight: 600;
 91        width: fit-content;
 92        display: inline-block;
 93        vertical-align: middle;
 94        /* 垂直居中对齐 */
 95    }
 96    
 97    .timeline__tags {
 98        display: inline-block;
 99        padding: 0;
100        margin-left: 0.3rem;
101        align-items: center;
102        gap: 0.3rem;
103    }
104    
105    .timeline__tag {
106        display: inline-block;
107        color: var(--secondary);
108        background-color: #84c4e230;
109        border: 1.5px solid #84c4e230;
110        border-radius: 999px;
111        padding: 0rem 0.5rem;
112        font-size: 12px;
113        white-space: nowrap;
114        line-height: 1.4rem;
115        opacity: 0.8;
116        vertical-align: middle;
117        /* 垂直居中对齐 */
118    }
119    
120    .timeline__description {
121        font-size: 15px;
122        line-height: 1.6;
123        color: #5d5d5d;
124        overflow: hidden;
125        text-overflow: ellipsis;
126        margin: 0.5rem 0 0.4rem 1.5rem;
127        /* 添加 1.5rem 的左侧内边距 */
128    }
129    /* 为类名为 "timeline__tag-style" 的标签定义颜色 */
130    
131    .timeline__tag-style {
132        background-color: #c581da;
133        /* 替换为你希望的颜色 */
134        border-color: #c581da;
135        /* 与背景色相同或不同，根据需要自定义 */
136        color: #FFFFFF;
137        /* 根据需要选择文本颜色 */
138    }
139    /* 为类名为 "timeline__tag-article" 的标签定义颜色 */
140    
141    .timeline__tag-article {
142        background-color: #92d392;
143        /* 替换为你希望的颜色 */
144        border-color: #92d392;
145        /* 与背景色相同或不同，根据需要自定义 */
146        color: #000000;
147        /* 根据需要选择文本颜色 */
148    }
149    /* 为类名为 "timeline__tag-page" 的标签定义颜色 */
150    
151    .timeline__tag-page {
152        background-color: #707070;
153        /* 替换为你希望的颜色 */
154        border-color: #707070;
155        /* 与背景色相同或不同，根据需要自定义 */
156        color: #FFFFFF;
157        /* 根据需要选择文本颜色 */
158    }
159    
160    @media screen and (max-width: 768px) {
161        .timeline__time {
162            font-size: 14px;
163            /* 在小屏幕上使用较小的字体大小 */
164        }
165        .timeline__title {
166            font-size: 16px;
167            /* 在小屏幕上使用较小的字体大小 */
168        }
169        .timeline__description {
170            font-size: 14px;
171            /* 在小屏幕上使用较小的字体大小 */
172        }
173    }
174</style>

使用：

1{{< timeline date="2024" title="First Time" description="我是萌新" tags="past"  >}}{{< timeline date="2025" title="Second Time" description="我还是萌新" tags="now"  >}}

图片轮播

新建 imgloop.html，内容为：

 1{{ if .Site.Params.enableimgloop }}
 2    <link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/Swiper/3.4.2/css/swiper.min.css">
 3    <!-- Swiper -->
 4    <div class="swiper-container">
 5        <div class="swiper-wrapper">
 6            {{$itItems := split (.Get 0) ","}}
 7            {{range $itItems }}
 8            <div class="swiper-slide">
 9                <img src="{{.}}" alt="">
10            </div>
11            {{end}}
12        </div>
13        <!-- Add Pagination -->
14        <div class="swiper-pagination"></div>
15    </div>
16
17    <script src="https://cdnjs.cloudflare.com/ajax/libs/Swiper/3.4.2/js/swiper.min.js"></script>
18     <!-- Initialize Swiper -->
19     <script>
20        var swiper = new Swiper('.swiper-container', {
21            pagination: '.swiper-pagination',
22            paginationClickable: true,
23        //自动调节高度
24        autoHeight: true,
25        //键盘左右方向键控制
26        keyboardControl : true,
27        //鼠标滑轮控制
28        mousewheelControl : true,
29        //自动切换
30        //autoplay : 5000,
31        //懒加载
32        lazyLoading : true,
33		lazyLoadingInPrevNext : true,
34		//无限循环
35		loop : true,
36        });
37        </script>
38{{ end }}

在 custom.scss 中添加：

 1//图片轮播
 2.swiper-container {
 3    max-width: 820px;
 4    margin: 2em auto;
 5}
 6.swiper-slide {
 7    text-align: center;
 8    font-size: 18px;
 9    background-color: #fff;
10    /* Center slide text vertically */
11    display: flex;
12    justify-content: center;
13    align-items: center;
14    img {
15        margin: 0 !important;
16    }
17}

在 config.yaml 找到 params:，添加 enableimgloop: true。
使用：

1{{< imgloop "1.jpg,2.jpg,3.jpg" >}}

瀑布流相册

新建 gallery.html，内容为：

 1{{ $baseURL := .Site.BaseURL }}
 2{{- with (.Get 0) -}}
 3{{- $files := readDir (print "/static/" .) }}
 4<div class="gallery-photos">
 5  {{- range (sort $files "Name" "asc") -}}
 6    {{- if ( .Name | findRE "\\.(gif|jpg|jpeg|tiff|png|bmp|webp|avif|jxl)") }}
 7    {{- $linkURL := print $baseURL "/" ($.Get 0) "/" .Name | absURL }}
 8    <div class="gallery-photo">
 9      <img class="photo-img" loading='lazy' decoding="async" src="{{  $linkURL  }}" alt="{{ .Name }}" />
10      <span class="photo-title">{{ .Name | replaceRE "\\..*" ""}}</span>
11    </div>
12    {{- end }}
13  {{- end }}
14</div>
15{{- end }}

在 layouts/partials/footer/custom.html 中插入：

 1<!-- 瀑布流相册 -->
 2<script src="https://immmmm.com/waterfall.min.js"></script>
 3<script src="https://immmmm.com/imgStatus.min.js"></script>
 4<script>
 5document.addEventListener('DOMContentLoaded', () => {
 6  //外链 gallery 标签相册瀑布流
 7  var photosAll = document.getElementsByTagName('gallery') || '';
 8  if(photosAll){
 9    for(var i=0;i < photosAll.length;i++){
10      photosAll[i].innerHTML = '<div class="gallery-photos">'+photosAll[i].innerHTML+'</div>'
11      var photosIMG = photosAll[i].getElementsByTagName('img')
12      for(var j=0;j < photosIMG.length;j++){
13        wrap(photosIMG[j], document.createElement('div'));
14      }
15    }
16  }
17  function wrap(el, wrapper) {
18    wrapper.className = "gallery-photo";
19    el.parentNode.insertBefore(wrapper, el);
20    wrapper.appendChild(el);
21  }
22  //相册瀑布流
23  let galleryPhotos = document.querySelectorAll('.gallery-photos') || ''
24  if(galleryPhotos){
25    imgStatus.watch('.gallery-photo img', function(imgs) {
26      if(imgs.isDone()){
27        for(var i=0;i < galleryPhotos.length;i++){
28          waterfall(galleryPhotos[i]);
29          let pagePhoto = galleryPhotos[i].querySelectorAll('.gallery-photo');
30          for(var j=0;j < pagePhoto.length;j++){pagePhoto[j].className += " visible"};
31        }
32      }
33    });
34    window.addEventListener('resize', function () {
35      for(var i=0;i < galleryPhotos.length;i++){
36        waterfall(galleryPhotos[i]);
37      }
38    });
39  }
40});
41</script>

在 layouts/partials/head/custom.html 中插入：

 1<style>
 2  .gallery-photos{width:100%;break-inside: avoid;margin-bottom: 10px;}
 3  .gallery-photo{width:33.3%;position: relative;padding:0px 4px 0px 4px;visibility: hidden;overflow: hidden;}
 4  .gallery-photo.visible{visibility: visible;}
 5  .gallery-photo img{width: 100%;height: 100%;object-fit: cover;border-radius: 5px;box-shadow: 0px 0px 5px rgba(0, 0, 0, 0.3);}
 6  @media screen and (min-width: 1200x) {
 7    .gallery-photo{
 8    width: 100%;
 9    columns: 3;
10    column-gap: 20px;
11    }
12  }
13  @media screen and (min-width: 860px) and (max-width: 1323.98px) {
14    .gallery-photo{    
15    width: 100%;
16    columns: 2;
17    column-gap: 20px;}
18  }
19  @media screen and (max-width: 860px) {
20    .gallery-photo{    
21    width: 100%;
22    columns: 1;}
23  }
24  @media (max-width: 767.98px){
25    .photo-time{display: none;}
26  }
27</style>

使用：

1<gallery>![](https://www.sleepymoon.cyou/2023/hugo-shortcodes/2.jpg)![](https://www.sleepymoon.cyou/2023/hugo-shortcodes/1.jpg)</gallery>

PDF/PPT插入

嵌入PDF

新建 pdf.html，内容为：

 1<div class="pdf" style="
 2    padding-bottom: 66%;
 3    position: relative;
 4    display: block;
 5    width: 100%;
 6    border-bottom: 5px solid;
 7">
 8    <iframe
 9        width="100%"
10        height="100%"
11        src="{{ .Get "src" }}"
12        frameborder="0"
13        allowfullscreen=""
14        style="
15            position: absolute;
16            top: 0;
17            left: 0" >
18    </iframe>
19</div>

使用：

1{{< pdf src="https://www.blatchingtonmill.org.uk/assets/Uploads/All-Of-Me-Sheet-Music-John-Legend-All-Of-Me-Piano-Sheet-Music-Medium-Vocals-Piano-Guitar.pdf" >}}

手动输入NeoDB条目

《八度空间》 [台] 周杰伦

< 9.2 >

歌曲可以拥有与电影媲美的叙事性吗？在短短四分钟左右的歌曲里，43 分钟的专辑《八度空间》中，周杰伦用旺盛的创作力和狂想尝试构建出这样的“空间”。“八度空间”意指西方的八度音阶，在看似局限的音乐空间中，周杰伦用他平时从电影和 MV 得来的灵感，给每首歌曲赋予了情节，打造没有维度限制的音乐异想世界。

Album

新建 book.html，内容为：

 1<div class="db-card">
 2    <div class="db-card-subject">
 3        <div class="db-card-post"><img loading="lazy" decoding="async" referrerpolicy="no-referrer" src="{{ .Get "image" }}"></div>
 4        <div class="db-card-content">
 5            <div class="db-card-title"><a href="{{ .Get "url" }}" class="cute" target="_blank" rel="noreferrer">{{ .Get "title" }}</a></div>
 6            <div class="rating">
 7                <span class="rating_nums"></span><span class="allstardark"><span class="allstarlight" style="width:{{ .Get "rate" }}0%"></span></span><span class="rating_float"></span></span>
 8                <span class="rating_float">< {{ .Get "rate_float" }} ></span>
 9            </div>
10            <div class="db-card-abstract">{{ .Get "brief" }}</div>
11        </div>
12        <div class="db-card-cate">{{ .Get "tag" }}</div>
13    </div>
14</div>

在 custom.scss 中添加：

 1/* db-card -------- start*/
 2.db-card{margin:2.5rem 3rem;background:var(--card-background);border-radius: 7px;box-shadow: 0 6px 10px 0 #00000053;margin-left:auto;margin-right:auto;}
 3.db-card-subject{display: flex;align-items:flex-start;line-height:1.6;padding:12px;position:relative;}
 4.dark .db-card{background:var(--card-background);}
 5.db-card-content {flex:1 1 auto;}
 6.db-card-post {width: 100px;margin-right: 15px;display: flex;flex: 0 0 auto;}
 7.db-card-title {margin-bottom: 3px;font-size: 14px;color: var(--card-text-color-main);;}
 8.db-card-title a{text-decoration: none!important}
 9.db-card-abstract,.db-card-comment{font-size:13px;overflow: auto;max-height:10rem;color: var(--card-text-color-main);;}
10.db-card-cate{position: absolute;top:0;right:0;background:#f99b01;padding:1px 8px;font-size:small;font-style:italic;border-radius:0 8px 0 8px;text-transform:capitalize;}
11.db-card-post img{width: 100px!important;height: 150px!important;border-radius: 4px;-o-object-fit: cover;object-fit: cover;}
12.rating{margin: 0 0 5px;font-size:13px;line-height: 1;display: flex;align-items: center;}
13.rating .allstardark{position:relative;color: #f99b01;height: 16px;width: 80px;background-size: auto 100%;margin-right: 8px;background-repeat: repeat;background-image: url(data:image/svg+xml;base64,PHN2ZyBjbGFzcz0iaWNvbiIgdmlld0JveD0iMCAwIDEwMjQgMTAyNCIgeG1sbnM9Imh0dHA6Ly93d3cudzMub3JnLzIwMDAvc3ZnIiB3aWR0aD0iMzIiIGhlaWdodD0iMzIiPjxwYXRoIGQ9Ik05MDguMSAzNTMuMWwtMjUzLjktMzYuOUw1NDAuNyA4Ni4xYy0zLjEtNi4zLTguMi0xMS40LTE0LjUtMTQuNS0xNS44LTcuOC0zNS0xLjMtNDIuOSAxNC41TDM2OS44IDMxNi4ybC0yNTMuOSAzNi45Yy03IDEtMTMuNCA0LjMtMTguMyA5LjMtMTIuMyAxMi43LTEyLjEgMzIuOS42IDQ1LjNsMTgzLjcgMTc5LjEtNDMuNCAyNTIuOWMtMS4yIDYuOS0uMSAxNC4xIDMuMiAyMC4zIDguMiAxNS42IDI3LjYgMjEuNyA0My4yIDEzLjRMNTEyIDc1NGwyMjcuMSAxMTkuNGM2LjIgMy4zIDEzLjQgNC40IDIwLjMgMy4yIDE3LjQtMyAyOS4xLTE5LjUgMjYuMS0zNi45bC00My40LTI1Mi45IDE4My43LTE3OS4xYzUtNC45IDguMy0xMS4zIDkuMy0xOC4zIDIuNy0xNy41LTkuNS0zMy43LTI3LTM2LjN6TTY2NC44IDU2MS42bDM2LjEgMjEwLjNMNTEyIDY3Mi43IDMyMy4xIDc3MmwzNi4xLTIxMC4zLTE1Mi44LTE0OUw0MTcuNiAzODIgNTEyIDE5MC43IDYwNi40IDM4MmwyMTEuMiAzMC43LTE1Mi44IDE0OC45eiIgZmlsbD0iI2Y5OWIwMSIvPjwvc3ZnPg==);
14}
15.rating .allstarlight{position: absolute;left: 0;color: #f99b01;height:16px;overflow: hidden;background-size: auto 100%;background-repeat: repeat;background-image: url(data:image/svg+xml;base64,PHN2ZyBjbGFzcz0iaWNvbiIgdmlld0JveD0iMCAwIDEwMjQgMTAyNCIgeG1sbnM9Imh0dHA6Ly93d3cudzMub3JnLzIwMDAvc3ZnIiB3aWR0aD0iMzIiIGhlaWdodD0iMzIiPjxwYXRoIGQ9Ik05MDguMSAzNTMuMWwtMjUzLjktMzYuOUw1NDAuNyA4Ni4xYy0zLjEtNi4zLTguMi0xMS40LTE0LjUtMTQuNS0xNS44LTcuOC0zNS0xLjMtNDIuOSAxNC41TDM2OS44IDMxNi4ybC0yNTMuOSAzNi45Yy03IDEtMTMuNCA0LjMtMTguMyA5LjMtMTIuMyAxMi43LTEyLjEgMzIuOS42IDQ1LjNsMTgzLjcgMTc5LjEtNDMuNCAyNTIuOWMtMS4yIDYuOS0uMSAxNC4xIDMuMiAyMC4zIDguMiAxNS42IDI3LjYgMjEuNyA0My4yIDEzLjRMNTEyIDc1NGwyMjcuMSAxMTkuNGM2LjIgMy4zIDEzLjQgNC40IDIwLjMgMy4yIDE3LjQtMyAyOS4xLTE5LjUgMjYuMS0zNi45bC00My40LTI1Mi45IDE4My43LTE3OS4xYzUtNC45IDguMy0xMS4zIDkuMy0xOC4zIDIuNy0xNy41LTkuNS0zMy43LTI3LTM2LjN6IiBmaWxsPSIjZjk5YjAxIi8+PC9zdmc+);}
16@media (max-width:550px) {
17	.db-card{margin:0.8rem 1rem;}
18	.db-card-comment{display: none;}
19}
20/* db-card -------- end */

使用：

1{{< book url="#" image="1.png" title="《JAY》 [台] 周杰倫" rate="9" rate_float="9.2" brief="text" tag="Album" >}}

居中引用

人生代代无穷已，江月年年望相似。
不知江月待何人，但见长江送流水。

新建 quote-center.html，内容为：

1<div class="quote-center">
2  {{- $content := .Inner | markdownify -}} 
3  {{- if not (strings.HasPrefix $content "<p>") }} 
4    {{ printf `</p><p>%s</p>` $content | safeHTML }} 
5  {{- else }} 
6    {{- $content }} 
7  {{- end -}}
8</div>

在 custom.scss 中添加：

 1.quote-center {
 2  background-color:#84c4e230!important;
 3  position: relative;
 4  border-left: none;
 5  padding-left: 0;
 6  padding: 20px!important;
 7  border-radius: 5px!important;
 8  border-top: 0px solid var(--color-markdown-blockquote-border);
 9  border-bottom: 0px solid var(--color-markdown-blockquote-border);
10  p {
11    text-align: center !important;
12    margin-top: 1.5em!important;
13    margin-bottom: 1.5em!important;
14    font-weight: bold;
15  }
16  &::before {
17    position: absolute;
18    left: 0;
19    content: '“---';
20    color: #8aa2d3;
21    font-size: 2.5em;
22    font-weight: normal;
23    margin-top: -5%;
24    margin-left: 1%;
25    height: 90%;
26  }
27  &::after {
28    position: absolute;
29    right: 0;
30    content: '---”';
31    color: #8aa2d3;
32    font-size: 2.5em;
33    font-weight: normal;
34    margin-top: -6%;
35    margin-right: 1%;
36    height: 90%;
37  }
38}

使用：

1{{< quote-center >}}
2人生代代无穷已，江月年年望相似。<br>不知江月待何人，但见长江送流水。
3{{< /quote-center >}}

古书排版

沧海一声笑
滔滔两岸潮
浮沉随浪
只记今朝
苍天笑
纷纷世上潮
谁负谁胜出
天知晓
江山笑
烟雨遥
涛浪淘尽红尘俗世
几多娇
清风笑
竟惹寂寥
豪情还剩了一襟晚照
苍生笑
不再寂寥
豪情仍在痴痴笑笑

新建 verticaltext.html，内容为：

 1<style>
 2.mainvlr {
 3  margin:20px;
 4  font-size: 20px;
 5  letter-spacing: 2px;
 6}
 7
 8.vlr{
 9  writing-mode: vertical-lr;
10}
11
12.vrl{
13  writing-mode: vertical-rl;
14  unicode-bidi: bidi-override;
15  border: 1px solid;
16  padding: 5px;
17  margin: 5px;
18  margin-right: 5px;
19  word-wrap: break-word;
20  overflow-y:auto;
21  height: {{ .Get "height" | default "500" }}px;
22  width: 100%;
23}
24</style>
25
26<div class="vrl" id="vrlmain">
27
28<div class="mainvlr">
29
30{{ .Inner | markdownify }}
31
32</div>
33
34</div>
35
36<script>
37window.scrollTo(document.body.scrollWidth - 500, 0);
38</script>

使用：（默认高度为500px，可以自定义）

1{{< verticaltext height="300px" >}}
2沧海一声笑
3滔滔两岸潮
4{{< /verticaltext >}}

对话样式

John Doe 2023-09-12 14:30

这是左边的消息内容。

2023-09-12 14:45 Alice

这是右边的消息内容。你好呀呀呀呀呀呀呀呀呀呀呀呀呀呀呀呀呀呀呀呀呀呀呀呀

新建 chat.html，内容为：

  1{{ if eq (.Get "position") "left" }}
  2<div class="chat --other">
  3    <div class="chat__inner">
  4        <div class="chat__meta">{{ .Get "name" }}&nbsp;&nbsp;&nbsp;{{ .Get "timestamp" }}</div>
  5        <div class="chat__text">
  6            {{ .Inner }}
  7        </div>
  8    </div>
  9</div>
 10{{ else if eq (.Get "position") "right" }}
 11<div class="chat --self">
 12    <div class="chat__inner">
 13        <div class="chat__meta" style="text-align: right;">{{ .Get "timestamp" }}&nbsp;&nbsp;&nbsp;{{ .Get "name" }}</div>
 14        <div class="chat__text">
 15            {{ .Inner }}
 16        </div>
 17    </div>
 18</div>
 19{{ end }}
 20
 21<style>
 22    .chat {
 23        margin: 10px;
 24        padding: 10px;
 25        position: relative;
 26        /* 添加相对定位，以便定位尖角箭头 */
 27        transition: transform 0.2s;
 28        /* 添加过渡效果，使放大平滑 */
 29        max-width: 80%;
 30        min-width: 15%;
 31    }
 32    
 33    .chat:hover {
 34        transform: scale(1.05);
 35    }
 36    
 37    .chat.--self {
 38        text-align: left;
 39        background-color: #ecf5ff;
 40        color: #000000;
 41        border-radius: 15px;
 42        width: fit-content;
 43        margin-left: auto;
 44    }
 45    /* 尖角箭头 */
 46    
 47    .chat.--self::before {
 48        content: "";
 49        position: absolute;
 50        right: -18px;
 51        /* 调整箭头位置 */
 52        bottom: 5px;
 53        transform: translateY(-50%);
 54        border-width: 15px 0 0 20px;
 55        border-style: solid;
 56        border-color: transparent transparent transparent #ecf5ff;
 57        /* 箭头颜色与对话框背景颜色一致 */
 58    }
 59    /* 左边对话框样式 */
 60    
 61    .chat.--other {
 62        text-align: left;
 63        background-color: #ffecec;
 64        color: #333;
 65        border-radius: 15px;
 66        position: relative;
 67        width: fit-content;
 68    }
 69    /* 左边对话框的尖角箭头 */
 70    
 71    .chat.--other::before {
 72        content: "";
 73        position: absolute;
 74        left: -18px;
 75        bottom: 5px;
 76        transform: translateY(-50%);
 77        border-width: 15px 20px 0 0;
 78        border-style: solid;
 79        border-color: transparent #ffecec transparent transparent;
 80    }
 81    /* 消息元数据样式（名称和时间戳） */
 82    
 83    .chat__meta {
 84        font-weight: bold;
 85        font-size: 0.67em;
 86        color: #707070;
 87        margin-bottom: 5px;
 88    }
 89    /* 消息文本样式 */
 90    
 91    .chat__text {
 92        font-size: 0.9em;
 93        margin-left: 10px;
 94        word-break: break-all;
 95    }
 96    
 97    [data-scheme="dark"] {
 98        .chat.--self {
 99            color: #fefefe;
100            background-color: #253958;
101        }
102        .chat.--self::before {
103            border-color: transparent transparent transparent #253958;
104        }
105        .chat.--other {
106            color: #fefefe;
107            background-color: #1a1a1a;
108        }
109        .chat.--other::before {
110            border-color: transparent #1a1a1a transparent transparent;
111        }
112        .chat__meta {
113            color: #b1b1b1;
114        }
115    }
116</style>

使用：

1{{< chat position="left" name="John Doe" timestamp="2023-09-12 14:30" >}}这是左边的消息内容。{{< /chat >}}
2{{< chat position="right" name="Alice" timestamp="2023-09-12 14:45" >}}这是右边的消息内容。{{< /chat >}}

脚注

第一层引用¹

第二层引用²

第三层引用³

单独引用²

新建 layouts/shortcodes/inner.html，内容为：

1{{ .Inner }}

新建 layouts/shortcodes/outer.html，内容为：

1{{ .Inner }}

使用：（outer 是外层引用或用作单独脚注，inner仅用作内部嵌套的脚注）

 1{{% outer %}}
 2footnote[^1]
 3{{< inner >}}
 4footnote[^2]
 5{{< /inner >}}
 6{{% /outer %}}
 7
 8...
 9...
10
11[^1]: footnote 1
12[^2]: footnote 2

简化版引用

十里青山远，潮平路带沙。数声啼鸟怨年华。又是凄凉时候，在天涯。白露收残月，清风散晓霞。绿杨堤畔问荷花。记得年时沽酒，那人家。

新建 simple-notice.html，内容为：

 1<!-- 文件位置：~/layouts/shortcodes/notice.html -->
 2
 3<!--https://github.com/martignoni/hugo-notice-->
 4{{- $noticeType := .Get 0 -}}
 5
 6{{- $raw := (markdownify .Inner | chomp) -}}
 7
 8{{- $block := findRE "(?is)^<(?:address|article|aside|blockquote|canvas|dd|div|dl|dt|fieldset|figcaption|figure|footer|form|h(?:1|2|3|4|5|6)|header|hgroup|hr|li|main|nav|noscript|ol|output|p|pre|section|table|tfoot|ul|video)\\b" $raw 1 -}}
 9
10{{ $icon := (replace (index $.Site.Data.SVG $noticeType) "icon" "icon simple-notice-icon") }}
11<div class="simple-notice {{ $noticeType }}" {{ if len .Params | eq 2 }} id="{{ .Get 1 }}" {{ end }}>
12    <div class="simple-notice-title">{{ $icon | safeHTML }}</div>
13    {{- if or $block (not $raw) }}{{ $raw }}{{ else }}<p>{{ $raw }}</p>{{ end -}}
14</div>

在 custom.scss 中添加：

  1// 文件位置：~/assets/scss/custom.scss
  2
  3.simple-notice {
  4    position:relative;
  5    padding: 1em 0 1em 2em;
  6    margin-bottom: 1em;
  7    transition: all .5s;
  8    p:last-child {
  9        margin-bottom: 0;
 10    }
 11    .simple-notice-title {
 12        position: absolute;
 13        left: 0.8em;
 14        .simple-notice-icon {
 15            width: 1em;
 16            height: 1em;
 17            margin-left: -0.8em;
 18        }
 19    }
 20    &.simple-notice-warning {
 21        border-top: 2px solid hsl(0, 100%, 35%);
 22        color: hsl(0, 100%, 35%);
 23        .simple-notice-title {
 24            color: hsl(0, 100%, 35%);
 25        }
 26        a {
 27            color: hsl(0, 100%, 35%);
 28            text-decoration-color: hsl(0, 100%, 35%);
 29        }
 30    }
 31    &.simple-notice-info {
 32        border-top: 2px solid hsl(40, 80%, 45%);
 33        color: hsl(40, 80%, 45%);
 34        .simple-notice-title {
 35            color: hsl(40, 80%, 45%);
 36        }
 37        a {
 38            color: hsl(40, 80%, 45%);
 39            text-decoration-color: hsl(40, 80%, 45%);
 40        }
 41    }
 42    &.simple-notice-note {
 43        border-top: 2px solid hsl(210, 100%, 25%);
 44        color: hsl(210, 100%, 25%);
 45        .simple-notice-title {
 46            color: hsl(210, 100%, 25%);
 47        }
 48        a {
 49            color: hsl(210, 100%, 25%);
 50            text-decoration-color: hsl(210, 100%, 25%);
 51        }
 52    }
 53    &.simple-notice-tip {
 54        border-top: 2px solid hsl(150, 100%, 25%);
 55        color: hsl(150, 100%, 25%);
 56        .simple-notice-title {
 57            color: hsl(150, 100%, 25%);
 58        }
 59        a {
 60            color: hsl(150, 100%, 25%);
 61            text-decoration-color: hsl(150, 100%, 25%);
 62        }
 63    }
 64}
 65
 66[data-theme="dark"] .simple-notice {
 67    &.simple-notice-warning {
 68        border-top: 2px solid hsl(0, 65%, 65%);
 69        color: hsl(0, 65%, 65%);
 70        .simple-notice-title {
 71            color: hsl(0, 65%, 65%);
 72        }
 73        a {
 74            color: hsl(0, 65%, 65%);
 75            text-decoration-color: hsl(0, 65%, 65%);
 76        }
 77    }
 78    &.simple-notice-info {
 79        border-top: 2px solid hsl(30, 80%, 70%);
 80        color: hsl(30, 80%, 70%);
 81        .simple-notice-title {
 82            color: hsl(30, 80%, 70%);
 83        }
 84        a {
 85            color: hsl(30, 80%, 70%);
 86            text-decoration-color: hsl(30, 80%, 70%);
 87        }
 88    }
 89    &.simple-notice-note {
 90        border-top: 2px solid hsl(200, 65%, 65%);
 91        color: hsl(200, 65%, 65%);
 92        .simple-notice-title {
 93            color: hsl(200, 65%, 65%);
 94        }
 95        a {
 96            color: hsl(200, 65%, 65%);
 97            text-decoration-color: hsl(200, 65%, 65%);
 98        }
 99    }
100    &.simple-notice-tip {
101        border-top: 2px solid hsl(140, 65%, 65%);
102        color: hsl(140, 65%, 65%);
103        .simple-notice-title {
104            color: hsl(140, 65%, 65%);
105        }
106        a {
107            color: hsl(140, 65%, 65%);
108            text-decoration-color: hsl(140, 65%, 65%);
109        }
110    }
111}

在 data/SVG.toml 中插入图标：

1# 文件位置：~/data/SVG.toml
2
3# Notice Icon
4simple-notice-warning = '<svg xmlns="http://www.w3.org/2000/svg" class="icon" viewBox="0 0 512 512"><path d="M114.57 76.07a45.71 45.71 0 00-67.51-6.41c-17.58 16.18-19 43.52-4.75 62.77l91.78 123-92.33 124.15c-14.23 19.25-13.11 46.59 4.74 62.77a45.71 45.71 0 0067.5-6.41L242.89 262.7a12.14 12.14 0 000-14.23zm355.67 303.51l-92.33-124.13 91.78-123c14.22-19.25 12.83-46.59-4.75-62.77a45.71 45.71 0 00-67.51 6.41l-128 172.12a12.14 12.14 0 000 14.23L398 435.94a45.71 45.71 0 0067.51 6.41c17.84-16.18 18.96-43.52 4.73-62.77z"/></svg>'
5simple-notice-note = '<svg xmlns="http://www.w3.org/2000/svg" class="icon" viewBox="0 0 192 512"><path d="M176 432c0 44.11-35.89 80-80 80s-80-35.89-80-80 35.89-80 80-80 80 35.89 80 80zM25.26 25.2l13.6 272A24 24 0 0062.83 320h66.34a24 24 0 0023.97-22.8l13.6-272A24 24 0 00142.77 0H49.23a24 24 0 00-23.97 25.2z"/></svg>'
6simple-notice-info = '<svg xmlns="http://www.w3.org/2000/svg" class="icon" viewBox="0 0 192 512"><path d="M20 424.23h20V279.77H20a20 20 0 01-20-20V212a20 20 0 0120-20h112a20 20 0 0120 20v212.23h20a20 20 0 0120 20V492a20 20 0 01-20 20H20a20 20 0 01-20-20v-47.77a20 20 0 0120-20zM96 0a72 72 0 100 144A72 72 0 0096 0z"/></svg>'
7simple-notice-tip = '<svg xmlns="http://www.w3.org/2000/svg" class="icon" viewBox="0 0 512 512"><path d="M173.9 439.4L7.5 273c-10-10-10-26.2 0-36.2l36.2-36.2c10-10 26.2-10 36.2 0L192 312.69l240.1-240.1c10-10 26.2-10 36.2 0l36.2 36.21c10 10 10 26.2 0 36.2L210.1 439.4c-10 10-26.2 10-36.2 0z"/></svg>'

使用：

1{{< simple-notice simple-notice-warning >}}
2十里青山远，潮平路带沙。数声啼鸟怨年华。又是凄凉时候，在天涯。白露收残月，清风散晓霞。绿杨堤畔问荷花。记得年时沽酒，那人家。
3{{< /simple-notice >}}

荧光标注

红色萤光笔橙色萤光笔黄色萤光笔绿色萤光笔蓝色萤光笔紫色萤光笔

新建 setSwlColor.html，内容为：

1{{ $color := default "mark_blue" (.Get "color") }}<span class='swl-marker {{ $color }}'>{{ .Inner }}</span>

在 custom.scss 中添加：

 1.swl-marker {
 2    display: inline;
 3    padding: 2px;
 4}
 5
 6.mark_blue {
 7    background: -webkit-linear-gradient(transparent 64%, #b7e3ff 0%);
 8    background: linear-gradient(transparent 64%, #b7e3ff 0%)
 9}
10
11.mark_green {
12    background: -webkit-linear-gradient(transparent 64%, #bdf9c3 0%);
13    background: linear-gradient(transparent 64%, #bdf9c3 0%);
14}
15
16.mark_yellow {
17    background: -webkit-linear-gradient(transparent 64%, #fcf69f 0%);
18    background: linear-gradient(transparent 64%, #fcf69f 0%)
19}
20
21.mark_orange {
22    background: -webkit-linear-gradient(transparent 64%, #ffddbc 0%);
23    background: linear-gradient(transparent 64%, #ffddbc 0%)
24}
25
26.mark_red {
27    background: -webkit-linear-gradient(transparent 64%, #dfa1a1 0%);
28    background: linear-gradient(transparent 64%, #dfa1a1 0%)
29}

使用：

1{{< setSwlColor color="mark_blue" >}}蓝色萤光笔{{< /setSwlColor >}}

警告框

标注

摘要

信息

提示

成功

疑问

警告

失败

危险

漏洞

范例

引用

新建 admonition.html，内容为：

 1{{- /* 使用方法 {{< admonition type=tip title="小标题" open=false >}}内容{{< /admonition >}}，其中type支持note, abstract, info, tip, success, question, warning, failure, danger, bug, example, quote， open表示默认是否为展开状态 */ -}}
 2{{- $inner := .Inner | .Page.RenderString -}}
 3
 4{{- $iconMap := dict "note" "fas fa-pencil-alt fa-fw" -}}
 5{{- $iconMap  = dict "abstract" "fas fa-list-ul fa-fw" | merge $iconMap -}}
 6{{- $iconMap  = dict "info" "fas fa-info-circle fa-fw" | merge $iconMap -}}
 7{{- $iconMap  = dict "tip" "fas fa-lightbulb fa-fw" | merge $iconMap -}}
 8{{- $iconMap  = dict "success" "fas fa-check-circle fa-fw" | merge $iconMap -}}
 9{{- $iconMap  = dict "question" "fas fa-question-circle fa-fw" | merge $iconMap -}}
10{{- $iconMap  = dict "warning" "fas fa-exclamation-triangle fa-fw" | merge $iconMap -}}
11{{- $iconMap  = dict "failure" "fas fa-times-circle fa-fw" | merge $iconMap -}}
12{{- $iconMap  = dict "danger" "fas fa-skull-crossbones fa-fw" | merge $iconMap -}}
13{{- $iconMap  = dict "bug" "fas fa-bug fa-fw" | merge $iconMap -}}
14{{- $iconMap  = dict "example" "fas fa-list-ol fa-fw" | merge $iconMap -}}
15{{- $iconMap  = dict "quote" "fas fa-quote-right fa-fw" | merge $iconMap -}}
16{{- $iconDetails := "fas fa-angle-right fa-fw" -}}
17
18{{- if .IsNamedParams -}}
19    {{- $type := .Get "type" | default "note" -}}
20    <div class="details admonition {{ $type }}{{ if .Get `open` | ne false }} open{{ end }}">
21        <div class="details-summary admonition-title">
22            <i class="icon {{ index $iconMap $type | default (index $iconMap "note") }}"></i>{{ .Get "title" | default (T $type) }}<i class="details-icon {{ $iconDetails }}"></i>
23        </div>
24        <div class="details-content">
25            <div class="admonition-content">
26                {{- $inner -}}
27            </div>
28        </div>
29    </div>
30{{- else -}}
31    {{- $type := .Get 0 | default "note" -}}
32    <div class="details admonition {{ $type }}{{ if .Get 2 | ne false }} open{{ end }}">
33        <div class="details-summary admonition-title">
34            <i class="icon {{ index $iconMap $type | default (index $iconMap "note") }}"></i>{{ .Get 1 | default (T $type) }}<i class="details-icon {{ $iconDetails }}"></i>
35        </div>
36        <div class="details-content">
37            <div class="admonition-content">
38                {{- $inner -}}
39            </div>
40        </div>
41    </div>
42{{- end -}}

在 custom.scss 中添加：

  1/*!
  2 * Font Awesome Free 5.15.4 by @fontawesome - https://fontawesome.com
  3 * License - https://fontawesome.com/license/free (Icons: CC BY 4.0, Fonts: SIL OFL 1.1, Code: MIT License)
  4 */
  5 .fa,.fab,.fad,.fal,.far,.fas{-moz-osx-font-smoothing:grayscale;-webkit-font-smoothing:antialiased;display:inline-block;font-style:normal;font-variant:normal;text-rendering:auto;line-height:1}.fa-lg{font-size:1.33333em;line-height:.75em;vertical-align:-.0667em}.fa-xs{font-size:.75em}.fa-sm{font-size:.875em}.fa-1x{font-size:1em}.fa-2x{font-size:2em}.fa-3x{font-size:3em}.fa-4x{font-size:4em}.fa-5x{font-size:5em}.fa-6x{font-size:6em}.fa-7x{font-size:7em}.fa-8x{font-size:8em}.fa-9x{font-size:9em}.fa-10x{font-size:10em}.fa-fw{text-align:center;width:1.25em}.fa-ul{list-style-type:none;margin-left:2.5em;padding-left:0}.fa-ul>li{position:relative}.fa-li{left:-2em;position:absolute;text-align:center;width:2em;line-height:inherit}.fa-border{border:.08em solid #eee;border-radius:.1em;padding:.2em .25em .15em}.fa-pull-left{float:left}.fa-pull-right{float:right}.fa.fa-pull-left,.fab.fa-pull-left,.fal.fa-pull-left,.far.fa-pull-left,.fas.fa-pull-left{margin-right:.3em}.fa.fa-pull-right,.fab.fa-pull-right,.fal.fa-pull-right,.far.fa-pull-right,.fas.fa-pull-right{margin-left:.3em}.fa-spin{-webkit-animation:fa-spin 2s linear infinite;animation:fa-spin 2s linear infinite}.fa-pulse{-webkit-animation:fa-spin 1s steps(8) infinite;animation:fa-spin 1s steps(8) infinite}@-webkit-keyframes fa-spin{0%{-webkit-transform:rotate(0deg);transform:rotate(0deg)}to{-webkit-transform:rotate(1turn);transform:rotate(1turn)}}@keyframes fa-spin{0%{-webkit-transform:rotate(0deg);transform:rotate(0deg)}to{-webkit-transform:rotate(1turn);transform:rotate(1turn)}}.fa-rotate-90{-ms-filter:"progid:DXImageTransform.Microsoft.BasicImage(rotation=1)";-webkit-transform:rotate(90deg);transform:rotate(90deg)}.fa-rotate-180{-ms-filter:"progid:DXImageTransform.Microsoft.BasicImage(rotation=2)";-webkit-transform:rotate(180deg);transform:rotate(180deg)}.fa-rotate-270{-ms-filter:"progid:DXImageTransform.Microsoft.BasicImage(rotation=3)";-webkit-transform:rotate(270deg);transform:rotate(270deg)}.fa-flip-horizontal{-ms-filter:"progid:DXImageTransform.Microsoft.BasicImage(rotation=0, mirror=1)";-webkit-transform:scaleX(-1);transform:scaleX(-1)}.fa-flip-vertical{-webkit-transform:scaleY(-1);transform:scaleY(-1)}.fa-flip-both,.fa-flip-horizontal.fa-flip-vertical,.fa-flip-vertical{-ms-filter:"progid:DXImageTransform.Microsoft.BasicImage(rotation=2, mirror=1)"}.fa-flip-both,.fa-flip-horizontal.fa-flip-vertical{-webkit-transform:scale(-1);transform:scale(-1)}:root .fa-flip-both,:root .fa-flip-horizontal,:root .fa-flip-vertical,:root .fa-rotate-90,:root .fa-rotate-180,:root .fa-rotate-270{-webkit-filter:none;filter:none}.fa-stack{display:inline-block;height:2em;line-height:2em;position:relative;vertical-align:middle;width:2.5em}.fa-stack-1x,.fa-stack-2x{left:0;position:absolute;text-align:center;width:100%}.fa-stack-1x{line-height:inherit}.fa-stack-2x{font-size:2em}.fa-inverse{color:#fff}.fa-500px:before{content:"\f26e"}.fa-accessible-icon:before{content:"\f368"}.fa-accusoft:before{content:"\f369"}.fa-acquisitions-incorporated:before{content:"\f6af"}.fa-ad:before{content:"\f641"}.fa-address-book:before{content:"\f2b9"}.fa-address-card:before{content:"\f2bb"}.fa-adjust:before{content:"\f042"}.fa-adn:before{content:"\f170"}.fa-adversal:before{content:"\f36a"}.fa-affiliatetheme:before{content:"\f36b"}.fa-air-freshener:before{content:"\f5d0"}.fa-airbnb:before{content:"\f834"}.fa-algolia:before{content:"\f36c"}.fa-align-center:before{content:"\f037"}.fa-align-justify:before{content:"\f039"}.fa-align-left:before{content:"\f036"}.fa-align-right:before{content:"\f038"}.fa-alipay:before{content:"\f642"}.fa-allergies:before{content:"\f461"}.fa-amazon:before{content:"\f270"}.fa-amazon-pay:before{content:"\f42c"}.fa-ambulance:before{content:"\f0f9"}.fa-american-sign-language-interpreting:before{content:"\f2a3"}.fa-amilia:before{content:"\f36d"}.fa-anchor:before{content:"\f13d"}.fa-android:before{content:"\f17b"}.fa-angellist:before{content:"\f209"}.fa-angle-double-down:before{content:"\f103"}.fa-angle-double-left:before{content:"\f100"}.fa-angle-double-right:before{content:"\f101"}.fa-angle-double-up:before{content:"\f102"}.fa-angle-down:before{content:"\f107"}.fa-angle-left:before{content:"\f104"}.fa-angle-right:before{content:"\f105"}.fa-angle-up:before{content:"\f106"}.fa-angry:before{content:"\f556"}.fa-angrycreative:before{content:"\f36e"}.fa-angular:before{content:"\f420"}.fa-ankh:before{content:"\f644"}.fa-app-store:before{content:"\f36f"}.fa-app-store-ios:before{content:"\f370"}.fa-apper:before{content:"\f371"}.fa-apple:before{content:"\f179"}.fa-apple-alt:before{content:"\f5d1"}.fa-apple-pay:before{content:"\f415"}.fa-archive:before{content:"\f187"}.fa-archway:before{content:"\f557"}.fa-arrow-alt-circle-down:before{content:"\f358"}.fa-arrow-alt-circle-left:before{content:"\f359"}.fa-arrow-alt-circle-right:before{content:"\f35a"}.fa-arrow-alt-circle-up:before{content:"\f35b"}.fa-arrow-circle-down:before{content:"\f0ab"}.fa-arrow-circle-left:before{content:"\f0a8"}.fa-arrow-circle-right:before{content:"\f0a9"}.fa-arrow-circle-up:before{content:"\f0aa"}.fa-arrow-down:before{content:"\f063"}.fa-arrow-left:before{content:"\f060"}.fa-arrow-right:before{content:"\f061"}.fa-arrow-up:before{content:"\f062"}.fa-arrows-alt:before{content:"\f0b2"}.fa-arrows-alt-h:before{content:"\f337"}.fa-arrows-alt-v:before{content:"\f338"}.fa-artstation:before{content:"\f77a"}.fa-assistive-listening-systems:before{content:"\f2a2"}.fa-asterisk:before{content:"\f069"}.fa-asymmetrik:before{content:"\f372"}.fa-at:before{content:"\f1fa"}.fa-atlas:before{content:"\f558"}.fa-atlassian:before{content:"\f77b"}.fa-atom:before{content:"\f5d2"}.fa-audible:before{content:"\f373"}.fa-audio-description:before{content:"\f29e"}.fa-autoprefixer:before{content:"\f41c"}.fa-avianex:before{content:"\f374"}.fa-aviato:before{content:"\f421"}.fa-award:before{content:"\f559"}.fa-aws:before{content:"\f375"}.fa-baby:before{content:"\f77c"}.fa-baby-carriage:before{content:"\f77d"}.fa-backspace:before{content:"\f55a"}.fa-backward:before{content:"\f04a"}.fa-bacon:before{content:"\f7e5"}.fa-bacteria:before{content:"\e059"}.fa-bacterium:before{content:"\e05a"}.fa-bahai:before{content:"\f666"}.fa-balance-scale:before{content:"\f24e"}.fa-balance-scale-left:before{content:"\f515"}.fa-balance-scale-right:before{content:"\f516"}.fa-ban:before{content:"\f05e"}.fa-band-aid:before{content:"\f462"}.fa-bandcamp:before{content:"\f2d5"}.fa-barcode:before{content:"\f02a"}.fa-bars:before{content:"\f0c9"}.fa-baseball-ball:before{content:"\f433"}.fa-basketball-ball:before{content:"\f434"}.fa-bath:before{content:"\f2cd"}.fa-battery-empty:before{content:"\f244"}.fa-battery-full:before{content:"\f240"}.fa-battery-half:before{content:"\f242"}.fa-battery-quarter:before{content:"\f243"}.fa-battery-three-quarters:before{content:"\f241"}.fa-battle-net:before{content:"\f835"}.fa-bed:before{content:"\f236"}.fa-beer:before{content:"\f0fc"}.fa-behance:before{content:"\f1b4"}.fa-behance-square:before{content:"\f1b5"}.fa-bell:before{content:"\f0f3"}.fa-bell-slash:before{content:"\f1f6"}.fa-bezier-curve:before{content:"\f55b"}.fa-bible:before{content:"\f647"}.fa-bicycle:before{content:"\f206"}.fa-biking:before{content:"\f84a"}.fa-bimobject:before{content:"\f378"}.fa-binoculars:before{content:"\f1e5"}.fa-biohazard:before{content:"\f780"}.fa-birthday-cake:before{content:"\f1fd"}.fa-bitbucket:before{content:"\f171"}.fa-bitcoin:before{content:"\f379"}.fa-bity:before{content:"\f37a"}.fa-black-tie:before{content:"\f27e"}.fa-blackberry:before{content:"\f37b"}.fa-blender:before{content:"\f517"}.fa-blender-phone:before{content:"\f6b6"}.fa-blind:before{content:"\f29d"}.fa-blog:before{content:"\f781"}.fa-blogger:before{content:"\f37c"}.fa-blogger-b:before{content:"\f37d"}.fa-bluetooth:before{content:"\f293"}.fa-bluetooth-b:before{content:"\f294"}.fa-bold:before{content:"\f032"}.fa-bolt:before{content:"\f0e7"}.fa-bomb:before{content:"\f1e2"}.fa-bone:before{content:"\f5d7"}.fa-bong:before{content:"\f55c"}.fa-book:before{content:"\f02d"}.fa-book-dead:before{content:"\f6b7"}.fa-book-medical:before{content:"\f7e6"}.fa-book-open:before{content:"\f518"}.fa-book-reader:before{content:"\f5da"}.fa-bookmark:before{content:"\f02e"}.fa-bootstrap:before{content:"\f836"}.fa-border-all:before{content:"\f84c"}.fa-border-none:before{content:"\f850"}.fa-border-style:before{content:"\f853"}.fa-bowling-ball:before{content:"\f436"}.fa-box:before{content:"\f466"}.fa-box-open:before{content:"\f49e"}.fa-box-tissue:before{content:"\e05b"}.fa-boxes:before{content:"\f468"}.fa-braille:before{content:"\f2a1"}.fa-brain:before{content:"\f5dc"}.fa-bread-slice:before{content:"\f7ec"}.fa-briefcase:before{content:"\f0b1"}.fa-briefcase-medical:before{content:"\f469"}.fa-broadcast-tower:before{content:"\f519"}.fa-broom:before{content:"\f51a"}.fa-brush:before{content:"\f55d"}.fa-btc:before{content:"\f15a"}.fa-buffer:before{content:"\f837"}.fa-bug:before{content:"\f188"}.fa-building:before{content:"\f1ad"}.fa-bullhorn:before{content:"\f0a1"}.fa-bullseye:before{content:"\f140"}.fa-burn:before{content:"\f46a"}.fa-buromobelexperte:before{content:"\f37f"}.fa-bus:before{content:"\f207"}.fa-bus-alt:before{content:"\f55e"}.fa-business-time:before{content:"\f64a"}.fa-buy-n-large:before{content:"\f8a6"}.fa-buysellads:before{content:"\f20d"}.fa-calculator:before{content:"\f1ec"}.fa-calendar:before{content:"\f133"}.fa-calendar-alt:before{content:"\f073"}.fa-calendar-check:before{content:"\f274"}.fa-calendar-day:before{content:"\f783"}.fa-calendar-minus:before{content:"\f272"}.fa-calendar-plus:before{content:"\f271"}.fa-calendar-times:before{content:"\f273"}.fa-calendar-week:before{content:"\f784"}.fa-camera:before{content:"\f030"}.fa-camera-retro:before{content:"\f083"}.fa-campground:before{content:"\f6bb"}.fa-canadian-maple-leaf:before{content:"\f785"}.fa-candy-cane:before{content:"\f786"}.fa-cannabis:before{content:"\f55f"}.fa-capsules:before{content:"\f46b"}.fa-car:before{content:"\f1b9"}.fa-car-alt:before{content:"\f5de"}.fa-car-battery:before{content:"\f5df"}.fa-car-crash:before{content:"\f5e1"}.fa-car-side:before{content:"\f5e4"}.fa-caravan:before{content:"\f8ff"}.fa-caret-down:before{content:"\f0d7"}.fa-caret-left:before{content:"\f0d9"}.fa-caret-right:before{content:"\f0da"}.fa-caret-square-down:before{content:"\f150"}.fa-caret-square-left:before{content:"\f191"}.fa-caret-square-right:before{content:"\f152"}.fa-caret-square-up:before{content:"\f151"}.fa-caret-up:before{content:"\f0d8"}.fa-carrot:before{content:"\f787"}.fa-cart-arrow-down:before{content:"\f218"}.fa-cart-plus:before{content:"\f217"}.fa-cash-register:before{content:"\f788"}.fa-cat:before{content:"\f6be"}.fa-cc-amazon-pay:before{content:"\f42d"}.fa-cc-amex:before{content:"\f1f3"}.fa-cc-apple-pay:before{content:"\f416"}.fa-cc-diners-club:before{content:"\f24c"}.fa-cc-discover:before{content:"\f1f2"}.fa-cc-jcb:before{content:"\f24b"}.fa-cc-mastercard:before{content:"\f1f1"}.fa-cc-paypal:before{content:"\f1f4"}.fa-cc-stripe:before{content:"\f1f5"}.fa-cc-visa:before{content:"\f1f0"}.fa-centercode:before{content:"\f380"}.fa-centos:before{content:"\f789"}.fa-certificate:before{content:"\f0a3"}.fa-chair:before{content:"\f6c0"}.fa-chalkboard:before{content:"\f51b"}.fa-chalkboard-teacher:before{content:"\f51c"}.fa-charging-station:before{content:"\f5e7"}.fa-chart-area:before{content:"\f1fe"}.fa-chart-bar:before{content:"\f080"}.fa-chart-line:before{content:"\f201"}.fa-chart-pie:before{content:"\f200"}.fa-check:before{content:"\f00c"}.fa-check-circle:before{content:"\f058"}.fa-check-double:before{content:"\f560"}.fa-check-square:before{content:"\f14a"}.fa-cheese:before{content:"\f7ef"}.fa-chess:before{content:"\f439"}.fa-chess-bishop:before{content:"\f43a"}.fa-chess-board:before{content:"\f43c"}.fa-chess-king:before{content:"\f43f"}.fa-chess-knight:before{content:"\f441"}.fa-chess-pawn:before{content:"\f443"}.fa-chess-queen:before{content:"\f445"}.fa-chess-rook:before{content:"\f447"}.fa-chevron-circle-down:before{content:"\f13a"}.fa-chevron-circle-left:before{content:"\f137"}.fa-chevron-circle-right:before{content:"\f138"}.fa-chevron-circle-up:before{content:"\f139"}.fa-chevron-down:before{content:"\f078"}.fa-chevron-left:before{content:"\f053"}.fa-chevron-right:before{content:"\f054"}.fa-chevron-up:before{content:"\f077"}.fa-child:before{content:"\f1ae"}.fa-chrome:before{content:"\f268"}.fa-chromecast:before{content:"\f838"}.fa-church:before{content:"\f51d"}.fa-circle:before{content:"\f111"}.fa-circle-notch:before{content:"\f1ce"}.fa-city:before{content:"\f64f"}.fa-clinic-medical:before{content:"\f7f2"}.fa-clipboard:before{content:"\f328"}.fa-clipboard-check:before{content:"\f46c"}.fa-clipboard-list:before{content:"\f46d"}.fa-clock:before{content:"\f017"}.fa-clone:before{content:"\f24d"}.fa-closed-captioning:before{content:"\f20a"}.fa-cloud:before{content:"\f0c2"}.fa-cloud-download-alt:before{content:"\f381"}.fa-cloud-meatball:before{content:"\f73b"}.fa-cloud-moon:before{content:"\f6c3"}.fa-cloud-moon-rain:before{content:"\f73c"}.fa-cloud-rain:before{content:"\f73d"}.fa-cloud-showers-heavy:before{content:"\f740"}.fa-cloud-sun:before{content:"\f6c4"}.fa-cloud-sun-rain:before{content:"\f743"}.fa-cloud-upload-alt:before{content:"\f382"}.fa-cloudflare:before{content:"\e07d"}.fa-cloudscale:before{content:"\f383"}.fa-cloudsmith:before{content:"\f384"}.fa-cloudversify:before{content:"\f385"}.fa-cocktail:before{content:"\f561"}.fa-code:before{content:"\f121"}.fa-code-branch:before{content:"\f126"}.fa-codepen:before{content:"\f1cb"}.fa-codiepie:before{content:"\f284"}.fa-coffee:before{content:"\f0f4"}.fa-cog:before{content:"\f013"}.fa-cogs:before{content:"\f085"}.fa-coins:before{content:"\f51e"}.fa-columns:before{content:"\f0db"}.fa-comment:before{content:"\f075"}.fa-comment-alt:before{content:"\f27a"}.fa-comment-dollar:before{content:"\f651"}.fa-comment-dots:before{content:"\f4ad"}.fa-comment-medical:before{content:"\f7f5"}.fa-comment-slash:before{content:"\f4b3"}.fa-comments:before{content:"\f086"}.fa-comments-dollar:before{content:"\f653"}.fa-compact-disc:before{content:"\f51f"}.fa-compass:before{content:"\f14e"}.fa-compress:before{content:"\f066"}.fa-compress-alt:before{content:"\f422"}.fa-compress-arrows-alt:before{content:"\f78c"}.fa-concierge-bell:before{content:"\f562"}.fa-confluence:before{content:"\f78d"}.fa-connectdevelop:before{content:"\f20e"}.fa-contao:before{content:"\f26d"}.fa-cookie:before{content:"\f563"}.fa-cookie-bite:before{content:"\f564"}.fa-copy:before{content:"\f0c5"}.fa-copyright:before{content:"\f1f9"}.fa-cotton-bureau:before{content:"\f89e"}.fa-couch:before{content:"\f4b8"}.fa-cpanel:before{content:"\f388"}.fa-creative-commons:before{content:"\f25e"}.fa-creative-commons-by:before{content:"\f4e7"}.fa-creative-commons-nc:before{content:"\f4e8"}.fa-creative-commons-nc-eu:before{content:"\f4e9"}.fa-creative-commons-nc-jp:before{content:"\f4ea"}.fa-creative-commons-nd:before{content:"\f4eb"}.fa-creative-commons-pd:before{content:"\f4ec"}.fa-creative-commons-pd-alt:before{content:"\f4ed"}.fa-creative-commons-remix:before{content:"\f4ee"}.fa-creative-commons-sa:before{content:"\f4ef"}.fa-creative-commons-sampling:before{content:"\f4f0"}.fa-creative-commons-sampling-plus:before{content:"\f4f1"}.fa-creative-commons-share:before{content:"\f4f2"}.fa-creative-commons-zero:before{content:"\f4f3"}.fa-credit-card:before{content:"\f09d"}.fa-critical-role:before{content:"\f6c9"}.fa-crop:before{content:"\f125"}.fa-crop-alt:before{content:"\f565"}.fa-cross:before{content:"\f654"}.fa-crosshairs:before{content:"\f05b"}.fa-crow:before{content:"\f520"}.fa-crown:before{content:"\f521"}.fa-crutch:before{content:"\f7f7"}.fa-css3:before{content:"\f13c"}.fa-css3-alt:before{content:"\f38b"}.fa-cube:before{content:"\f1b2"}.fa-cubes:before{content:"\f1b3"}.fa-cut:before{content:"\f0c4"}.fa-cuttlefish:before{content:"\f38c"}.fa-d-and-d:before{content:"\f38d"}.fa-d-and-d-beyond:before{content:"\f6ca"}.fa-dailymotion:before{content:"\e052"}.fa-dashcube:before{content:"\f210"}.fa-database:before{content:"\f1c0"}.fa-deaf:before{content:"\f2a4"}.fa-deezer:before{content:"\e077"}.fa-delicious:before{content:"\f1a5"}.fa-democrat:before{content:"\f747"}.fa-deploydog:before{content:"\f38e"}.fa-deskpro:before{content:"\f38f"}.fa-desktop:before{content:"\f108"}.fa-dev:before{content:"\f6cc"}.fa-deviantart:before{content:"\f1bd"}.fa-dharmachakra:before{content:"\f655"}.fa-dhl:before{content:"\f790"}.fa-diagnoses:before{content:"\f470"}.fa-diaspora:before{content:"\f791"}.fa-dice:before{content:"\f522"}.fa-dice-d20:before{content:"\f6cf"}.fa-dice-d6:before{content:"\f6d1"}.fa-dice-five:before{content:"\f523"}.fa-dice-four:before{content:"\f524"}.fa-dice-one:before{content:"\f525"}.fa-dice-six:before{content:"\f526"}.fa-dice-three:before{content:"\f527"}.fa-dice-two:before{content:"\f528"}.fa-digg:before{content:"\f1a6"}.fa-digital-ocean:before{content:"\f391"}.fa-digital-tachograph:before{content:"\f566"}.fa-directions:before{content:"\f5eb"}.fa-discord:before{content:"\f392"}.fa-discourse:before{content:"\f393"}.fa-disease:before{content:"\f7fa"}.fa-divide:before{content:"\f529"}.fa-dizzy:before{content:"\f567"}.fa-dna:before{content:"\f471"}.fa-dochub:before{content:"\f394"}.fa-docker:before{content:"\f395"}.fa-dog:before{content:"\f6d3"}.fa-dollar-sign:before{content:"\f155"}.fa-dolly:before{content:"\f472"}.fa-dolly-flatbed:before{content:"\f474"}.fa-donate:before{content:"\f4b9"}.fa-door-closed:before{content:"\f52a"}.fa-door-open:before{content:"\f52b"}.fa-dot-circle:before{content:"\f192"}.fa-dove:before{content:"\f4ba"}.fa-download:before{content:"\f019"}.fa-draft2digital:before{content:"\f396"}.fa-drafting-compass:before{content:"\f568"}.fa-dragon:before{content:"\f6d5"}.fa-draw-polygon:before{content:"\f5ee"}.fa-dribbble:before{content:"\f17d"}.fa-dribbble-square:before{content:"\f397"}.fa-dropbox:before{content:"\f16b"}.fa-drum:before{content:"\f569"}.fa-drum-steelpan:before{content:"\f56a"}.fa-drumstick-bite:before{content:"\f6d7"}.fa-drupal:before{content:"\f1a9"}.fa-dumbbell:before{content:"\f44b"}.fa-dumpster:before{content:"\f793"}.fa-dumpster-fire:before{content:"\f794"}.fa-dungeon:before{content:"\f6d9"}.fa-dyalog:before{content:"\f399"}.fa-earlybirds:before{content:"\f39a"}.fa-ebay:before{content:"\f4f4"}.fa-edge:before{content:"\f282"}.fa-edge-legacy:before{content:"\e078"}.fa-edit:before{content:"\f044"}.fa-egg:before{content:"\f7fb"}.fa-eject:before{content:"\f052"}.fa-elementor:before{content:"\f430"}.fa-ellipsis-h:before{content:"\f141"}.fa-ellipsis-v:before{content:"\f142"}.fa-ello:before{content:"\f5f1"}.fa-ember:before{content:"\f423"}.fa-empire:before{content:"\f1d1"}.fa-envelope:before{content:"\f0e0"}.fa-envelope-open:before{content:"\f2b6"}.fa-envelope-open-text:before{content:"\f658"}.fa-envelope-square:before{content:"\f199"}.fa-envira:before{content:"\f299"}.fa-equals:before{content:"\f52c"}.fa-eraser:before{content:"\f12d"}.fa-erlang:before{content:"\f39d"}.fa-ethereum:before{content:"\f42e"}.fa-ethernet:before{content:"\f796"}.fa-etsy:before{content:"\f2d7"}.fa-euro-sign:before{content:"\f153"}.fa-evernote:before{content:"\f839"}.fa-exchange-alt:before{content:"\f362"}.fa-exclamation:before{content:"\f12a"}.fa-exclamation-circle:before{content:"\f06a"}.fa-exclamation-triangle:before{content:"\f071"}.fa-expand:before{content:"\f065"}.fa-expand-alt:before{content:"\f424"}.fa-expand-arrows-alt:before{content:"\f31e"}.fa-expeditedssl:before{content:"\f23e"}.fa-external-link-alt:before{content:"\f35d"}.fa-external-link-square-alt:before{content:"\f360"}.fa-eye:before{content:"\f06e"}.fa-eye-dropper:before{content:"\f1fb"}.fa-eye-slash:before{content:"\f070"}.fa-facebook:before{content:"\f09a"}.fa-facebook-f:before{content:"\f39e"}.fa-facebook-messenger:before{content:"\f39f"}.fa-facebook-square:before{content:"\f082"}.fa-fan:before{content:"\f863"}.fa-fantasy-flight-games:before{content:"\f6dc"}.fa-fast-backward:before{content:"\f049"}.fa-fast-forward:before{content:"\f050"}.fa-faucet:before{content:"\e005"}.fa-fax:before{content:"\f1ac"}.fa-feather:before{content:"\f52d"}.fa-feather-alt:before{content:"\f56b"}.fa-fedex:before{content:"\f797"}.fa-fedora:before{content:"\f798"}.fa-female:before{content:"\f182"}.fa-fighter-jet:before{content:"\f0fb"}.fa-figma:before{content:"\f799"}.fa-file:before{content:"\f15b"}.fa-file-alt:before{content:"\f15c"}.fa-file-archive:before{content:"\f1c6"}.fa-file-audio:before{content:"\f1c7"}.fa-file-code:before{content:"\f1c9"}.fa-file-contract:before{content:"\f56c"}.fa-file-csv:before{content:"\f6dd"}.fa-file-download:before{content:"\f56d"}.fa-file-excel:before{content:"\f1c3"}.fa-file-export:before{content:"\f56e"}.fa-file-image:before{content:"\f1c5"}.fa-file-import:before{content:"\f56f"}.fa-file-invoice:before{content:"\f570"}.fa-file-invoice-dollar:before{content:"\f571"}.fa-file-medical:before{content:"\f477"}.fa-file-medical-alt:before{content:"\f478"}.fa-file-pdf:before{content:"\f1c1"}.fa-file-powerpoint:before{content:"\f1c4"}.fa-file-prescription:before{content:"\f572"}.fa-file-signature:before{content:"\f573"}.fa-file-upload:before{content:"\f574"}.fa-file-video:before{content:"\f1c8"}.fa-file-word:before{content:"\f1c2"}.fa-fill:before{content:"\f575"}.fa-fill-drip:before{content:"\f576"}.fa-film:before{content:"\f008"}.fa-filter:before{content:"\f0b0"}.fa-fingerprint:before{content:"\f577"}.fa-fire:before{content:"\f06d"}.fa-fire-alt:before{content:"\f7e4"}.fa-fire-extinguisher:before{content:"\f134"}.fa-firefox:before{content:"\f269"}.fa-firefox-browser:before{content:"\e007"}.fa-first-aid:before{content:"\f479"}.fa-first-order:before{content:"\f2b0"}.fa-first-order-alt:before{content:"\f50a"}.fa-firstdraft:before{content:"\f3a1"}.fa-fish:before{content:"\f578"}.fa-fist-raised:before{content:"\f6de"}.fa-flag:before{content:"\f024"}.fa-flag-checkered:before{content:"\f11e"}.fa-flag-usa:before{content:"\f74d"}.fa-flask:before{content:"\f0c3"}.fa-flickr:before{content:"\f16e"}.fa-flipboard:before{content:"\f44d"}.fa-flushed:before{content:"\f579"}.fa-fly:before{content:"\f417"}.fa-folder:before{content:"\f07b"}.fa-folder-minus:before{content:"\f65d"}.fa-folder-open:before{content:"\f07c"}.fa-folder-plus:before{content:"\f65e"}.fa-font:before{content:"\f031"}.fa-font-awesome:before{content:"\f2b4"}.fa-font-awesome-alt:before{content:"\f35c"}.fa-font-awesome-flag:before{content:"\f425"}.fa-font-awesome-logo-full:before{content:"\f4e6"}.fa-fonticons:before{content:"\f280"}.fa-fonticons-fi:before{content:"\f3a2"}.fa-football-ball:before{content:"\f44e"}.fa-fort-awesome:before{content:"\f286"}.fa-fort-awesome-alt:before{content:"\f3a3"}.fa-forumbee:before{content:"\f211"}.fa-forward:before{content:"\f04e"}.fa-foursquare:before{content:"\f180"}.fa-free-code-camp:before{content:"\f2c5"}.fa-freebsd:before{content:"\f3a4"}.fa-frog:before{content:"\f52e"}.fa-frown:before{content:"\f119"}.fa-frown-open:before{content:"\f57a"}.fa-fulcrum:before{content:"\f50b"}.fa-funnel-dollar:before{content:"\f662"}.fa-futbol:before{content:"\f1e3"}.fa-galactic-republic:before{content:"\f50c"}.fa-galactic-senate:before{content:"\f50d"}.fa-gamepad:before{content:"\f11b"}.fa-gas-pump:before{content:"\f52f"}.fa-gavel:before{content:"\f0e3"}.fa-gem:before{content:"\f3a5"}.fa-genderless:before{content:"\f22d"}.fa-get-pocket:before{content:"\f265"}.fa-gg:before{content:"\f260"}.fa-gg-circle:before{content:"\f261"}.fa-ghost:before{content:"\f6e2"}.fa-gift:before{content:"\f06b"}.fa-gifts:before{content:"\f79c"}.fa-git:before{content:"\f1d3"}.fa-git-alt:before{content:"\f841"}.fa-git-square:before{content:"\f1d2"}.fa-github:before{content:"\f09b"}.fa-github-alt:before{content:"\f113"}.fa-github-square:before{content:"\f092"}.fa-gitkraken:before{content:"\f3a6"}.fa-gitlab:before{content:"\f296"}.fa-gitter:before{content:"\f426"}.fa-glass-cheers:before{content:"\f79f"}.fa-glass-martini:before{content:"\f000"}.fa-glass-martini-alt:before{content:"\f57b"}.fa-glass-whiskey:before{content:"\f7a0"}.fa-glasses:before{content:"\f530"}.fa-glide:before{content:"\f2a5"}.fa-glide-g:before{content:"\f2a6"}.fa-globe:before{content:"\f0ac"}.fa-globe-africa:before{content:"\f57c"}.fa-globe-americas:before{content:"\f57d"}.fa-globe-asia:before{content:"\f57e"}.fa-globe-europe:before{content:"\f7a2"}.fa-gofore:before{content:"\f3a7"}.fa-golf-ball:before{content:"\f450"}.fa-goodreads:before{content:"\f3a8"}.fa-goodreads-g:before{content:"\f3a9"}.fa-google:before{content:"\f1a0"}.fa-google-drive:before{content:"\f3aa"}.fa-google-pay:before{content:"\e079"}.fa-google-play:before{content:"\f3ab"}.fa-google-plus:before{content:"\f2b3"}.fa-google-plus-g:before{content:"\f0d5"}.fa-google-plus-square:before{content:"\f0d4"}.fa-google-wallet:before{content:"\f1ee"}.fa-gopuram:before{content:"\f664"}.fa-graduation-cap:before{content:"\f19d"}.fa-gratipay:before{content:"\f184"}.fa-grav:before{content:"\f2d6"}.fa-greater-than:before{content:"\f531"}.fa-greater-than-equal:before{content:"\f532"}.fa-grimace:before{content:"\f57f"}.fa-grin:before{content:"\f580"}.fa-grin-alt:before{content:"\f581"}.fa-grin-beam:before{content:"\f582"}.fa-grin-beam-sweat:before{content:"\f583"}.fa-grin-hearts:before{content:"\f584"}.fa-grin-squint:before{content:"\f585"}.fa-grin-squint-tears:before{content:"\f586"}.fa-grin-stars:before{content:"\f587"}.fa-grin-tears:before{content:"\f588"}.fa-grin-tongue:before{content:"\f589"}.fa-grin-tongue-squint:before{content:"\f58a"}.fa-grin-tongue-wink:before{content:"\f58b"}.fa-grin-wink:before{content:"\f58c"}.fa-grip-horizontal:before{content:"\f58d"}.fa-grip-lines:before{content:"\f7a4"}.fa-grip-lines-vertical:before{content:"\f7a5"}.fa-grip-vertical:before{content:"\f58e"}.fa-gripfire:before{content:"\f3ac"}.fa-grunt:before{content:"\f3ad"}.fa-guilded:before{content:"\e07e"}.fa-guitar:before{content:"\f7a6"}.fa-gulp:before{content:"\f3ae"}.fa-h-square:before{content:"\f0fd"}.fa-hacker-news:before{content:"\f1d4"}.fa-hacker-news-square:before{content:"\f3af"}.fa-hackerrank:before{content:"\f5f7"}.fa-hamburger:before{content:"\f805"}.fa-hammer:before{content:"\f6e3"}.fa-hamsa:before{content:"\f665"}.fa-hand-holding:before{content:"\f4bd"}.fa-hand-holding-heart:before{content:"\f4be"}.fa-hand-holding-medical:before{content:"\e05c"}.fa-hand-holding-usd:before{content:"\f4c0"}.fa-hand-holding-water:before{content:"\f4c1"}.fa-hand-lizard:before{content:"\f258"}.fa-hand-middle-finger:before{content:"\f806"}.fa-hand-paper:before{content:"\f256"}.fa-hand-peace:before{content:"\f25b"}.fa-hand-point-down:before{content:"\f0a7"}.fa-hand-point-left:before{content:"\f0a5"}.fa-hand-point-right:before{content:"\f0a4"}.fa-hand-point-up:before{content:"\f0a6"}.fa-hand-pointer:before{content:"\f25a"}.fa-hand-rock:before{content:"\f255"}.fa-hand-scissors:before{content:"\f257"}.fa-hand-sparkles:before{content:"\e05d"}.fa-hand-spock:before{content:"\f259"}.fa-hands:before{content:"\f4c2"}.fa-hands-helping:before{content:"\f4c4"}.fa-hands-wash:before{content:"\e05e"}.fa-handshake:before{content:"\f2b5"}.fa-handshake-alt-slash:before{content:"\e05f"}.fa-handshake-slash:before{content:"\e060"}.fa-hanukiah:before{content:"\f6e6"}.fa-hard-hat:before{content:"\f807"}.fa-hashtag:before{content:"\f292"}.fa-hat-cowboy:before{content:"\f8c0"}.fa-hat-cowboy-side:before{content:"\f8c1"}.fa-hat-wizard:before{content:"\f6e8"}.fa-hdd:before{content:"\f0a0"}.fa-head-side-cough:before{content:"\e061"}.fa-head-side-cough-slash:before{content:"\e062"}.fa-head-side-mask:before{content:"\e063"}.fa-head-side-virus:before{content:"\e064"}.fa-heading:before{content:"\f1dc"}.fa-headphones:before{content:"\f025"}.fa-headphones-alt:before{content:"\f58f"}.fa-headset:before{content:"\f590"}.fa-heart:before{content:"\f004"}.fa-heart-broken:before{content:"\f7a9"}.fa-heartbeat:before{content:"\f21e"}.fa-helicopter:before{content:"\f533"}.fa-highlighter:before{content:"\f591"}.fa-hiking:before{content:"\f6ec"}.fa-hippo:before{content:"\f6ed"}.fa-hips:before{content:"\f452"}.fa-hire-a-helper:before{content:"\f3b0"}.fa-history:before{content:"\f1da"}.fa-hive:before{content:"\e07f"}.fa-hockey-puck:before{content:"\f453"}.fa-holly-berry:before{content:"\f7aa"}.fa-home:before{content:"\f015"}.fa-hooli:before{content:"\f427"}.fa-hornbill:before{content:"\f592"}.fa-horse:before{content:"\f6f0"}.fa-horse-head:before{content:"\f7ab"}.fa-hospital:before{content:"\f0f8"}.fa-hospital-alt:before{content:"\f47d"}.fa-hospital-symbol:before{content:"\f47e"}.fa-hospital-user:before{content:"\f80d"}.fa-hot-tub:before{content:"\f593"}.fa-hotdog:before{content:"\f80f"}.fa-hotel:before{content:"\f594"}.fa-hotjar:before{content:"\f3b1"}.fa-hourglass:before{content:"\f254"}.fa-hourglass-end:before{content:"\f253"}.fa-hourglass-half:before{content:"\f252"}.fa-hourglass-start:before{content:"\f251"}.fa-house-damage:before{content:"\f6f1"}.fa-house-user:before{content:"\e065"}.fa-houzz:before{content:"\f27c"}.fa-hryvnia:before{content:"\f6f2"}.fa-html5:before{content:"\f13b"}.fa-hubspot:before{content:"\f3b2"}.fa-i-cursor:before{content:"\f246"}.fa-ice-cream:before{content:"\f810"}.fa-icicles:before{content:"\f7ad"}.fa-icons:before{content:"\f86d"}.fa-id-badge:before{content:"\f2c1"}.fa-id-card:before{content:"\f2c2"}.fa-id-card-alt:before{content:"\f47f"}.fa-ideal:before{content:"\e013"}.fa-igloo:before{content:"\f7ae"}.fa-image:before{content:"\f03e"}.fa-images:before{content:"\f302"}.fa-imdb:before{content:"\f2d8"}.fa-inbox:before{content:"\f01c"}.fa-indent:before{content:"\f03c"}.fa-industry:before{content:"\f275"}.fa-infinity:before{content:"\f534"}.fa-info:before{content:"\f129"}.fa-info-circle:before{content:"\f05a"}.fa-innosoft:before{content:"\e080"}.fa-instagram:before{content:"\f16d"}.fa-instagram-square:before{content:"\e055"}.fa-instalod:before{content:"\e081"}.fa-intercom:before{content:"\f7af"}.fa-internet-explorer:before{content:"\f26b"}.fa-invision:before{content:"\f7b0"}.fa-ioxhost:before{content:"\f208"}.fa-italic:before{content:"\f033"}.fa-itch-io:before{content:"\f83a"}.fa-itunes:before{content:"\f3b4"}.fa-itunes-note:before{content:"\f3b5"}.fa-java:before{content:"\f4e4"}.fa-jedi:before{content:"\f669"}.fa-jedi-order:before{content:"\f50e"}.fa-jenkins:before{content:"\f3b6"}.fa-jira:before{content:"\f7b1"}.fa-joget:before{content:"\f3b7"}.fa-joint:before{content:"\f595"}.fa-joomla:before{content:"\f1aa"}.fa-journal-whills:before{content:"\f66a"}.fa-js:before{content:"\f3b8"}.fa-js-square:before{content:"\f3b9"}.fa-jsfiddle:before{content:"\f1cc"}.fa-kaaba:before{content:"\f66b"}.fa-kaggle:before{content:"\f5fa"}.fa-key:before{content:"\f084"}.fa-keybase:before{content:"\f4f5"}.fa-keyboard:before{content:"\f11c"}.fa-keycdn:before{content:"\f3ba"}.fa-khanda:before{content:"\f66d"}.fa-kickstarter:before{content:"\f3bb"}.fa-kickstarter-k:before{content:"\f3bc"}.fa-kiss:before{content:"\f596"}.fa-kiss-beam:before{content:"\f597"}.fa-kiss-wink-heart:before{content:"\f598"}.fa-kiwi-bird:before{content:"\f535"}.fa-korvue:before{content:"\f42f"}.fa-landmark:before{content:"\f66f"}.fa-language:before{content:"\f1ab"}.fa-laptop:before{content:"\f109"}.fa-laptop-code:before{content:"\f5fc"}.fa-laptop-house:before{content:"\e066"}.fa-laptop-medical:before{content:"\f812"}.fa-laravel:before{content:"\f3bd"}.fa-lastfm:before{content:"\f202"}.fa-lastfm-square:before{content:"\f203"}.fa-laugh:before{content:"\f599"}.fa-laugh-beam:before{content:"\f59a"}.fa-laugh-squint:before{content:"\f59b"}.fa-laugh-wink:before{content:"\f59c"}.fa-layer-group:before{content:"\f5fd"}.fa-leaf:before{content:"\f06c"}.fa-leanpub:before{content:"\f212"}.fa-lemon:before{content:"\f094"}.fa-less:before{content:"\f41d"}.fa-less-than:before{content:"\f536"}.fa-less-than-equal:before{content:"\f537"}.fa-level-down-alt:before{content:"\f3be"}.fa-level-up-alt:before{content:"\f3bf"}.fa-life-ring:before{content:"\f1cd"}.fa-lightbulb:before{content:"\f0eb"}.fa-line:before{content:"\f3c0"}.fa-link:before{content:"\f0c1"}.fa-linkedin:before{content:"\f08c"}.fa-linkedin-in:before{content:"\f0e1"}.fa-linode:before{content:"\f2b8"}.fa-linux:before{content:"\f17c"}.fa-lira-sign:before{content:"\f195"}.fa-list:before{content:"\f03a"}.fa-list-alt:before{content:"\f022"}.fa-list-ol:before{content:"\f0cb"}.fa-list-ul:before{content:"\f0ca"}.fa-location-arrow:before{content:"\f124"}.fa-lock:before{content:"\f023"}.fa-lock-open:before{content:"\f3c1"}.fa-long-arrow-alt-down:before{content:"\f309"}.fa-long-arrow-alt-left:before{content:"\f30a"}.fa-long-arrow-alt-right:before{content:"\f30b"}.fa-long-arrow-alt-up:before{content:"\f30c"}.fa-low-vision:before{content:"\f2a8"}.fa-luggage-cart:before{content:"\f59d"}.fa-lungs:before{content:"\f604"}.fa-lungs-virus:before{content:"\e067"}.fa-lyft:before{content:"\f3c3"}.fa-magento:before{content:"\f3c4"}.fa-magic:before{content:"\f0d0"}.fa-magnet:before{content:"\f076"}.fa-mail-bulk:before{content:"\f674"}.fa-mailchimp:before{content:"\f59e"}.fa-male:before{content:"\f183"}.fa-mandalorian:before{content:"\f50f"}.fa-map:before{content:"\f279"}.fa-map-marked:before{content:"\f59f"}.fa-map-marked-alt:before{content:"\f5a0"}.fa-map-marker:before{content:"\f041"}.fa-map-marker-alt:before{content:"\f3c5"}.fa-map-pin:before{content:"\f276"}.fa-map-signs:before{content:"\f277"}.fa-markdown:before{content:"\f60f"}.fa-marker:before{content:"\f5a1"}.fa-mars:before{content:"\f222"}.fa-mars-double:before{content:"\f227"}.fa-mars-stroke:before{content:"\f229"}.fa-mars-stroke-h:before{content:"\f22b"}.fa-mars-stroke-v:before{content:"\f22a"}.fa-mask:before{content:"\f6fa"}.fa-mastodon:before{content:"\f4f6"}.fa-maxcdn:before{content:"\f136"}.fa-mdb:before{content:"\f8ca"}.fa-medal:before{content:"\f5a2"}.fa-medapps:before{content:"\f3c6"}.fa-medium:before{content:"\f23a"}.fa-medium-m:before{content:"\f3c7"}.fa-medkit:before{content:"\f0fa"}.fa-medrt:before{content:"\f3c8"}.fa-meetup:before{content:"\f2e0"}.fa-megaport:before{content:"\f5a3"}.fa-meh:before{content:"\f11a"}.fa-meh-blank:before{content:"\f5a4"}.fa-meh-rolling-eyes:before{content:"\f5a5"}.fa-memory:before{content:"\f538"}.fa-mendeley:before{content:"\f7b3"}.fa-menorah:before{content:"\f676"}.fa-mercury:before{content:"\f223"}.fa-meteor:before{content:"\f753"}.fa-microblog:before{content:"\e01a"}.fa-microchip:before{content:"\f2db"}.fa-microphone:before{content:"\f130"}.fa-microphone-alt:before{content:"\f3c9"}.fa-microphone-alt-slash:before{content:"\f539"}.fa-microphone-slash:before{content:"\f131"}.fa-microscope:before{content:"\f610"}.fa-microsoft:before{content:"\f3ca"}.fa-minus:before{content:"\f068"}.fa-minus-circle:before{content:"\f056"}.fa-minus-square:before{content:"\f146"}.fa-mitten:before{content:"\f7b5"}.fa-mix:before{content:"\f3cb"}.fa-mixcloud:before{content:"\f289"}.fa-mixer:before{content:"\e056"}.fa-mizuni:before{content:"\f3cc"}.fa-mobile:before{content:"\f10b"}.fa-mobile-alt:before{content:"\f3cd"}.fa-modx:before{content:"\f285"}.fa-monero:before{content:"\f3d0"}.fa-money-bill:before{content:"\f0d6"}.fa-money-bill-alt:before{content:"\f3d1"}.fa-money-bill-wave:before{content:"\f53a"}.fa-money-bill-wave-alt:before{content:"\f53b"}.fa-money-check:before{content:"\f53c"}.fa-money-check-alt:before{content:"\f53d"}.fa-monument:before{content:"\f5a6"}.fa-moon:before{content:"\f186"}.fa-mortar-pestle:before{content:"\f5a7"}.fa-mosque:before{content:"\f678"}.fa-motorcycle:before{content:"\f21c"}.fa-mountain:before{content:"\f6fc"}.fa-mouse:before{content:"\f8cc"}.fa-mouse-pointer:before{content:"\f245"}.fa-mug-hot:before{content:"\f7b6"}.fa-music:before{content:"\f001"}.fa-napster:before{content:"\f3d2"}.fa-neos:before{content:"\f612"}.fa-network-wired:before{content:"\f6ff"}.fa-neuter:before{content:"\f22c"}.fa-newspaper:before{content:"\f1ea"}.fa-nimblr:before{content:"\f5a8"}.fa-node:before{content:"\f419"}.fa-node-js:before{content:"\f3d3"}.fa-not-equal:before{content:"\f53e"}.fa-notes-medical:before{content:"\f481"}.fa-npm:before{content:"\f3d4"}.fa-ns8:before{content:"\f3d5"}.fa-nutritionix:before{content:"\f3d6"}.fa-object-group:before{content:"\f247"}.fa-object-ungroup:before{content:"\f248"}.fa-octopus-deploy:before{content:"\e082"}.fa-odnoklassniki:before{content:"\f263"}.fa-odnoklassniki-square:before{content:"\f264"}.fa-oil-can:before{content:"\f613"}.fa-old-republic:before{content:"\f510"}.fa-om:before{content:"\f679"}.fa-opencart:before{content:"\f23d"}.fa-openid:before{content:"\f19b"}.fa-opera:before{content:"\f26a"}.fa-optin-monster:before{content:"\f23c"}.fa-orcid:before{content:"\f8d2"}.fa-osi:before{content:"\f41a"}.fa-otter:before{content:"\f700"}.fa-outdent:before{content:"\f03b"}.fa-page4:before{content:"\f3d7"}.fa-pagelines:before{content:"\f18c"}.fa-pager:before{content:"\f815"}.fa-paint-brush:before{content:"\f1fc"}.fa-paint-roller:before{content:"\f5aa"}.fa-palette:before{content:"\f53f"}.fa-palfed:before{content:"\f3d8"}.fa-pallet:before{content:"\f482"}.fa-paper-plane:before{content:"\f1d8"}.fa-paperclip:before{content:"\f0c6"}.fa-parachute-box:before{content:"\f4cd"}.fa-paragraph:before{content:"\f1dd"}.fa-parking:before{content:"\f540"}.fa-passport:before{content:"\f5ab"}.fa-pastafarianism:before{content:"\f67b"}.fa-paste:before{content:"\f0ea"}.fa-patreon:before{content:"\f3d9"}.fa-pause:before{content:"\f04c"}.fa-pause-circle:before{content:"\f28b"}.fa-paw:before{content:"\f1b0"}.fa-paypal:before{content:"\f1ed"}.fa-peace:before{content:"\f67c"}.fa-pen:before{content:"\f304"}.fa-pen-alt:before{content:"\f305"}.fa-pen-fancy:before{content:"\f5ac"}.fa-pen-nib:before{content:"\f5ad"}.fa-pen-square:before{content:"\f14b"}.fa-pencil-alt:before{content:"\f303"}.fa-pencil-ruler:before{content:"\f5ae"}.fa-penny-arcade:before{content:"\f704"}.fa-people-arrows:before{content:"\e068"}.fa-people-carry:before{content:"\f4ce"}.fa-pepper-hot:before{content:"\f816"}.fa-perbyte:before{content:"\e083"}.fa-percent:before{content:"\f295"}.fa-percentage:before{content:"\f541"}.fa-periscope:before{content:"\f3da"}.fa-person-booth:before{content:"\f756"}.fa-phabricator:before{content:"\f3db"}.fa-phoenix-framework:before{content:"\f3dc"}.fa-phoenix-squadron:before{content:"\f511"}.fa-phone:before{content:"\f095"}.fa-phone-alt:before{content:"\f879"}.fa-phone-slash:before{content:"\f3dd"}.fa-phone-square:before{content:"\f098"}.fa-phone-square-alt:before{content:"\f87b"}.fa-phone-volume:before{content:"\f2a0"}.fa-photo-video:before{content:"\f87c"}.fa-php:before{content:"\f457"}.fa-pied-piper:before{content:"\f2ae"}.fa-pied-piper-alt:before{content:"\f1a8"}.fa-pied-piper-hat:before{content:"\f4e5"}.fa-pied-piper-pp:before{content:"\f1a7"}.fa-pied-piper-square:before{content:"\e01e"}.fa-piggy-bank:before{content:"\f4d3"}.fa-pills:before{content:"\f484"}.fa-pinterest:before{content:"\f0d2"}.fa-pinterest-p:before{content:"\f231"}.fa-pinterest-square:before{content:"\f0d3"}.fa-pizza-slice:before{content:"\f818"}.fa-place-of-worship:before{content:"\f67f"}.fa-plane:before{content:"\f072"}.fa-plane-arrival:before{content:"\f5af"}.fa-plane-departure:before{content:"\f5b0"}.fa-plane-slash:before{content:"\e069"}.fa-play:before{content:"\f04b"}.fa-play-circle:before{content:"\f144"}.fa-playstation:before{content:"\f3df"}.fa-plug:before{content:"\f1e6"}.fa-plus:before{content:"\f067"}.fa-plus-circle:before{content:"\f055"}.fa-plus-square:before{content:"\f0fe"}.fa-podcast:before{content:"\f2ce"}.fa-poll:before{content:"\f681"}.fa-poll-h:before{content:"\f682"}.fa-poo:before{content:"\f2fe"}.fa-poo-storm:before{content:"\f75a"}.fa-poop:before{content:"\f619"}.fa-portrait:before{content:"\f3e0"}.fa-pound-sign:before{content:"\f154"}.fa-power-off:before{content:"\f011"}.fa-pray:before{content:"\f683"}.fa-praying-hands:before{content:"\f684"}.fa-prescription:before{content:"\f5b1"}.fa-prescription-bottle:before{content:"\f485"}.fa-prescription-bottle-alt:before{content:"\f486"}.fa-print:before{content:"\f02f"}.fa-procedures:before{content:"\f487"}.fa-product-hunt:before{content:"\f288"}.fa-project-diagram:before{content:"\f542"}.fa-pump-medical:before{content:"\e06a"}.fa-pump-soap:before{content:"\e06b"}.fa-pushed:before{content:"\f3e1"}.fa-puzzle-piece:before{content:"\f12e"}.fa-python:before{content:"\f3e2"}.fa-qq:before{content:"\f1d6"}.fa-qrcode:before{content:"\f029"}.fa-question:before{content:"\f128"}.fa-question-circle:before{content:"\f059"}.fa-quidditch:before{content:"\f458"}.fa-quinscape:before{content:"\f459"}.fa-quora:before{content:"\f2c4"}.fa-quote-left:before{content:"\f10d"}.fa-quote-right:before{content:"\f10e"}.fa-quran:before{content:"\f687"}.fa-r-project:before{content:"\f4f7"}.fa-radiation:before{content:"\f7b9"}.fa-radiation-alt:before{content:"\f7ba"}.fa-rainbow:before{content:"\f75b"}.fa-random:before{content:"\f074"}.fa-raspberry-pi:before{content:"\f7bb"}.fa-ravelry:before{content:"\f2d9"}.fa-react:before{content:"\f41b"}.fa-reacteurope:before{content:"\f75d"}.fa-readme:before{content:"\f4d5"}.fa-rebel:before{content:"\f1d0"}.fa-receipt:before{content:"\f543"}.fa-record-vinyl:before{content:"\f8d9"}.fa-recycle:before{content:"\f1b8"}.fa-red-river:before{content:"\f3e3"}.fa-reddit:before{content:"\f1a1"}.fa-reddit-alien:before{content:"\f281"}.fa-reddit-square:before{content:"\f1a2"}.fa-redhat:before{content:"\f7bc"}.fa-redo:before{content:"\f01e"}.fa-redo-alt:before{content:"\f2f9"}.fa-registered:before{content:"\f25d"}.fa-remove-format:before{content:"\f87d"}.fa-renren:before{content:"\f18b"}.fa-reply:before{content:"\f3e5"}.fa-reply-all:before{content:"\f122"}.fa-replyd:before{content:"\f3e6"}.fa-republican:before{content:"\f75e"}.fa-researchgate:before{content:"\f4f8"}.fa-resolving:before{content:"\f3e7"}.fa-restroom:before{content:"\f7bd"}.fa-retweet:before{content:"\f079"}.fa-rev:before{content:"\f5b2"}.fa-ribbon:before{content:"\f4d6"}.fa-ring:before{content:"\f70b"}.fa-road:before{content:"\f018"}.fa-robot:before{content:"\f544"}.fa-rocket:before{content:"\f135"}.fa-rocketchat:before{content:"\f3e8"}.fa-rockrms:before{content:"\f3e9"}.fa-route:before{content:"\f4d7"}.fa-rss:before{content:"\f09e"}.fa-rss-square:before{content:"\f143"}.fa-ruble-sign:before{content:"\f158"}.fa-ruler:before{content:"\f545"}.fa-ruler-combined:before{content:"\f546"}.fa-ruler-horizontal:before{content:"\f547"}.fa-ruler-vertical:before{content:"\f548"}.fa-running:before{content:"\f70c"}.fa-rupee-sign:before{content:"\f156"}.fa-rust:before{content:"\e07a"}.fa-sad-cry:before{content:"\f5b3"}.fa-sad-tear:before{content:"\f5b4"}.fa-safari:before{content:"\f267"}.fa-salesforce:before{content:"\f83b"}.fa-sass:before{content:"\f41e"}.fa-satellite:before{content:"\f7bf"}.fa-satellite-dish:before{content:"\f7c0"}.fa-save:before{content:"\f0c7"}.fa-schlix:before{content:"\f3ea"}.fa-school:before{content:"\f549"}.fa-screwdriver:before{content:"\f54a"}.fa-scribd:before{content:"\f28a"}.fa-scroll:before{content:"\f70e"}.fa-sd-card:before{content:"\f7c2"}.fa-search:before{content:"\f002"}.fa-search-dollar:before{content:"\f688"}.fa-search-location:before{content:"\f689"}.fa-search-minus:before{content:"\f010"}.fa-search-plus:before{content:"\f00e"}.fa-searchengin:before{content:"\f3eb"}.fa-seedling:before{content:"\f4d8"}.fa-sellcast:before{content:"\f2da"}.fa-sellsy:before{content:"\f213"}.fa-server:before{content:"\f233"}.fa-servicestack:before{content:"\f3ec"}.fa-shapes:before{content:"\f61f"}.fa-share:before{content:"\f064"}.fa-share-alt:before{content:"\f1e0"}.fa-share-alt-square:before{content:"\f1e1"}.fa-share-square:before{content:"\f14d"}.fa-shekel-sign:before{content:"\f20b"}.fa-shield-alt:before{content:"\f3ed"}.fa-shield-virus:before{content:"\e06c"}.fa-ship:before{content:"\f21a"}.fa-shipping-fast:before{content:"\f48b"}.fa-shirtsinbulk:before{content:"\f214"}.fa-shoe-prints:before{content:"\f54b"}.fa-shopify:before{content:"\e057"}.fa-shopping-bag:before{content:"\f290"}.fa-shopping-basket:before{content:"\f291"}.fa-shopping-cart:before{content:"\f07a"}.fa-shopware:before{content:"\f5b5"}.fa-shower:before{content:"\f2cc"}.fa-shuttle-van:before{content:"\f5b6"}.fa-sign:before{content:"\f4d9"}.fa-sign-in-alt:before{content:"\f2f6"}.fa-sign-language:before{content:"\f2a7"}.fa-sign-out-alt:before{content:"\f2f5"}.fa-signal:before{content:"\f012"}.fa-signature:before{content:"\f5b7"}.fa-sim-card:before{content:"\f7c4"}.fa-simplybuilt:before{content:"\f215"}.fa-sink:before{content:"\e06d"}.fa-sistrix:before{content:"\f3ee"}.fa-sitemap:before{content:"\f0e8"}.fa-sith:before{content:"\f512"}.fa-skating:before{content:"\f7c5"}.fa-sketch:before{content:"\f7c6"}.fa-skiing:before{content:"\f7c9"}.fa-skiing-nordic:before{content:"\f7ca"}.fa-skull:before{content:"\f54c"}.fa-skull-crossbones:before{content:"\f714"}.fa-skyatlas:before{content:"\f216"}.fa-skype:before{content:"\f17e"}.fa-slack:before{content:"\f198"}.fa-slack-hash:before{content:"\f3ef"}.fa-slash:before{content:"\f715"}.fa-sleigh:before{content:"\f7cc"}.fa-sliders-h:before{content:"\f1de"}.fa-slideshare:before{content:"\f1e7"}.fa-smile:before{content:"\f118"}.fa-smile-beam:before{content:"\f5b8"}.fa-smile-wink:before{content:"\f4da"}.fa-smog:before{content:"\f75f"}.fa-smoking:before{content:"\f48d"}.fa-smoking-ban:before{content:"\f54d"}.fa-sms:before{content:"\f7cd"}.fa-snapchat:before{content:"\f2ab"}.fa-snapchat-ghost:before{content:"\f2ac"}.fa-snapchat-square:before{content:"\f2ad"}.fa-snowboarding:before{content:"\f7ce"}.fa-snowflake:before{content:"\f2dc"}.fa-snowman:before{content:"\f7d0"}.fa-snowplow:before{content:"\f7d2"}.fa-soap:before{content:"\e06e"}.fa-socks:before{content:"\f696"}.fa-solar-panel:before{content:"\f5ba"}.fa-sort:before{content:"\f0dc"}.fa-sort-alpha-down:before{content:"\f15d"}.fa-sort-alpha-down-alt:before{content:"\f881"}.fa-sort-alpha-up:before{content:"\f15e"}.fa-sort-alpha-up-alt:before{content:"\f882"}.fa-sort-amount-down:before{content:"\f160"}.fa-sort-amount-down-alt:before{content:"\f884"}.fa-sort-amount-up:before{content:"\f161"}.fa-sort-amount-up-alt:before{content:"\f885"}.fa-sort-down:before{content:"\f0dd"}.fa-sort-numeric-down:before{content:"\f162"}.fa-sort-numeric-down-alt:before{content:"\f886"}.fa-sort-numeric-up:before{content:"\f163"}.fa-sort-numeric-up-alt:before{content:"\f887"}.fa-sort-up:before{content:"\f0de"}.fa-soundcloud:before{content:"\f1be"}.fa-sourcetree:before{content:"\f7d3"}.fa-spa:before{content:"\f5bb"}.fa-space-shuttle:before{content:"\f197"}.fa-speakap:before{content:"\f3f3"}.fa-speaker-deck:before{content:"\f83c"}.fa-spell-check:before{content:"\f891"}.fa-spider:before{content:"\f717"}.fa-spinner:before{content:"\f110"}.fa-splotch:before{content:"\f5bc"}.fa-spotify:before{content:"\f1bc"}.fa-spray-can:before{content:"\f5bd"}.fa-square:before{content:"\f0c8"}.fa-square-full:before{content:"\f45c"}.fa-square-root-alt:before{content:"\f698"}.fa-squarespace:before{content:"\f5be"}.fa-stack-exchange:before{content:"\f18d"}.fa-stack-overflow:before{content:"\f16c"}.fa-stackpath:before{content:"\f842"}.fa-stamp:before{content:"\f5bf"}.fa-star:before{content:"\f005"}.fa-star-and-crescent:before{content:"\f699"}.fa-star-half:before{content:"\f089"}.fa-star-half-alt:before{content:"\f5c0"}.fa-star-of-david:before{content:"\f69a"}.fa-star-of-life:before{content:"\f621"}.fa-staylinked:before{content:"\f3f5"}.fa-steam:before{content:"\f1b6"}.fa-steam-square:before{content:"\f1b7"}.fa-steam-symbol:before{content:"\f3f6"}.fa-step-backward:before{content:"\f048"}.fa-step-forward:before{content:"\f051"}.fa-stethoscope:before{content:"\f0f1"}.fa-sticker-mule:before{content:"\f3f7"}.fa-sticky-note:before{content:"\f249"}.fa-stop:before{content:"\f04d"}.fa-stop-circle:before{content:"\f28d"}.fa-stopwatch:before{content:"\f2f2"}.fa-stopwatch-20:before{content:"\e06f"}.fa-store:before{content:"\f54e"}.fa-store-alt:before{content:"\f54f"}.fa-store-alt-slash:before{content:"\e070"}.fa-store-slash:before{content:"\e071"}.fa-strava:before{content:"\f428"}.fa-stream:before{content:"\f550"}.fa-street-view:before{content:"\f21d"}.fa-strikethrough:before{content:"\f0cc"}.fa-stripe:before{content:"\f429"}.fa-stripe-s:before{content:"\f42a"}.fa-stroopwafel:before{content:"\f551"}.fa-studiovinari:before{content:"\f3f8"}.fa-stumbleupon:before{content:"\f1a4"}.fa-stumbleupon-circle:before{content:"\f1a3"}.fa-subscript:before{content:"\f12c"}.fa-subway:before{content:"\f239"}.fa-suitcase:before{content:"\f0f2"}.fa-suitcase-rolling:before{content:"\f5c1"}.fa-sun:before{content:"\f185"}.fa-superpowers:before{content:"\f2dd"}.fa-superscript:before{content:"\f12b"}.fa-supple:before{content:"\f3f9"}.fa-surprise:before{content:"\f5c2"}.fa-suse:before{content:"\f7d6"}.fa-swatchbook:before{content:"\f5c3"}.fa-swift:before{content:"\f8e1"}.fa-swimmer:before{content:"\f5c4"}.fa-swimming-pool:before{content:"\f5c5"}.fa-symfony:before{content:"\f83d"}.fa-synagogue:before{content:"\f69b"}.fa-sync:before{content:"\f021"}.fa-sync-alt:before{content:"\f2f1"}.fa-syringe:before{content:"\f48e"}.fa-table:before{content:"\f0ce"}.fa-table-tennis:before{content:"\f45d"}.fa-tablet:before{content:"\f10a"}.fa-tablet-alt:before{content:"\f3fa"}.fa-tablets:before{content:"\f490"}.fa-tachometer-alt:before{content:"\f3fd"}.fa-tag:before{content:"\f02b"}.fa-tags:before{content:"\f02c"}.fa-tape:before{content:"\f4db"}.fa-tasks:before{content:"\f0ae"}.fa-taxi:before{content:"\f1ba"}.fa-teamspeak:before{content:"\f4f9"}.fa-teeth:before{content:"\f62e"}.fa-teeth-open:before{content:"\f62f"}.fa-telegram:before{content:"\f2c6"}.fa-telegram-plane:before{content:"\f3fe"}.fa-temperature-high:before{content:"\f769"}.fa-temperature-low:before{content:"\f76b"}.fa-tencent-weibo:before{content:"\f1d5"}.fa-tenge:before{content:"\f7d7"}.fa-terminal:before{content:"\f120"}.fa-text-height:before{content:"\f034"}.fa-text-width:before{content:"\f035"}.fa-th:before{content:"\f00a"}.fa-th-large:before{content:"\f009"}.fa-th-list:before{content:"\f00b"}.fa-the-red-yeti:before{content:"\f69d"}.fa-theater-masks:before{content:"\f630"}.fa-themeco:before{content:"\f5c6"}.fa-themeisle:before{content:"\f2b2"}.fa-thermometer:before{content:"\f491"}.fa-thermometer-empty:before{content:"\f2cb"}.fa-thermometer-full:before{content:"\f2c7"}.fa-thermometer-half:before{content:"\f2c9"}.fa-thermometer-quarter:before{content:"\f2ca"}.fa-thermometer-three-quarters:before{content:"\f2c8"}.fa-think-peaks:before{content:"\f731"}.fa-thumbs-down:before{content:"\f165"}.fa-thumbs-up:before{content:"\f164"}.fa-thumbtack:before{content:"\f08d"}.fa-ticket-alt:before{content:"\f3ff"}.fa-tiktok:before{content:"\e07b"}.fa-times:before{content:"\f00d"}.fa-times-circle:before{content:"\f057"}.fa-tint:before{content:"\f043"}.fa-tint-slash:before{content:"\f5c7"}.fa-tired:before{content:"\f5c8"}.fa-toggle-off:before{content:"\f204"}.fa-toggle-on:before{content:"\f205"}.fa-toilet:before{content:"\f7d8"}.fa-toilet-paper:before{content:"\f71e"}.fa-toilet-paper-slash:before{content:"\e072"}.fa-toolbox:before{content:"\f552"}.fa-tools:before{content:"\f7d9"}.fa-tooth:before{content:"\f5c9"}.fa-torah:before{content:"\f6a0"}.fa-torii-gate:before{content:"\f6a1"}.fa-tractor:before{content:"\f722"}.fa-trade-federation:before{content:"\f513"}.fa-trademark:before{content:"\f25c"}.fa-traffic-light:before{content:"\f637"}.fa-trailer:before{content:"\e041"}.fa-train:before{content:"\f238"}.fa-tram:before{content:"\f7da"}.fa-transgender:before{content:"\f224"}.fa-transgender-alt:before{content:"\f225"}.fa-trash:before{content:"\f1f8"}.fa-trash-alt:before{content:"\f2ed"}.fa-trash-restore:before{content:"\f829"}.fa-trash-restore-alt:before{content:"\f82a"}.fa-tree:before{content:"\f1bb"}.fa-trello:before{content:"\f181"}.fa-trophy:before{content:"\f091"}.fa-truck:before{content:"\f0d1"}.fa-truck-loading:before{content:"\f4de"}.fa-truck-monster:before{content:"\f63b"}.fa-truck-moving:before{content:"\f4df"}.fa-truck-pickup:before{content:"\f63c"}.fa-tshirt:before{content:"\f553"}.fa-tty:before{content:"\f1e4"}.fa-tumblr:before{content:"\f173"}.fa-tumblr-square:before{content:"\f174"}.fa-tv:before{content:"\f26c"}.fa-twitch:before{content:"\f1e8"}.fa-twitter:before{content:"\f099"}.fa-twitter-square:before{content:"\f081"}.fa-typo3:before{content:"\f42b"}.fa-uber:before{content:"\f402"}.fa-ubuntu:before{content:"\f7df"}.fa-uikit:before{content:"\f403"}.fa-umbraco:before{content:"\f8e8"}.fa-umbrella:before{content:"\f0e9"}.fa-umbrella-beach:before{content:"\f5ca"}.fa-uncharted:before{content:"\e084"}.fa-underline:before{content:"\f0cd"}.fa-undo:before{content:"\f0e2"}.fa-undo-alt:before{content:"\f2ea"}.fa-uniregistry:before{content:"\f404"}.fa-unity:before{content:"\e049"}.fa-universal-access:before{content:"\f29a"}.fa-university:before{content:"\f19c"}.fa-unlink:before{content:"\f127"}.fa-unlock:before{content:"\f09c"}.fa-unlock-alt:before{content:"\f13e"}.fa-unsplash:before{content:"\e07c"}.fa-untappd:before{content:"\f405"}.fa-upload:before{content:"\f093"}.fa-ups:before{content:"\f7e0"}.fa-usb:before{content:"\f287"}.fa-user:before{content:"\f007"}.fa-user-alt:before{content:"\f406"}.fa-user-alt-slash:before{content:"\f4fa"}.fa-user-astronaut:before{content:"\f4fb"}.fa-user-check:before{content:"\f4fc"}.fa-user-circle:before{content:"\f2bd"}.fa-user-clock:before{content:"\f4fd"}.fa-user-cog:before{content:"\f4fe"}.fa-user-edit:before{content:"\f4ff"}.fa-user-friends:before{content:"\f500"}.fa-user-graduate:before{content:"\f501"}.fa-user-injured:before{content:"\f728"}.fa-user-lock:before{content:"\f502"}.fa-user-md:before{content:"\f0f0"}.fa-user-minus:before{content:"\f503"}.fa-user-ninja:before{content:"\f504"}.fa-user-nurse:before{content:"\f82f"}.fa-user-plus:before{content:"\f234"}.fa-user-secret:before{content:"\f21b"}.fa-user-shield:before{content:"\f505"}.fa-user-slash:before{content:"\f506"}.fa-user-tag:before{content:"\f507"}.fa-user-tie:before{content:"\f508"}.fa-user-times:before{content:"\f235"}.fa-users:before{content:"\f0c0"}.fa-users-cog:before{content:"\f509"}.fa-users-slash:before{content:"\e073"}.fa-usps:before{content:"\f7e1"}.fa-ussunnah:before{content:"\f407"}.fa-utensil-spoon:before{content:"\f2e5"}.fa-utensils:before{content:"\f2e7"}.fa-vaadin:before{content:"\f408"}.fa-vector-square:before{content:"\f5cb"}.fa-venus:before{content:"\f221"}.fa-venus-double:before{content:"\f226"}.fa-venus-mars:before{content:"\f228"}.fa-vest:before{content:"\e085"}.fa-vest-patches:before{content:"\e086"}.fa-viacoin:before{content:"\f237"}.fa-viadeo:before{content:"\f2a9"}.fa-viadeo-square:before{content:"\f2aa"}.fa-vial:before{content:"\f492"}.fa-vials:before{content:"\f493"}.fa-viber:before{content:"\f409"}.fa-video:before{content:"\f03d"}.fa-video-slash:before{content:"\f4e2"}.fa-vihara:before{content:"\f6a7"}.fa-vimeo:before{content:"\f40a"}.fa-vimeo-square:before{content:"\f194"}.fa-vimeo-v:before{content:"\f27d"}.fa-vine:before{content:"\f1ca"}.fa-virus:before{content:"\e074"}.fa-virus-slash:before{content:"\e075"}.fa-viruses:before{content:"\e076"}.fa-vk:before{content:"\f189"}.fa-vnv:before{content:"\f40b"}.fa-voicemail:before{content:"\f897"}.fa-volleyball-ball:before{content:"\f45f"}.fa-volume-down:before{content:"\f027"}.fa-volume-mute:before{content:"\f6a9"}.fa-volume-off:before{content:"\f026"}.fa-volume-up:before{content:"\f028"}.fa-vote-yea:before{content:"\f772"}.fa-vr-cardboard:before{content:"\f729"}.fa-vuejs:before{content:"\f41f"}.fa-walking:before{content:"\f554"}.fa-wallet:before{content:"\f555"}.fa-warehouse:before{content:"\f494"}.fa-watchman-monitoring:before{content:"\e087"}.fa-water:before{content:"\f773"}.fa-wave-square:before{content:"\f83e"}.fa-waze:before{content:"\f83f"}.fa-weebly:before{content:"\f5cc"}.fa-weibo:before{content:"\f18a"}.fa-weight:before{content:"\f496"}.fa-weight-hanging:before{content:"\f5cd"}.fa-weixin:before{content:"\f1d7"}.fa-whatsapp:before{content:"\f232"}.fa-whatsapp-square:before{content:"\f40c"}.fa-wheelchair:before{content:"\f193"}.fa-whmcs:before{content:"\f40d"}.fa-wifi:before{content:"\f1eb"}.fa-wikipedia-w:before{content:"\f266"}.fa-wind:before{content:"\f72e"}.fa-window-close:before{content:"\f410"}.fa-window-maximize:before{content:"\f2d0"}.fa-window-minimize:before{content:"\f2d1"}.fa-window-restore:before{content:"\f2d2"}.fa-windows:before{content:"\f17a"}.fa-wine-bottle:before{content:"\f72f"}.fa-wine-glass:before{content:"\f4e3"}.fa-wine-glass-alt:before{content:"\f5ce"}.fa-wix:before{content:"\f5cf"}.fa-wizards-of-the-coast:before{content:"\f730"}.fa-wodu:before{content:"\e088"}.fa-wolf-pack-battalion:before{content:"\f514"}.fa-won-sign:before{content:"\f159"}.fa-wordpress:before{content:"\f19a"}.fa-wordpress-simple:before{content:"\f411"}.fa-wpbeginner:before{content:"\f297"}.fa-wpexplorer:before{content:"\f2de"}.fa-wpforms:before{content:"\f298"}.fa-wpressr:before{content:"\f3e4"}.fa-wrench:before{content:"\f0ad"}.fa-x-ray:before{content:"\f497"}.fa-xbox:before{content:"\f412"}.fa-xing:before{content:"\f168"}.fa-xing-square:before{content:"\f169"}.fa-y-combinator:before{content:"\f23b"}.fa-yahoo:before{content:"\f19e"}.fa-yammer:before{content:"\f840"}.fa-yandex:before{content:"\f413"}.fa-yandex-international:before{content:"\f414"}.fa-yarn:before{content:"\f7e3"}.fa-yelp:before{content:"\f1e9"}.fa-yen-sign:before{content:"\f157"}.fa-yin-yang:before{content:"\f6ad"}.fa-yoast:before{content:"\f2b1"}.fa-youtube:before{content:"\f167"}.fa-youtube-square:before{content:"\f431"}.fa-zhihu:before{content:"\f63f"}.sr-only{border:0;clip:rect(0,0,0,0);height:1px;margin:-1px;overflow:hidden;padding:0;position:absolute;width:1px}.sr-only-focusable:active,.sr-only-focusable:focus{clip:auto;height:auto;margin:0;overflow:visible;position:static;width:auto}@font-face{font-family:"Font Awesome 5 Brands";font-style:normal;font-weight:400;font-display:block;src:url(/font/fa/fa-brands-400.eot);src:url(/font/fa/fa-brands-400.eot?#iefix) format("embedded-opentype"),url(/font/fa/fa-brands-400.woff2) format("woff2"),url(/font/fa/fa-brands-400.woff) format("woff"),url(/font/fa/fa-brands-400.ttf) format("truetype"),url(/font/fa/fa-brands-400.svg#fontawesome) format("svg")}.fab{font-family:"Font Awesome 5 Brands"}@font-face{font-family:"Font Awesome 5 Free";font-style:normal;font-weight:400;font-display:block;src:url(/font/fa/fa-regular-400.eot);src:url(/font/fa/fa-regular-400.eot?#iefix) format("embedded-opentype"),url(/font/fa/fa-regular-400.woff2) format("woff2"),url(/font/fa/fa-regular-400.woff) format("woff"),url(/font/fa/fa-regular-400.ttf) format("truetype"),url(/font/fa/fa-regular-400.svg#fontawesome) format("svg")}.fab,.far{font-weight:400}@font-face{font-family:"Font Awesome 5 Free";font-style:normal;font-weight:900;font-display:block;src:url(/font/fa/fa-solid-900.eot);src:url(/font/fa/fa-solid-900.eot?#iefix) format("embedded-opentype"),url(/font/fa/fa-solid-900.woff2) format("woff2"),url(/font/fa/fa-solid-900.woff) format("woff"),url(/font/fa/fa-solid-900.ttf) format("truetype"),url(/font/fa/fa-solid-900.svg#fontawesome) format("svg")}.fa,.far,.fas{font-family:"Font Awesome 5 Free"}.fa,.fas{font-weight:900}
  6
  7.details .details-summary:hover {
  8  cursor: pointer;
  9}
 10.details i.details-icon {
 11color: var(--content);
 12-webkit-transition: transform 0.2s ease;
 13-moz-transition: transform 0.2s ease;
 14-o-transition: transform 0.2s ease;
 15transition: transform 0.2s ease;
 16}
 17[class=dark] .details i.details-icon {
 18color: var(--content);
 19}
 20.details .details-content {
 21max-height: 0;
 22overflow-y: hidden;
 23word-wrap: break-word;
 24overflow-x: hidden;
 25-webkit-transition: max-height 0.8s cubic-bezier(0, 1, 0, 1) 0s;
 26-moz-transition: max-height 0.8s cubic-bezier(0, 1, 0, 1) 0s;
 27-o-transition: max-height 0.8s cubic-bezier(0, 1, 0, 1) 0s;
 28transition: max-height 0.8s cubic-bezier(0, 1, 0, 1) 0s;
 29}
 30.details.open i.details-icon {
 31-webkit-transform: rotate(90deg);
 32-moz-transform: rotate(90deg);
 33-ms-transform: rotate(90deg);
 34-o-transform: rotate(90deg);
 35transform: rotate(90deg);
 36}
 37.details.open .details-content {
 38max-height: 12000px;
 39-webkit-transition: max-height 0.8s cubic-bezier(0.5, 0, 1, 0) 0s;
 40-moz-transition: max-height 0.8s cubic-bezier(0.5, 0, 1, 0) 0s;
 41-o-transition: max-height 0.8s cubic-bezier(0.5, 0, 1, 0) 0s;
 42transition: max-height 0.8s cubic-bezier(0.5, 0, 1, 0) 0s;
 43overflow-x: hidden;
 44}
 45
 46.admonition {
 47  position: relative;
 48  margin: 1rem 0;
 49  padding: 0 0.75rem;
 50  background-color: rgba(68, 138, 255, 0.1);
 51  border-left: 0.25rem solid #448aff;
 52  border-radius: 8px;
 53  overflow: auto;
 54}
 55.admonition .admonition-title {
 56  font-weight: bold;
 57  margin: 0 -0.75rem;
 58  padding: 0.25rem 3rem;
 59  border-radius: 7px;
 60  border-bottom: 1px solid rgba(68, 138, 255, 0.1);
 61  background-color: rgba(68, 138, 255, 0.25);
 62}
 63.admonition.open .admonition-title {
 64  background-color: rgba(68, 138, 255, 0.1);
 65}
 66.admonition .admonition-content {
 67  padding: 0.5rem 0;
 68}
 69.admonition i.icon {
 70  font-size: 1.45rem;
 71  color: #448aff;
 72  position: absolute;
 73  top: 1.25rem;
 74  left: 0.65rem;
 75}
 76.admonition i.details-icon {
 77  position: absolute;
 78  top: 0.9rem;
 79  right: 0.5rem;
 80}
 81.admonition.note {
 82  border-left-color: #448aff;
 83}
 84.admonition.note i.icon {
 85  color: #448aff;
 86}
 87.admonition.abstract {
 88  border-left-color: #00b0ff;
 89}
 90.admonition.abstract i.icon {
 91  color: #00b0ff;
 92}
 93.admonition.info {
 94  border-left-color: #00b8d4;
 95}
 96.admonition.info i.icon {
 97  color: #00b8d4;
 98}
 99.admonition.tip {
100  border-left-color: #00bfa5;
101}
102.admonition.tip i.icon {
103  color: #00bfa5;
104}
105.admonition.success {
106  border-left-color: #00c853;
107}
108.admonition.success i.icon {
109  color: #00c853;
110}
111.admonition.question {
112  border-left-color: #64dd17;
113}
114.admonition.question i.icon {
115  color: #64dd17;
116}
117.admonition.warning {
118  border-left-color: #ff9100;
119}
120.admonition.warning i.icon {
121  color: #ff9100;
122}
123.admonition.failure {
124  border-left-color: #ff5252;
125}
126.admonition.failure i.icon {
127  color: #ff5252;
128}
129.admonition.danger {
130  border-left-color: #ff1744;
131}
132.admonition.danger i.icon {
133  color: #ff1744;
134}
135.admonition.bug {
136  border-left-color: #f50057;
137}
138.admonition.bug i.icon {
139  color: #f50057;
140}
141.admonition.example {
142  border-left-color: #651fff;
143}
144.admonition.example i.icon {
145  color: #651fff;
146}
147.admonition.quote {
148  border-left-color: #9e9e9e;
149}
150.admonition.quote i.icon {
151  color: #9e9e9e;
152}
153.admonition.note {
154  background-color: rgba(68, 138, 255, 0.1);
155}
156.admonition.note .admonition-title {
157  border-bottom-color: rgba(68, 138, 255, 0.1);
158  background-color: rgba(68, 138, 255, 0.25);
159}
160.admonition.note.open .admonition-title {
161  background-color: rgba(68, 138, 255, 0.1);
162}
163.admonition.abstract {
164  background-color: rgba(0, 176, 255, 0.1);
165}
166.admonition.abstract .admonition-title {
167  border-bottom-color: rgba(0, 176, 255, 0.1);
168  background-color: rgba(0, 176, 255, 0.25);
169}
170.admonition.abstract.open .admonition-title {
171  background-color: rgba(0, 176, 255, 0.1);
172}
173.admonition.info {
174  background-color: rgba(0, 184, 212, 0.1);
175}
176.admonition.info .admonition-title {
177  border-bottom-color: rgba(0, 184, 212, 0.1);
178  background-color: rgba(0, 184, 212, 0.25);
179}
180.admonition.info.open .admonition-title {
181  background-color: rgba(0, 184, 212, 0.1);
182}
183.admonition.tip {
184  background-color: rgba(0, 191, 165, 0.1);
185}
186.admonition.tip .admonition-title {
187  border-bottom-color: rgba(0, 191, 165, 0.1);
188  background-color: rgba(0, 191, 165, 0.25);
189}
190.admonition.tip.open .admonition-title {
191  background-color: rgba(0, 191, 165, 0.1);
192}
193.admonition.success {
194  background-color: rgba(0, 200, 83, 0.1);
195}
196.admonition.success .admonition-title {
197  border-bottom-color: rgba(0, 200, 83, 0.1);
198  background-color: rgba(0, 200, 83, 0.25);
199}
200.admonition.success.open .admonition-title {
201  background-color: rgba(0, 200, 83, 0.1);
202}
203.admonition.question {
204  background-color: rgba(100, 221, 23, 0.1);
205}
206.admonition.question .admonition-title {
207  border-bottom-color: rgba(100, 221, 23, 0.1);
208  background-color: rgba(100, 221, 23, 0.25);
209}
210.admonition.question.open .admonition-title {
211  background-color: rgba(100, 221, 23, 0.1);
212}
213.admonition.warning {
214  background-color: rgba(255, 145, 0, 0.1);
215}
216.admonition.warning .admonition-title {
217  border-bottom-color: rgba(255, 145, 0, 0.1);
218  background-color: rgba(255, 145, 0, 0.25);
219}
220.admonition.warning.open .admonition-title {
221  background-color: rgba(255, 145, 0, 0.1);
222}
223.admonition.failure {
224  background-color: rgba(255, 82, 82, 0.1);
225}
226.admonition.failure .admonition-title {
227  border-bottom-color: rgba(255, 82, 82, 0.1);
228  background-color: rgba(255, 82, 82, 0.25);
229}
230.admonition.failure.open .admonition-title {
231  background-color: rgba(255, 82, 82, 0.1);
232}
233.admonition.danger {
234  background-color: rgba(255, 23, 68, 0.1);
235}
236.admonition.danger .admonition-title {
237  border-bottom-color: rgba(255, 23, 68, 0.1);
238  background-color: rgba(255, 23, 68, 0.25);
239}
240.admonition.danger.open .admonition-title {
241  background-color: rgba(255, 23, 68, 0.1);
242}
243.admonition.bug {
244  background-color: rgba(245, 0, 87, 0.1);
245}
246.admonition.bug .admonition-title {
247  border-bottom-color: rgba(245, 0, 87, 0.1);
248  background-color: rgba(245, 0, 87, 0.25);
249}
250.admonition.bug.open .admonition-title {
251  background-color: rgba(245, 0, 87, 0.1);
252}
253.admonition.example {
254  background-color: rgba(101, 31, 255, 0.1);
255}
256.admonition.example .admonition-title {
257  border-bottom-color: rgba(101, 31, 255, 0.1);
258  background-color: rgba(101, 31, 255, 0.25);
259}
260.admonition.example.open .admonition-title {
261  background-color: rgba(101, 31, 255, 0.1);
262}
263.admonition.quote {
264  background-color: rgba(60,60,60,.1);
265}
266.admonition.quote .admonition-title {
267  border-bottom-color: rgba(60, 60, 60, 0.1);
268  background-color: rgba(60, 60, 60, 0.25);
269}
270.admonition.quote.open .admonition-title {
271  background-color: rgba(60, 60, 60, 0.1);
272}
273.admonition:last-child {
274  margin-bottom: 0.75rem;
275}
276.admonition.note.open .admonition-title:hover,
277.admonition.note .admonition-title:hover {
278  background-color: rgba(68, 138, 255, 0.5);
279  cursor: url('/img/link.png'), pointer !important;
280}
281
282.admonition.abstract.open .admonition-title:hover,
283.admonition.abstract .admonition-title:hover {
284  background-color: rgba(0, 176, 255, 0.5);
285  cursor: url('/img/link.png'), pointer !important;
286}
287
288.admonition.info.open .admonition-title:hover,
289.admonition.info .admonition-title:hover {
290  background-color: rgba(0, 184, 212, 0.5);
291  cursor: url('/img/link.png'), pointer !important;
292}
293
294.admonition.tip.open .admonition-title:hover,
295.admonition.tip .admonition-title:hover {
296  background-color: rgba(0, 191, 165, 0.5);
297  cursor: url('/img/link.png'), pointer !important;
298}
299
300.admonition.success.open .admonition-title:hover,
301.admonition.success .admonition-title:hover {
302  background-color: rgba(0, 200, 83, 0.5);
303  cursor: url('/img/link.png'), pointer !important;
304}
305
306.admonition.question.open .admonition-title:hover,
307.admonition.question .admonition-title:hover {
308  background-color: rgba(100, 221, 23, 0.5);
309  cursor: url('/img/link.png'), pointer !important;
310}
311
312.admonition.warning.open .admonition-title:hover,
313.admonition.warning .admonition-title:hover {
314  background-color: rgba(255, 145, 0, 0.5);
315  cursor: url('/img/link.png'), pointer !important;
316}
317
318.admonition.failure.open .admonition-title:hover,
319.admonition.failure .admonition-title:hover {
320  background-color: rgba(255, 82, 82, 0.5);
321  cursor: url('/img/link.png'), pointer !important;
322}
323
324.admonition.danger.open .admonition-title:hover,
325.admonition.danger .admonition-title:hover {
326  background-color: rgba(255, 23, 68, 0.5);
327  cursor: url('/img/link.png'), pointer !important;
328}
329
330.admonition.bug.open .admonition-title:hover,
331.admonition.bug .admonition-title:hover {
332  background-color: rgba(245, 0, 87, 0.5);
333  cursor: url('/img/link.png'), pointer !important;
334}
335
336.admonition.example.open .admonition-title:hover,
337.admonition.example .admonition-title:hover {
338  background-color: rgba(101, 31, 255, 0.5);
339  cursor: url('/img/link.png'), pointer !important;
340}
341
342.admonition.quote.open .admonition-title:hover,
343.admonition.quote .admonition-title:hover {
344  background-color: rgba(60, 60, 60, 0.5);
345  cursor: url('/img/link.png'), pointer !important;
346}
347[data-scheme="dark"] .admonition.quote.open .admonition-title:hover,
348[data-scheme="dark"] .admonition.quote .admonition-title:hover {
349  background-color: rgba(160, 160, 160, 0.5);
350}

在 layouts/partials/footer/custom.html 最后添加：

 1{{- /* admonition toggle */}}
 2<script>
 3    let details = document.getElementsByClassName('details')
 4    details = details || [];
 5    for (let i = 0; i < details.length; i++) {
 6        let element = details[i]
 7        const summary = element.getElementsByClassName('details-summary')[0];
 8        if (summary) {
 9            summary.addEventListener('click', () => {
10                element.classList.toggle('open');
11            }, false);
12        }
13    }
14</script>

复制字体文件

将字体文件复制到 static/font/fa/ 中。所有用到的文件目录结构如下：

 1tree hugo/
 2# hugo/
 3# ├─ assets
 4# │    └─ scss
 5# │           └─ custom.scss
 6# ├─ layouts
 7# │    ├─ partials
 8# │    │     └─ footer
 9# │    │            └─ custom.html
10# │    └─ shortcodes
11# │           └─ admonition.html
12# └─ static
13#        └─ font
14#               └─ fa
15#                      ├─ fa-brands-400.eot
16#                      ├─ fa-brands-400.svg
17#                      ├─ fa-brands-400.ttf
18#                      ├─ fa-brands-400.woff
19#                      ├─ fa-brands-400.woff2
20#                      ├─ fa-regular-400.eot
21#                      ├─ fa-regular-400.svg
22#                      ├─ fa-regular-400.ttf
23#                      ├─ fa-regular-400.woff
24#                      ├─ fa-regular-400.woff2
25#                      ├─ fa-solid-900.eot
26#                      ├─ fa-solid-900.svg
27#                      ├─ fa-solid-900.ttf
28#                      ├─ fa-solid-900.woff
29#                      └─ fa-solid-900.woff2

使用：

1{{< admonition type=note title="标注" open=false >}}标注{{< /admonition >}}

小记

参考

‫ ‫ ‫

忙忙忙，只能又水一篇了

脚注参考链接 1 : 续・深入探究 Hugo 短代码：我今天还就非得把这个脚注写出来不可 ↩︎
脚注参考链接 2 : Footnotes are not rendered as expected in nested shortcodes ↩︎ ↩︎
footnote 3 ：点返回试试 → ↩︎

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

小结

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

Code 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` 协程