码农笔记

Go Web学习笔记（二）- JSON binding、validator、错误响应

2026-06-02T02:00:00.000Z

今天学习：

ShouldBindJSON
binding tag
参数校验
统一错误响应
业务错误和参数错误区分

ShouldBindJSON

ShouldBindJSON会把请求body里的JSON绑定到struct

type CreateUserRequest struct {
Name  string `json:"name"`
Email string `json:"email"`
Age   int    `json:"age"`
}

func createUser(c *gin.Context) {
var req CreateUserRequest

if err := c.ShouldBindJSON(&req); err != nil {
c.JSON(http.StatusBadRequest, gin.H{
"error": err.Error(),
})
return
}
c.JSON(http.StatusOK, gin.H{
"id":    1,
"name":  req.Name,
"email": req.Email,
"age":   req.Age,
})

}

注意：c.ShouldBindJSON(&req)这里必须传递指针，因为要修改req的值。

除了ShouldBindJSON，还有一个BindJSON。

err := c.BindJSON(&req)
if err != nil {
return
}

如果报错，会直接返回。

1	400 Bad Request

不过出于灵活性，工作中常用的是ShouldBindJSON。

validator:binding tag

对于熟悉Spring的Java程序员来说，它就相当于@Validated、@Valid注解，以及各种字段注解：@NotNull、@Size、@Min等。

例如：

type CreateUserRequest struct {
Name     string `json:"name" binding:"required,min=2,max=5"`
Email    string `json:"email" binding:"required,email"`
Password string `json:"password" binding:"required,min=8"`
Age      int    `json:"age" binding:"required,gte=18,lte=120"`
}

在常规json struct中，加入binding，常见规则有：

required : 必填
email    : 必须是邮箱格式
min      : 最小长度或者最小值
max      : 最大长度或者最大值
gte      : 大于等于
lte      : 小于等于
oneof    : 枚举值

关于oneof，以角色状态为：

1	Status string `json:"status" binding:"required,oneof=active disabled"`

当然，这些知识基础校验，通常也是放在Request DTO的binding tag里，对于业务校验，还应该放在service层。例如用户已存在、邮箱后缀不符等。

统一错误响应

不要每个handler随便返回不同格式，对于前端是个灾难，对于Java来说，通常都会定一个一Response类，返回固定格式:

{
    "msg":"xxxx",
    "code":200,
    “data”:object
}

对于Go Web当然也都是一样的操作（俗称java味？）。

创建一个response包，并创建一个response.go文件，内容如下：

package response

import (
"net/http"

"github.com/gin-gonic/gin"
)

type ErrorResponse struct {
Code    string `json:"code"`
Message string `json:"message"`
}

func Error(c *gin.Context, status int, code, message string) {
c.JSON(status, ErrorResponse{
Code:    code,
Message: message,
})
}

func BadRequest(c *gin.Context, message string) {
Error(c, http.StatusBadRequest, "BAD_REQUEST", message)
}

func Unauthorized(c *gin.Context, message string) {
Error(c, http.StatusUnauthorized, "UNAUTHORIZED", message)
}

func OK(c *gin.Context, data any) {
c.JSON(http.StatusOK, gin.H{
"data": data,
})
}

使用办法，直接在原来的例子中修改为如下：

import (
"fmt"
"net/http"
// 导入
"dev.net.cn/goweb/response"
"github.com/gin-gonic/gin"
)

func createUser(c *gin.Context) {
var req CreateUserRequest

if err := c.ShouldBindJSON(&req); err != nil {
        /*
        c.JSON(http.StatusBadRequest, gin.H{
"error": err.Error(),
})
*/
        // 修改为如下
response.BadRequest(c, err.Error())
return
}
response.OK(c, gin.H{
"id":    1,
"name":  req.Name,
"email": req.Email,
"age":   req.Age,
})

}

测试：

POST http://localhost:8080/user
{
    "name":"张三",
    "email":"zhangsan@dev.net",
    "password":"123456",
    "age":28
}

响应如下：

{
    "code": "BAD_REQUEST",
    "message": "Key: 'CreateUserRequest.Password' Error:Field validation for 'Password' failed on the 'min' tag"
}

将password的值修改为8位，响应如下：

{
    "data": {
        "age": 28,
        "email": "zhangsan@dev.net",
        "id": 1,
        "name": "张三"
    }
}

业务错误类型

除了常规错误意外，系统中还应处理业务错误，例如：邮箱已存在、用户名已存在等。

创建errs包，并创建error.go文件，内容为：

package errs

type AppError struct {
Code       string
Message    string
HTTPStatus int
}

func (e *AppError) Error() string {
return e.Code + " : " + e.Message
}

var ErrUserNotFound = &AppError{
Code:       "USER_NOT_FOUND",
Message:    "User not found",
HTTPStatus: 404,
}

var ErrEmailExists = &AppError{
Code:       "EMAIL_EXISTS",
Message:    "Email exists",
HTTPStatus: 409,
}

在response包里面的resopnse.go文件中，新增如下内容：

// 别忘了 import "dev.net.cn/goweb/errs"
func HandleError(c *gin.Context, err error) {
if appErr, ok := errors.AsType[*errs.AppError](err); ok {
c.JSON(appErr.HTTPStatus, gin.H{
"code":    appErr.Code,
"message": appErr.Message,
})
return
}
c.JSON(http.StatusInternalServerError, gin.H{
"code":    "INTERNAL_ERROR",
"message": "internal server error",
})
}

修改main.go，新增如下代码：

1
2
3

func validateEmail(email string) error {
return errs.ErrEmailExists
}

修改原来的createUser代码为如下：

func createUser(c *gin.Context) {
var req CreateUserRequest

if err := c.ShouldBindJSON(&req); err != nil {
response.BadRequest(c, err.Error())
return
}

if err := validateEmail(req.Email); err != nil {
response.HandleError(c, err)
return
}

response.OK(c, gin.H{
"id":    1,
"name":  req.Name,
"email": req.Email,
"age":   req.Age,
})

}

调用这个接口：

{
    "code": "EMAIL_EXISTS",
    "message": "Email exists"
}

Go Web学习笔记（一）- 路由、参数、JSON 响应

2026-06-01T02:00:00.000Z

今天开始学习Go Web，目前主流的框架有gin、go-zero、echo等。我还是随主流，选择gin。

今天要学习的知识点是：

启动Gin服务
定义Get / POST / PUT / DELETE / 路由
获取路径参数
获取query参数
返回JSON响应
路由分组

创建一个gin项目

初始化项目

# 创建项目目录
mkdir goweb
cd goweb

# 初始化go mode
go mod init dev.net.cn/goweb

执行完成后，会生成一个go.mod文件，用来管理项目的依赖和版本。

配置代理

为了更快的下载Go的模块，这里推荐大陆用户配置代理

# 如果是 Linux / macOS
export GOPROXY=https://goproxy.cn,direct

# 如果是 Windows (PowerShell)
$env:GOPROXY="https://goproxy.cn,direct"

下载gin依赖

1	go get -u github.com/gin-gonic/gin

编写主程序代码

在项目根目录创建main.go，其内容如下：

package main

import (
"fmt"
"net/http"

"github.com/gin-gonic/gin"
)

func main() {
// 创建一个默认的Gin路由引擎（内置了Logger和Recovery）
r := gin.Default()
    // 创建一个新的Gin路由引擎（不带任何中间件）
// r := gin.New()

// 绑定路由及操作 @Mapping("/hello")
r.GET("/hello", func(c *gin.Context) {
c.JSON(http.StatusOK, gin.H{
"message": "hello go web",
"status":  "ok",
})
})
// 指定端口，默认就是8080
err := r.Run(":8080")
if err != nil {
fmt.Println("start error...")
}
}

测试

1	curl http://localhost:8080/hello

1	{"message":"hello go web","status":"ok"}

其中c.JSON(http.StatusOK, gin.H{...})表示返回JSON响应，gin.H本质上是：

1	map[string]any

Gin中的gin.Default()和gin.New()的主要区别：gin.Default()默认包含了Logger和Recovery中间件；gin.New()创建一个不带默认中间件的engine，需要自己手动添加中间件。暂时先用Default。

路径参数：c.Param

类似于：@PathVariable("id")，假设要获取一个路径参数，可以使用如下方式：

r.GET("/users/:id", func(c *gin.Context) {
// 获取路径参数 id
    id := c.Param("id")
c.JSON(http.StatusOK, gin.H{
"id": id,
})
})

访问

1	curl http://localhost:8080/users/666

响应：

1	{"id":"666"}

默认拿到的路径参数是string类型。如需其他类型需要自行转换。

Query参数：c.Query/c.DefaultQuery

类似于：@ReuqestParam("xxx")如果是Query参数，那么就需要如下方式：

r.GET("/users", func(c *gin.Context) {
// 如果参数不存在，返回默认值
page := c.DefaultQuery("page", "1")
pageSize := c.DefaultQuery("page_size", "10")
// 参数不存在 返回空字符串
keyword := c.Query("keyword")
c.JSON(http.StatusOK, gin.H{
"page":      page,
"page_size": pageSize,
"keyword":   keyword,
})
})

DefaultQuery ：如果不存在，返回默认值
Query：如果不存在，返回空字符串。

路径参数与Query参数的使用区别：

路径参数通常表示资源标识，例如/users/:id；
Query参数通常表示过略、分页、排序条件。

POST/PUT/DELETE请求

上面的例子都是GET请求，下面介绍其他几个请求方式。本质上和Spring的没啥区别。

POST

对于POST，首先需要参数绑定，计划明天学习，先来实践一下：

type User struct {
// binding： "required 表示该字段必填，否则报错 对应Java @NotNull"
Name string `json:"name" binding:"required"`
// 限制年龄在0-130
Age int `json:"age" binding:"gte=0,lte=130"`
}

type UserURI struct {
ID string `uri:"id" binding:"required"`
}

其代码如下：

r.POST("/users", func(c *gin.Context) {
var newUser User
//c.ShouldBindJSON(&newUser); 相当于 @RequestBody
if err := c.ShouldBindJSON(&newUser); err != nil {
c.JSON(http.StatusBadRequest, gin.H{
"error": err.Error(),
})
}
c.JSON(http.StatusOK, gin.H{
"status": "user created",
"data":   newUser,
})
})

c.ShouldBindJSON(&newUser)相当于Spring中的@ReuqestBody，将请求体中的json绑定到User中。

POST http://localhost:8080/users
{
    "name": "tom",
    "age": 22
}

PUT

r.PUT("/users/:id", func(c *gin.Context) {
var uriData UserURI
var updateData User

if err := c.ShouldBindUri(&uriData); err != nil {
c.JSON(http.StatusBadRequest, gin.H{
"error": err.Error(),
})
return
}
if err := c.ShouldBindJSON(&updateData); err != nil {
c.JSON(http.StatusBadRequest, gin.H{
"error": err.Error(),
})
return
}
c.JSON(http.StatusOK, gin.H{
"status":  "user updated",
"userId":  uriData.ID,
"newData": updateData,
})
})

代码综合GET/POST

PUT http://localhost:8080/users/123
{
    "name":"jerry",
    "age": 18
}

Delete

r.DELETE("/users/:id", func(c *gin.Context) {
id := c.Param("id")
if id == "" {
c.JSON(http.StatusBadRequest, gin.H{
"error": "id is required",
})
return
}
c.JSON(http.StatusOK, gin.H{
"status": "user deleted",
"id":     id,
})
})

请求报文

1	DELETE http://localhost:8080/users/123

路由分组：RouterGroup

可以将某一类接口进行分组。相当于Java加在Controller类上的@Mapping("/xxx")。

func main() {
// 创建一个默认的Gin路由引擎（内置了Logger和Recovery）
r := gin.Default()
api := r.Group("/api/v1")
{
api.GET("/users", listUser)
api.GET("/users/:id", getUser)
api.POST("/users", createUser)
}

err := r.Run(":8080")
if err != nil {
fmt.Println("start error...")
}
}

func listUser(c *gin.Context) {
c.JSON(http.StatusOK, gin.H{
"items": []gin.H{
{"id": 1, "name": "tom"},
{"id": 2, "name": "jack"},
},
})
}

func getUser(c *gin.Context) {
id := c.Param("id")
c.JSON(http.StatusOK, gin.H{
"id":   id,
"name": "tom",
})
}

func createUser(c *gin.Context) {
c.JSON(http.StatusOK, gin.H{
"id":   1,
"name": "tom",
})
}

请求：

1	GET http://localhost:8080/api/v1/users

响应：

{
    "items": [
        {
            "id": 1,
            "name": "tom"
        },
        {
            "id": 2,
            "name": "jack"
        }
    ]
}

路由分组适合做API版本、模块分区、权限分区。

VS Code无法登录微软账号

2026-04-13T03:00:00.000Z

现象

在VS Code中，点击账户->登录以同步设置后，弹出的登陆界面提示404，右下角错误信息为：no_network_connectivity: No network connectivity. Check your internet connection.。如下图所示：

在mac/linux上这个功能是可用的。

解决方案

其根本原因是Clash Verge在作祟，但也不能每次都关闭，还要查到具体的原因。后来通过多方搜索，找到了原因：

登录调用的是工作或学校账户的UWP应用，默认无法使用本地回环地址的代理

所以，需要借助Clash Verge自带的UWP 工具，在设置 -> Clash设置 -> UWP 工具。打开后，勾选列表中的工作或学校账户。

点击Save Changes后，再次尝试登录，就可以正常登录了。

Go语言学习笔记（八）- 标准库

2026-04-07T04:00:00.000Z

文件操作：os、io、bufio

Go语言中，文件操作主要分三层

os : 直接和操作系统交互，比如打开文件、删除文件、创建文件、读写文件等。
io ：抽象I/O行为，比如：io.Reader、io.Writer、io.Copy
bufio : 带缓冲的读写，适合按行读取、大文件处理、减少系统调用。

os.ReadFile

一次性读取整个文件，适合读取小文件，例如配置文件、模板文件、JSON文件。

func TestOsReadFile(t *testing.T) {
data, err := os.ReadFile("d:/a.txt")
if err != nil {
t.Error(err)
}

fmt.Println(string(data))
}

注意：不要用它读取特别大的文件，因为会一次性把整个文件加载到内存。

os.WriteFile

一次性写入文件

func TestOsWriteFile(t *testing.T) {

data := []byte("Hello World\n")

err := os.WriteFile("d:/a1.txt", data, 0644)
if err != nil {
t.Error(err)
return
}

fmt.Println("write success")
}

0644是权限标志，代表：owner:读写(6) 、group:只读(4)、others: 只读(4)，等同于linux中的rw-r--r--。另外：可执行权限是1(x)。

os.Open

打开文件：os.Open默认是只读打开。

func TestOsOpen(t *testing.T) {
file, err := os.Open("d:/a.txt")
if err != nil {
t.Error(err)
return
}
// 关闭文件
//defer file.Close()

defer func(file *os.File) {
err := file.Close()
if err != nil {
t.Error(err)
}
}(file)

t.Logf("file name: %s", file.Name())
}

打开文件后，一定要关闭，日常Go代码里，打开资源后立刻defer Close()是很常见的习惯。

不过，这里和Java一样，也要处理关闭时的异常。推荐使用如下代码：

defer func(file *os.File) {
err := file.Close()
if err != nil {
t.Error(err)
}
}(file)

os.Create

创建文件：

func TestOsCreate(t *testing.T) {
file, err := os.Create("d:/a2.txt")
if err != nil {
t.Error(err)
return
}
defer func(file *os.File) {
if err := file.Close(); err != nil {
t.Logf("close file failed : %v", err)
}
}(file)

_, err = file.WriteString("hello world \n")
if err != nil {
t.Error(err)
return
}
}

如果文件已经存在，会清空源文件内容。

os.OpenFile

追加写入文件：日常开发里的日志、追加数据等场景可以用到。

func TestOsOpenFile(t *testing.T) {
file, err := os.OpenFile("a.txt", os.O_CREATE|os.O_WRONLY|os.O_APPEND, 0644)
if err != nil {
t.Error(err)
return
}

defer func(file *os.File) {
err := file.Close()
if err != nil {
t.Error(err)
}
}(file)

_, err = file.WriteString("\n666666666666666666666666666\n")
if err != nil {
t.Error(err)
return
}
}

其中第二个参数是flag，常见的有：

os.O_CREATE : 文件不存在则创建
os.O_WRONLY ：只写
os.O_RDWR ：读写
os.O_APPEND : 追加写
os.O_TRUNC: 打开时清空

os.ErrNotExist

判断文件是否存在

func TestOsErrNotExist(t *testing.T) {
_, err := os.Stat("ab.txt")
//if err != nil {
//t.Error(err)
//return
//}
// 推荐使用errors.Is判断错误类型
if errors.Is(err, os.ErrNotExist) {
t.Error("file does not exist")
return
}
t.Log("stat file", err)
}

io.Reader和io.Writer

这是Go语言关于I/O的核心抽象

io.Reader的定义大概如下：

1
2
3

type Reader interface {
    Read(p []byte) (n int,err error)
}

io.Writer的定义大概如下：

1
2
3

type Writer interface {
    Write(p []byte) (n int,err error)
}

io包的主要作用就是把各种I/O实现抽象成通用接口，例如文件、网络链接、HTTP响应体、字符串reader都可以被统一处理。

/**
 这个函数可以接受任何io.Reader
    printAll(file)
    printAll(resp.Body)
    printAll(strings.NewReader("abc"))
 */
func printAll(r io.Reader) error {
data, err := io.ReadAll(r)
if err != nil {
return err
}
fmt.Println(string(data))
return nil
}

func TestIOReader(t *testing.T) {
r := strings.NewReader("Hello Reader")
err := printAll(r)
if err != nil {
t.Fatal(err)
}
}

这就是Go的接口设计风格：小接口、非常灵活。

io.Copy

复制数据流，比如把一个我呢见复制到另一个文件：

func TestIOCopy(t *testing.T) {
src, err := os.Open("a.txt")
if err != nil {
t.Error(err)
return
}

defer func(file *os.File) {
err := src.Close()
if err != nil {
t.Error(err)
}
}(src)

dest, err := os.Create("b.txt")
if err != nil {
t.Error(err)
return
}

defer func(file *os.File) {
err := file.Close()
if err != nil {
t.Error(err)
}
}(dest)

n, err := io.Copy(dest, src)
if err != nil {
t.Error(err)
}

t.Log("copied bytes ", n)

}

使用场景：文件复制、HTTP 下载保存到文件、上传文件写入磁盘、把请求体转发给另一个服务等。

bufio.Scanner

按行读取文件，这是处理日志、CSV、文本文件时非常常用的写法：

func TestBufioScanner(t *testing.T) {
file, err := os.Open("info.log")
if err != nil {
t.Error(err)
return
}

defer func(file *os.File) {
err := file.Close()
if err != nil {
t.Error(err)
}
}(file)

scanner := bufio.NewScanner(file)

// Scanner默认单个token大小有限，如果读取超长行或者大日志等，需要调大buffer
// scanner.Buffer(make([]byte ,1024),1024*1024)

for scanner.Scan() {
line := scanner.Text()
t.Log(line)
}

if err := scanner.Err(); err != nil {
t.Error(err)
}
}

bufio会包装一个io.Reader或io.Writer，提供缓冲能力和更方便的文本I/O操作。

Scanner默认单个token大小有限。如果你读取超长行，可能需要调大buffer。

bufio.Writer

缓冲写入

func TestBufioWriter(t *testing.T) {
file, err := os.Create("bufio_writer.txt")
if err != nil {
t.Error(err)
return
}

defer func(file *os.File) {
err := file.Close()
if err != nil {
t.Error(err)
}
}(file)

writer := bufio.NewWriter(file)
for i := 0; i < 3; i++ {
_, err := writer.WriteString(fmt.Sprintf("line %d\n", i))
if err != nil {
t.Error(err)
return
}
}
// 注意，这里需要flush，否则不会落盘
if err := writer.Flush(); err != nil {
t.Error(err)
}
}

使用bufio.Writer后，数据可能还在缓冲区里，不调用Flush()可能不会真正写入文件。

一句话总结：

os负责具体的文件和操作系统交互，io提供通用I/O抽象，核心时io.Reader和io.Writer，bufio在Reader/Writer外层增加缓冲，适合按行读取和批量写入。小文件可以使用os.ReadFile，大文件或流式处理应该用os.Open配合bufio.Scanner、bufio.Reader或者io.Copy。

JSON 处理：encoding/json

Go标准库的encoding/json用于JSON编码和解码，也是Go对象与JSON字符串之间的转换。常见操作有：

json.Marshal               : Go struct/map -> JSON bytes
json.Unmarshal             : JSON bytes  -> Go struct/map
json.NewEncoder            : 把JSON写到io.Writer
json.NewDecoder            : 从io.Reader 读取 JSON

先定义一个user：

type User struct {
ID   int    `json:"id"`
Name string `json:"name"`
Age  int    `json:"age"`
}

json.Marshal

从struct/map 转JSON

func TestJsonMarsha1(t *testing.T) {
u := User{
ID:   1,
Name: "tom",
Age:  18,
}

data, err := json.Marshal(u)
if err != nil {
t.Error(err)
return
}
t.Log(string(data))

m := map[string]any{
"id":    1,
"age":   18,
"phone": 1323232,
"name":  "Jerry",
}

dataMap, err := json.Marshal(m)
if err != nil {
t.Error(err)
return
}
t.Log(string(dataMap))
}

输出：

1 2	{"id":1,"name":"tom","age":18} {"age":18,"id":1,"name":"Jerry","phone":1323232}

json.Unmarshal

func TestJsonUnmarshal(t *testing.T) {
input := []byte(`{"id":1,"name":"tom","age":18}`)
var u User
var m map[string]any

err := json.Unmarshal(input, &u)
if err != nil {
t.Error(err)
return
}
t.Logf("%+v\n", u)
    // 通常建议 err复用即可，因为本身就是一个临时变量。
err = json.Unmarshal(input, &m)
if err != nil {
t.Error(err)
return
}
t.Logf("%+v\n", m)
}

输出：

1 2	{ID:1 Name:tom Age:18} map[age:18 id:1 name:tom]

从上述例子可以看到，json.Unmarshal(input,&u)这里必须传递指针，因为要修改u的值。

JSON tag

type UserInfo struct {
ID   int    `json:"id"`
UserName string `json:"user_name"`
Password  int    `json:"-"`
    Email    string  `json:"email,omitempty"`
}

含义：

json:"id"               JSON字段名是id
json:"uer_name"         JSON字段名是user_name
json:"-"                忽略该字段
json:"email,omitempty"  空值时忽略

例如：

func TestJsonTag(t *testing.T) {
u := UserInfo{
ID:       1,
UserName: "tom",
Password: "123456",
}

s, err := json.Marshal(u)
if err != nil {
t.Error(err)
return
}
t.Log(string(s))
}

输出：

1	{"id":1,"user_name":"tom"}

注意：Go的JSON序列化只能处理导出字段，也就是大写开头的字段。

下面的这个就无法序列化成功。

type UserInfo1 struct {
id   int    `json:"id"`
name string `json:"user_name"`
}

func TestJsonTag1(t *testing.T) {
u := UserInfo1{
id:   1,
name: "tom",
}
s, err := json.Marshal(u)
if err != nil {
t.Error(err)
return
}
    // 输出 {}
t.Log(string(s))
}

Decoder/Encoder

适合HTTP和流式处理，例如在HTTP handler里，经常会这样写：

1 2	json.NewDecoder(r.Body).Decode(&req) json.NewEncoder(w).Encode(resp)

例如

type CreateUserRequest struct {
Name string `json:"name"`
Age  int    `json:"age"`
}

type CreateUserResponse struct {
ID   int    `json:"id"`
Name string `json:"name"`
}

func createUserHandler(w http.ResponseWriter, r *http.Request) {
var req CreateUserRequest
if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
http.Error(w, "invalid json", http.StatusBadRequest)
return
}
resp := CreateUserResponse{
ID:   1,
Name: req.Name,
}
w.Header().Set("Content-Type", "application/json")
if err := json.NewEncoder(w).Encode(resp); err != nil {
return
}

}

Encoder/Decoder的好处是可以直接对接io.Reader和io.Writer，不用先手动转换为[]byte。

DisallowUnknownFields

拒绝未知字段：默认情况下，Go会忽略JSON里的未知字段。

1	{“name”:"Tom","age":20,"unknown":"xxx"}

如果struct里没有unknown字段，默认不会报错。

如果需要严格校验：

1
2
3

decoder := json.NewDecoder(r.Body)
// 
decoder.DisallowUnknownFields()

在API开发里很有用，可以避免前端传错字段。

除了上述提到的小写无法序列化（非导出）和Unmarshal需要传递指针外，还有一个需要注意的就是数字会被解析为flaot64。

var m map[string]any
json.Unmarshal([]byte(`{"id":123}`),&m)
// float64
fmt.Printf("%T\n",m["id"])

如果需要精确处理数字，可以使用struct，或者使用Decoder.UseNumber()。

HTTP 服务：net/http

net/http是Go标准库里非常重要的包，它同时提供HTTP client和 HTTP server实现。

一个简单的HTTP服务

func helloHandler(w http.ResponseWriter, r *http.Request) {
_, err := fmt.Fprintln(w, "hello go")
if err != nil {
return
}
}

func TestNet(t *testing.T) {
http.HandleFunc("/hello", helloHandler)

err := http.ListenAndServe(":8080", nil)
if err != nil {
panic(err)
}
}

http.ResponseWriter和 *http.Request

handle的核心签名是：

1	func(w http.ResponseWriter,r * http.Request)

可以理解为：

w:用来写响应
r：表示当前请求

例如：

func userHandler(w http.ResponseWriter, r *http.Request) {
method := r.Method
path := r.URL.Path
query := r.URL.Query().Get("name")

fmt.Println(method, path, query)
}

// 在上一个例子中，添加如下：
http.HandleFunc("/user", userHandler)

然后再Goland中的rest-api.http的请求中执行如下：

1	GET http://localhost:8080/user?name=zhangsan

按Method区分请求

将userHandler方法修改为：

func userHandler(w http.ResponseWriter, r *http.Request) {
switch r.Method {
case http.MethodGet:
w.Header().Set("Content-Type", "application/json")
json.NewEncoder(w).Encode([]User{
{ID: 1, Name: "tom"},
})
case http.MethodPost:
var req User
if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
http.Error(w, "invaild json", http.StatusBadRequest)
return
}

req.ID = 100
w.Header().Set("Content-Type", "application/json")
w.WriteHeader(http.StatusCreated)
err := json.NewEncoder(w).Encode(req)
if err != nil {
return
}
default:
http.Error(w, "method not allowed", http.StatusMethodNotAllowed)
}
}

自定义http.Server

http.ListenAndSarver(":8080",nil)通常也只是用在demo阶段，实际工作中还是会显示的创建http.Server，配置超时时间。

func TestHttpServer(t *testing.T) {
mux := http.NewServeMux()
mux.HandleFunc("/health", func(w http.ResponseWriter, r *http.Request) {
_, err := w.Write([]byte("ok"))
if err != nil {
return
}
})

server := &http.Server{
Addr:         ":8080",
Handler:      mux,
ReadTimeout:  5 * time.Second,
WriteTimeout: 10 * time.Second,
IdleTimeout:  60 * time.Second,
}

log.Println("server start at :8080")

if err := server.ListenAndServe(); err != nil {
log.Fatal(err)
}
}

HTTP Client

HTTP客户端：

func TestHttpClient(t *testing.T) {
client := &http.Client{
Timeout: 5 * time.Second,
}

resp, err := client.Get("https://localhost:8080/health")
if err != nil {
fmt.Println("request failed: ", err)
return
}
// 关闭的模板代码
defer func(resp *http.Response) {
if err := (*resp).Body.Close(); err != nil {
fmt.Println("close response body failed: ", err)
}
}(resp)

body, err := io.ReadAll(resp.Body)
if err != nil {
fmt.Println("read body failed ", err)
}
fmt.Println("status: ", resp.StatusCode)
fmt.Println(string(body))
}

和读取文件一样（本质上也是IO流），HTTP响应体必须关闭，否则会造成连接泄露。

带Context的请求

日常开发，更推荐使用context控制超时和取消

func TestContext(t *testing.T) {
ctx, cancel := context.WithTimeout(context.Background(), 2*time.Second)
defer cancel()
req, err := http.NewRequestWithContext(ctx, http.MethodGet, "https://localhost:8080/health", nil)
if err != nil {
fmt.Println("new request failed ", err)
}
resp, err := http.DefaultClient.Do(req)
if err != nil {
fmt.Println("request failed : ", err)
}
defer func(resp *http.Response) {
err := resp.Body.Close()
if err != nil {
fmt.Println("close failed ")
return
}
}(resp)
data, _ := io.ReadAll(resp.Body)
fmt.Println(string(data))
}

用httptest测试HTTP handler

net/http/httptest是测试HTTP handler的标准工具。

func helloHandler1(w http.ResponseWriter, r *http.Request) {
w.WriteHeader(http.StatusOK)
_, err := w.Write([]byte("hello"))
if err != nil {
fmt.Println("resp error")
return
}
}

func TestHelloHandler1(t *testing.T) {
req := httptest.NewRequest(http.MethodGet, "/hello", nil)
rec := httptest.NewRecorder()

helloHandler1(rec, req)

if rec.Code != http.StatusOK {
t.Fatalf("expected status 200, got %d ", rec.Code)
}

if rec.Body.String() != "hello" {
t.Fatalf("unexpected body : %s ", rec.Body.String())
}
}

关于网络

net/http同时提供HTTP服务端和客户端。服务端核心是http.Handler，常见的方法签名是func(w http.ResponseWriter, r *http.Request)。 ResponseWriter 用来写响应，Request表示请求。通常编码时推荐使用自定义http.Server并且设置timeout。客户端请求后必须关闭resp.Body，并且推荐使用context控制超时和取消。

字符串处理：strings、strconv

strings用来处理字符串查找、切割、拼接、转换、裁剪等操作；strconv用于字符串和基础类型之间的转换。例如 string转换为int、int转string等。

strings.Contains

判断是否包含

func TestStringsContains(t *testing.T) {
s := "hello go"
t.Log(strings.Contains(s, "ll"))
t.Log(strings.Contains(s, "golang"))
}

strings.HasPrefix/strings.HasSuffix

前缀和后缀

func TestHasPrefix(t *testing.T) {
url := "https://www.google.com"
t.Log(strings.HasPrefix(url, "https"))
t.Log(strings.HasSuffix(url, ".com"))
}

strings.Split/strings.Join

func TestSplit(t *testing.T) {
s := "go,java,python,typescript"
parts := strings.Split(s, ",")
for _, part := range parts {
t.Log(part)
}
// []string  -> string
joined := strings.Join(parts, "|")
// go|java|python|typescript
t.Log(joined)
}

strings.TrimSpace

去掉首位空白

func TestTripSpace(t *testing.T) {
s := "   Hello  Go    "
//Hello  Go
t.Log(strings.TrimSpace(s))
}

strings.ReplaceAll

替换所有字符串

func TestReplaceALl(t *testing.T) {
s := "Hello Go"
t.Log(strings.ReplaceAll(s, "Go", "Golang"))
}

strings.Builder

拼接字符串，类似Java里的StringBuilder。

func TestBuilder(t *testing.T) {
var sb strings.Builder
for i := 0; i < 3; i++ {
sb.WriteString("GO")
sb.WriteString(" ")
}
t.Log(sb.String())
}

这玩意也是为了解决大量字符串拼接的问题。解决string += "xxx"的问题。

len(string)统计字节数

这个在第二天的只是中学习过，注意：它统计的是字节数，而不是字符数。

func TestLen(t *testing.T) {
s := "你好，Go"
for i, r := range s {
t.Log(i, string(r))
}
/**
  strings_test.go:55: 0 你
  strings_test.go:55: 3 好
  strings_test.go:55: 6 ，
  strings_test.go:55: 9 G
  strings_test.go:55: 10 o
*/

// 5  如何需要按字符数
t.Log(len([]rune(s)))

}

strconv.Atoi/Itoa

这个也是第二天的内容

func TestStrconv(t *testing.T) {
s := "123"
n, err := strconv.Atoi(s)
if err != nil {
t.Error("convert failed", err)
}
//  string: 123 ,convert int
t.Logf("string: %s ,convert %T", s, n)

num := 888
str := strconv.Itoa(num)
t.Logf("str type : %T, value : %s", str, str)
}

strconv.ParseInt/FormatInt

如果需要控制进制和位数，用ParseInt(ParseFloat、ParseBool、ParseComplex、ParseUint)

func TestParseInt(t *testing.T) {
s := "123"
n, err := strconv.ParseInt(s, 10, 64)
if err != nil {
t.Error("convert failed", err)
}

t.Logf("string: %s ,convert %T", s, n)

s1 := strconv.FormatInt(n, 10)
t.Logf("str type : %T, value : %s", s1, s1)
}

其中：123是输出的字符串，10： 十进制，64：int64

单元测试：testing 包

Go的测试不需要JUnit这种外部框架，标准库自带testing包，配合go test命令就可以完成测试。例如我大量的例子都是，其规则为：1、文件名，要以_test.go结尾，函数必须是func TestXxx(*testing.T)。

例如：math_test.go,创建一个加法代码:

1
2
3

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

测试代码：

func TestMath(t *testing.T) {
got := Add(1, 2)
want := 3

if got != want {
t.Fatalf("Add(1,2) = %d,want %d", got, want)
}
}

t.Error和t.Fatal的区别

t.Error/t.Errorf：报错但继续

t.Fatal/t.Fatalf：保存并停止当前测试

表驱动测试

日常开发中非常重要的写法：

func TestAdd(t *testing.T) {
tests := []struct {
name string
a    int
b    int
want int
}{
{name: "positive number", a: 1, b: 2, want: 3},
{name: "zero", a: 0, b: 5, want: 5},
{name: "negative number", a: -1, b: 1, want: 0},
}

for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
got := Add(tt.a, tt.b)
if got != tt.want {
t.Fatalf("Add(%d,%d) = %d,want %d", tt.a, tt.b, got, tt.want)
}
})
}
}

Go语言学习笔记（七）- 错误处理与包管理

2026-04-06T04:00:00.000Z

error 接口与 errors 包

Go语言的错误，不像Java/Python那样默认靠异常传播机制，而是一个普通返回值。Go内置的error类型本质上是一个接口。只要求实现一个方法Error() string；nil通常表示没有错误。

1
2
3

type error interface {
    Error() string
}

在Go代码里最常见的模板就是：

result,err := doSomething()
if err !=nil{
    return err
}

这种模式，就相当于Java的try/catch。

创建简单错误

errors.New(text)会创建一个只包含文本信息的error；每次调用errors.New都返回一个不同的error的值，即使文本相同。

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

func TestErrorNew(t *testing.T) {
v, err := divide(4, 2)
if err != nil {
t.Error(err)
return
}
fmt.Println(v)
}

日常开发中，errors.New适合创建简单、固定、无须携带上下文的错误。

创建带有格式化信息的错误

如果错误信息需要拼接变量，那就需要使用fmt.Errorf。

func findUser(id int) error {
return fmt.Errorf("user %d not found", id)
}

func TestErrorFindUser(t *testing.T) {
err := findUser(1)
if err != nil {
t.Error(err)
}
}

错误包装

实际开发中，不止返回底层错误，还需要加上下文。

1	return fmt.Errorf("read config %s failed %w",path,err)

%w的意思就是：包装原始错误。使用%w且参数时error时，返回的错误会实现unwrap，从而可以被errors.Is和errors.As检查。

func readConfig(path string) error {
_, err := os.Open(path)
if err != nil {
        // 注意这里一定是%w，千万不要写成%v,%v 只是把错误转成字符串，原始错误链会丢失。
return fmt.Errorf("read config %s failed : %w", path, err)
}
return nil
}

func TestErrorReadConfig(t *testing.T) {
err := readConfig("config.yaml")
if err != nil {
fmt.Println(err)
if errors.Is(err, os.ErrNotExist) {
fmt.Println("config file does not exist")
}
}
}

// 输出
// read config config.yaml failed : open config.yaml: The system cannot find the file specified.
// config file does not exist

%v和%w有啥区别呢？

%v：只格式化错误文本。
%w：包装error，保留错误链，可以使用errors.Is和errors.As判断。

errors.Is 判断错误链里是否包含某个错误

errors.Is(err,target)用来判断err或者它包装的底层错误里，是否包含指定错误。通常也是推荐使用errors.Is来检查错误链，而不是==。

// sentinel error
var ErrUserNotFound = errors.New("user not found")

func getUser(id int) error {
return fmt.Errorf("query user %d failed：%w", id, ErrUserNotFound)
}

func TestErrorGetUser(t *testing.T) {
err := getUser(1)
if errors.Is(err, ErrUserNotFound) {
t.Log("handle user not found")
} else if err != nil {
t.Error(err)
}
}

如果错误可能被包装过，不应该使用err == ErrUserNotFound，而应该使用errors.Is(err,ErrUserNotFound)。

errors.As:提取某种具体错误类型

errors.As用来从错误链中找出某种具体类型的错误。errors.As会检查整条错误链。

func parseAge(s string) error {
_, err := strconv.Atoi(s)
if err != nil {
return fmt.Errorf("parse age failed: %w", err)
}
return nil
}

func TestErrorParseAge(t *testing.T) {
err := parseAge("age")
var numErr *strconv.NumError
    // errors.As需要把找到的错误复制到变量里
if errors.As(err, &numErr) {
// invalid number : age
fmt.Println("invalid number :", numErr.Num)
// function : Atoi
fmt.Println("function :", numErr.Func)
}
}

那么errors.Is和errors.As有啥区别呢？

errors.Is : 判断是不是某个目标错误，常用于sentinel error
errors.As：判断能不能转换成某个错误类型，并提取出来。

errors.Unwrap: 手动拆开错误链

errors.Unwrap(err)会调用错误上的Unwrap() error方法，如果没有，就返回nil。

func TestErrorsUnwrap(t *testing.T) {
base := errors.New("base error")
wrapped := fmt.Errorf("service failed: %w", base)
    // service failed: base error
fmt.Println(wrapped)
inner := errors.Unwrap(wrapped)
    // base error
fmt.Println(inner)
}

通常来说，更推荐使用errors.Is和errors.As。

1 2	errors.Is(err, target) errors.As(err, &target)

errors.Join 合并多个错误

errors.Join可以把多个error合并成一个error：Join会丢弃nil，如果全部都是nil，则返回nil，非nil的Join结果可以通过errors.Is和errors.As检查。

例如：批量处理时，不想遇到第一个错误就返回，而是收集所有错误。

func validateName(name string) error {
if name == "" {
return errors.New("name is empty")
}
return nil
}

func validateAge(age int) error {
if age <= 0 {
return errors.New("age must be greater than zero")
}
return nil
}

func validateUser(name string, age int) error {
var errs []error
if err := validateName(name); err != nil {
errs = append(errs, err)
}
if err := validateAge(age); err != nil {
errs = append(errs, err)
}
return errors.Join(errs...)
}

func TestErrorsJoin(t *testing.T) {
err := validateUser("", -1)
if err != nil {
//    error_test.go:131: name is empty
//    age must be greater than zero
t.Log(err)
}
}

适合场景：

批量校验
批量删除
批量导入
多个资源清理失败

Go的error是一个内置接口，只有Error() string方法。Go通过多返回值显示返回错误，通常使用if nil != nil处理。简单错误可以用errors.New，带上下文的错误可以用fmt.Errorf。如果要保留底层错误链，应该使用%w包装，再通过errors.Is判断sentinel Error,通过errors.As提取具体错误类型。

自定义错误类型

自定义错误类型的核心是：只要事先Error() string方法，就实现了error接口。

对于Java来说

1	class MyException extends Exception

如果是Go，则只需要：

1
2
3

func (e MyError) Error() string{
    return "xxxxx"
}

一个简单的例子：

type UserNotFound struct {
UserID int
}

func (e UserNotFound) Error() string {
return fmt.Sprintf("user %d not found", e.UserID)
}

func findUserByUserId(id int) error {
return UserNotFound{UserID: id}
}

func TestError1(t *testing.T) {
err := findUserByUserId(1)
if err != nil {
t.Log(err)
}
}

自定义错误类型适合如下场景：

错误需要携带结构化字段
调用方需要根据字段做判断
需要保留底层错误
业务系统有错误码
API层需要把内部错误映射为HTTP状态码

例如：把业务是错误转为HTTP响应

type AppError struct {
Code       string
Message    string
HTTPStatus int
}

func (e *AppError) Error() string {
return e.Code + " : " + e.Message
}

var ErrUserNotFound2 = &AppError{
Code:       "USER_NOT_FOUND",
Message:    "user not found",
HTTPStatus: http.StatusNotFound,
}

func getUser1(id int) error {
if id == 0 {
return ErrUserNotFound2
}
return nil
}

func handle() {
err := getUser1(0)
if err == nil {
return
}

var appErr *AppError
if errors.As(err, &appErr) {
fmt.Println("status: ", appErr.HTTPStatus)
fmt.Println("code: ", appErr.Code)
return
}

fmt.Println("status: ", http.StatusInternalServerError)
}

在Go中，自定义错误类型只要实现Error() string就实现了error接口。如果错误需要携带结构化信息，比如错误码、资源ID、路径、HTTP状态码，就适合使用自定义错误类型。如果自定义错误类内部包装了底层错误，应实现Unwrap()，这样调用方仍然可以使用errors.Is和error.As检查错误链。

go mod

Go的现代项目基本都是用module。一个module有go.mod文件定义，go.mod会描述当前模块路径、Go版本和依赖模块等信息。相当于Java的pom.xml/build.gradle。

go mod init

初始化模块，go mod init会在当前目录初始化并写入新的go.mod文件。

1
2
3

mkdir learn-go
cd learn-go
go mod init dev.net.cn/learn-go

此时就会在learn-go目录下生成一个go.mod文件，内容为：

1
2
3

module dev.net.cn/learn-go

go 1.26.3

其中module dev.net.cn/learn-go就是模块路径，真实目录通常写仓库地址：

github.com/xxx/xxx
// 例如本站dev.net.cn/learn-go 
// 和Java不同的是，这里的域名不需要倒着写，因为Go 的依赖管理工具会根据模块路径去真实的服务器拉取代码
company.com/xxx/xxx

如果没有自己的域名，那就可以使用github仓库来命名（这种比较推荐），很多Go的模块都是如此。

1 2	# 例如我想做个gin-json的模块，就可以使用如下方式，然后在github创建仓库名为gin-json即可。 go mod init github.com/idevly/gin-json

尽可能不要随便写模块名：

1	go mod init test

因为后续包导入路径会基于module path。

初始体验，个人觉得不如maven。

module、package、repository的关系

Go程序由package组织；一个package是同一目录下共同编译的一组GO源文件。一个repository可以包含一个或多个module，而一个module是一起发布的一组相关package。通过下面一个结构就能理解：

1
2
3

repository 仓库
  └── module 模块，go.mod 所在目录
        └── package 包，一个目录通常一个 package

例如：

gin-json/
  go.mod                 module dev.net.cn/gin-json
  main.go                package main
  internal/
    service/
      todo_service.go    package service
    repository/
      todo_repo.go       package repository

如果要导入路径：

1	import "dev.net.cn/gin-json/internal/service"

go.sum

添加完以来后，Go会生成go.sum，里面记录依赖模块的校验和，用来验证下载的模块文件完整性。

1	go get github.com/google/uuid

在代码里使用：

package day7

import (
"testing"

"github.com/google/uuid"
)

func TestGoMod(t *testing.T) {
t.Log(uuid.NewString())
}

此时，项目根目录下面会存在两个文件go.mod和go.sum，这两个文件都需要提交到git仓库。

go mod tidy

整理依赖：go mod tidy会让go.mod和源码实际使用的依赖保持一致。他会添加缺失的依赖，删除不再提供相关包的依赖，并更新go.sum。

go get github.com/gin-gonic/gin
# 如果代码里没有任何使用gin的地方，但是它存在在go.mod中，那么执行此命令就会删掉这个模块，并且更新go.sum
go mod tidy
# 反之，如果代码里使用了某个模块，但没有下载这个模块，执行go mod tidy也会自动下载。

indirect依赖

在go.mod里可以看到

1	require github.com/some/lib v1.2.3 // indirect

这个意思就是：当前项目代码没有直接import它，但它是你得直接依赖的依赖。//indirect表示这个目录没有提供主模块中包直接导入的package。类比就是Java第三方库依赖的其他依赖。

这个不需要自己维护，所以无需上心，知道是啥意思就行。

go mod vendor

把依赖复制到vendor目录：go mod vendor会在主模块根目录创建vendor目录，复制构建和测试当前模块所需的依赖包，他会生成vendor/modules.txt，记录依赖包和版本。

go mod vendor


d----          2026/6/3     10:21                  day7
d----          2026/6/3     10:33                  vendor
-a---          2026/6/3     10:27             65   go.mod
-a---          2026/6/3     10:27            163   go.sum
# vendor里面就是如下结构
 D:\GolandProjects\hellogo\vendor\github.com\google\uuid

vendor/modules.txt内容为：

1
2
3

# github.com/google/uuid v1.6.0
## explicit
github.com/google/uuid

然后使用vendor构建：

# 显示声明
go build -mod=vendor ./...
go test -mod=vendor ./...
# go 1.14以后 默认即可，它会自动使用vendor
go build ./...
go test ./...

需要使用vendor的场景，基本上就是如下：

内网环境，不能访问外网（to G）
构建环境要求所有依赖在仓库里
对供应链安全又强约束
老项目
希望构建时不访问网络。

记得以前在生产使用jenkins构建部署前端项目时，直接将npm的node_modules上传到服务器上，Maven也是要将.m2仓库上传到指定服务器上。就这意思~~

replace 本地调试依赖

如果有两个项目

1 2	user-service common-lib

user-service/go.mod：

module dev.net.cn/user-service
require dev.net.cn/common-lib v1.0.0

replace dev.net.cn/common-lib => ./common-lib

这样本地开发时，user-service就会使用本地的common-lib。

注意，提交代码的时候，replace是否需要提交，自己要特别做一下判断。理论上都不应该提交。

包的组织与可见性（大小写）

对于Java来说，Java包往往都比较深：

1	src/main/java/cn/net/dev/user-cms/user/service/UserService.java

而Go更偏向：

1	internal/service/user.go

Go的基本单位是package，一个package是同一个目录中，一起编译的一组Go源文件,同一个package的不同文件可以互相访问不辞定义的函数、类型、变量和常量。

还有一个特别要注意的：

同一个文件夹（package）下，所有源文件必须属于同一个 package（包）

例如在service这个包或者是目录下面，所有的.go源码中，package都必须是service，不能有些是package service有些是package main。当然，_test.go包是个例外。

所以，这里也是建议，往后的go项目结构应当是如下：

my_project/
  ├── go.mod
  ├── cmd/
  │   └── my_app/
  │       └── main.go    // package main（单独的目录）
  └── internal/ (或直接在根目录)
      └── service/
          └── todo_service.go // package service

如果一个目录要编译成可执行程序，包名必须是package main。并且通常有func main(){}方法。例如：

my-api/
  cmd/
    server/
      main.go

main.go

package main

import "fmt"

func main(){
    fmt.Println("Hello World")
}

运行：

1	go run ./cmd/server

正如上面提到的，通常建议把入口放在cmd目录下(尤其是仓库中有多个命令时)：

1
2
3

cmd/server/main.go
cmd/migrate/main.go
cmd/worker/main.go

大写导出，小写私有

这是Go可见性的核心。

Go规范规定：一个标识符如果首字母是Unicode大写字母，并且它声明在package block中，或者是字段名/方法名，那么他就是exported；其他标识符都不是exported。

通俗讲就是

大写开头，包外可访问
小写开头，只能在当前package内可访问。

例如：

package user

type User struct {
// 大写
ID   int
Name string
// 小写
password string
}

// 大写
func NewUser(name string) User {
return User{
ID:       1,
Name:     name,
password: "123456",
}
}

// 小写
func validateName(name string) bool {
return name != ""
}

其他包可以访问：

user.User
user.NewUser
u.ID
u.Name

但不能访问

1 2	u.password user.validateName

struct字段大小写也影响JSON

type User struct {
// 大写
ID   int  `json:"id"`
Name string `json:"name"`
// 小写 结构体字段 'password' 具有 'json' 标记，但未被导出 
password string `json:"password"`
}

虽然有了json标记，但小谢字段password对encoding/json也是不可导出的，外部包不能通过反射正常访问它，所以不会被正常序列化。当然，将他改成大写就可以了，但如果不想将敏感字段进行序列化，最好是不要将其放入response struct

type UserResponse struct {
ID   int  `json:"id"`
Name string `json:"name"`    
}

应该和Java差不多，Go也会分model、DTO之类的分层。

包名应该短小且不重复

Go包名一般短小、全小写

例如：

package user
package service
package repository
package dto
package http

不推荐

1
2
3

package userService
package userservice
package user_service

Go常见风格是：

user.NewService()
// 反例 userservice.NewUserService()
repo.New()
config.Load()

internal目录：限制包导入范围

internal是Go非常重要的工程化机制，位于internal目录或者其子目录下的代码，只能被internal父目录树内的代码导入。

todo-api/
  go.mod
  internal/
    service/
      todo_service.go
  cmd/
    server/
      main.go

cmd/server/main.go可以导入

1	import "dev.net.cn/todo-api/internal/service"

但另一个外部项目不能导入

1 2	// use of internal package not allowed // import "dev.net.cn/todo-api/internal/service"

日常建议：

internal/ 放项目内部实现
pkg/ 放希望别人import的公共库
cmd/ 放可执行程序入口

例如：

todo-api/
  go.mod
  cmd/
    server/
      main.go
  internal/
    handler/
      todo_handler.go
    service/
      todo_service.go
    repository/
      todo_repository.go
    model/
      todo.go
  pkg/
    response/
      response.go

含义：

cmd/server：程序入口
internal/handler：HTTP handler
internal/service：业务逻辑
internal/repository：数据库访问
internal/model：内部模型
pkg/response：可复用公共包

但也要注意，Go 不是 Java，不需要为了“架构感”建很多包。

Go语言学习笔记（六）- 并发编程

2026-04-05T04:00:00.000Z

今天开始学习Go语言的重要特性，Goroutine。

goroutine

Goroutine，通常称之为协程，区别于Java的线程，它是由Go runtime调度，启动成本很低，初始栈很小，并且可以按需增长。多个goroutine在同一个进程地址空间内并发执行。

先看看Java的线程：

1	new Thread(() -> {System.out.println("Hello Java");}).start();

在看看看Go的goroutine：

1
2
3

go func() {
    fmt.Println("Hello Go")
}()

启动普通函数

import (
"fmt"
"sync"
"testing"
)

func PrintName(name string) {
fmt.Println(name)
}

func TestGoroutine(t *testing.T) {
    // wg用来等待程序完成
var wg sync.WaitGroup
    // 计数加1，表示要等待1个goroutine,注意，这里暂时不可以是2，因为其中一个没有执行wa.Done()，后续在解释。
wg.Add(1)
//如果需要 defer wg.Done()，通常会包一层匿名函数。
go func() {
        // 在函数退出时，调用Done来通知main函数工作已经完成
defer wg.Done()
PrintName("hello")
}()
// 也可以这样直接调用
go PrintName("Hello Goroutine")

fmt.Println("Waiting To Finish")
wg.Wait()
fmt.Println("Terminating Program")
}

如果你需要 defer wg.Done()，通常会包一层匿名函数。

此时程序会打印如下：

=== RUN   TestGoroutine
Waiting To Finish
Hello Goroutine
hello
Terminating Program
--- PASS: TestGoroutine (0.00s)
PASS

启动匿名函数

1
2
3

go func(){
    fmt.Println("running in background")
}()

特别注意，后面的()别忘了，这个括号表示立即执行这个匿名函数，只是他会在新的goroutine中执行。

主goroutine退出，程序就结束

这是一个特别需要注意的地方。下面通过一个错误示例来观察：

func TestGoroutine2(t *testing.T) {
go func() {
fmt.Println("hello")
}()
fmt.Println("main done")
}

这个例子，最后打印的结果有三种情况：

# 情况一，两个打印语句都执行
main done
hello

# 情况二，只打印 main done
main done

# 情况三，极低概率，会先打印hello
hello
main done

和Java的线程类似，谁先执行（或者会不会执行），完全看CPU如何调度（如果是主goroutine先执行，那么程序就会退出，其他的goroutine不一定会执行），这是不可靠的。为了避免这个问题，请使用如下方式：

func TestGoroutine3(t *testing.T) {
var wg sync.WaitGroup
wg.Add(1)
go func() {
defer wg.Done()
fmt.Println("Hello")
}()
wg.Wait()
}

WaitGroup

sync.WaitGroup是日常开发最常用的goroutine等待工具。它本质上是一个计数器：Add增加任务数，Done表示任务完成，Wait阻塞等待计数归零。言简意赅就是用于等待一组goroutine或任务完成得计数号量。

有些像CountDownLatch?

上面的两个例子都已经有过介绍，其主要语法（其实就是模板代码）就是

var wg sync.WaitGroup
// 增加一个任务数
wg.Add(1)
go func(){
    // 任务完成后，计数器减少1
    defer wg.Done()
}()
// 等计数器等于0，则退出，否则会阻塞。最开始那个例子就是因为第二个没有执行Done，导致计数器不是0
wg.Wait()

这里也有个知识点需要说明，wg.Add(1)需要放在goroutine外面。下面先看要给错误的示例：

func TestGoroutine4(t *testing.T) {
var wg sync.WaitGroup
for i := 0; i < 3; i++ {
go func() {
wg.Add(1)
defer wg.Done()
fmt.Println(i)
}()
}
wg.Wait()
}

这个例子得问题：wg.Wait()可能再wg.Add(1)执行前就开始等待，甚至直接结束。

需要将其修改为如下方式：

func TestGoroutine5(t *testing.T) {
var wg sync.WaitGroup
for i := 0; i < 3; i++ {
// 在 go 关键字之前执行 Add，确保主协程去 Wait 时，计数器一定大于 0
wg.Add(1)
go func(i int) {
defer wg.Done()
fmt.Println(i)
}(i)
}
// 此时计数器是 3，主协程会老老实实在这里死等，直到 3 次 Done 都报到
wg.Wait()
}

使用 sync.WaitGroup 的黄金法则是：必须在启动子协程之前（在主协程里）就把账记好（Add）,Done必须在go之中。

上述例子还可以修改为：

func TestGoroutine6(t *testing.T) {
var wg sync.WaitGroup
// 如果确定知道要执行三次，也可以再循环外一次性把计数器设置好
wg.Add(3)
for i := 0; i < 3; i++ {
go func(i int) {
defer wg.Done()
fmt.Println(i)
}(i)
}
wg.Wait()
}

对于面试来说，只需要一句：

Add 必须在启动 goroutine 之前调用，否则主 goroutine 可能先执行到 Wait，造成等待计数不准确，甚至提前返回。

由于我是基于Go 1.26学习，这个版本对WaitGroup.go有所优化，可以直接使用Go方法，它可以直接启动任务并等待。

func TestGoroutine7(t *testing.T) {
var wg sync.WaitGroup
// 直接启动任务并等待
wg.Go(func() {
fmt.Println("task 1")
})
// 直接启动任务并等待
wg.Go(func() {
fmt.Println("task 2")
})

wg.Wait()
}

从代码层面来看，使用wg.Go()肯定要优于传统写法得，如果使用传统写法，你需要特别注意：

必须时刻小心Add()得位置，不能写在go func内部
必须保证Add数量与Done的数量绝对相等
任何地方漏写了defer wg.Done()，或者因为panic中途崩了导致wa.Done()没执行上，程序会直接死锁。

传统写法，用于面试或者维护古老项目使用。新项目建议使用wg.Go(func(){})

这里有个小坑：WaitGroup可以复用，但必须确保上一轮彻底结束后在进入下一轮，复杂场景下不如重新定义新的WaitGroup。

channel

goroutine不能像普通函数那样直接拿返回值。

1 2	// 不支持如下语法 //result := go calculate()

此时就需要通过channel接受结果。

func calculate() int {
return 100
}

func TestGoroutine8(t *testing.T) {
resultChannel := make(chan int)

go func() {
resultChannel <- calculate()
}()
result := <-resultChannel
t.Logf("Result from goroutine: %d", result)
}

或者也可以通过WaitGroup + 共享变量实现：

func TestGoroutine9(t *testing.T) {
var wg sync.WaitGroup
var result int

wg.Add(1)
go func() {
defer wg.Done()
result = 100
}()
wg.Wait()
t.Logf("Result from goroutine: %d", result)
}

虽然也能拿到返回值，但如果有多个goroutine同时写共享变量，就得考虑锁或者channel

Go 有一句非常经典的思想：不要通过共享内存通信，而要通过通信共享内存。

Go 官方 blog 也强调，Go 鼓励通过 channel 在 goroutine 之间传递数据引用，避免多个 goroutine 同时直接操作同一份数据。

对于Java程序员来说，channel可以类比为：

Blocking Queue
线程间消息传递
生产者-消费者模式

基础发送和接收

func TestChannel(t *testing.T) {
// 创建一个string类型的channel
    ch := make(chan string)
go func() {
        // 表示发送
ch <- "hello"
}()
    // 表示接收
msg := <-ch
t.Log(msg)
}

无缓冲channel

1	ch := make(chan int)

无缓冲channel发送时，如果没有接收者，发送方会阻塞。，总结其特点就是：

发送方发送时，如果没有接收方准备好，会阻塞
接收方接收时，如果没有发送方准备好，也会阻塞

所以，它不仅能传数据，还能用来做同步。

func TestChannel2(t *testing.T) {
ch := make(chan int)

go func() {
fmt.Println("sending...")
ch <- 1
fmt.Println("sent")
}()
v := <-ch
t.Logf("received,%d", v)
}

无缓冲channel很像Java里的SynchronousQueue，发送和接收必须“碰头”。

有缓冲channel

1 2	// 有缓冲channel 创建方式 ch := make(chan int,2)

例如：

func TestChannel3(t *testing.T) {
    // 创建一个容量为2的缓冲channel
ch := make(chan int, 2)
    // 前两次发送不会阻塞，第三次发送如果没人接收，就会阻塞
ch <- 1
ch <- 2
t.Log(<-ch)
t.Log(<-ch)
}

有缓冲channel在缓冲区没满前，发送不会阻塞。相当于Java的BlockingQueue。但Go的channel语义更轻，更适合配合select。

1 2	// ch := make(chan int, 2) new ArrayBlockingQueue<>(2)

关闭channel

关闭channel，表示：以后不会再发送新数据了。

close(ch)

例如：

func TestChannel4(t *testing.T) {
ch := make(chan int)

go func() {
defer close(ch)
for i := 0; i < 3; i++ {
ch <- i
}
}()
// 遍历channel
for v := range ch {
t.Log(v)
}
}

for v := range ch : 会一直读取channel，直到channel被关闭。

如果对已经关闭的channel进行读取和写入，会发生啥呢？

func TestChannel5(t *testing.T) {
ch := make(chan int, 1)
ch <- 100
close(ch)
v1, ok1 := <-ch
// v1 = 100, ok1 = true
t.Logf("v1 = %d, ok1 = %v", v1, ok1)
v2, ok2 := <-ch
// v2 = 0, ok2 = false
t.Logf("v2 = %d, ok2 = %v", v2, ok2)
    
    // panic: send on closed channel [recovered, repanicked]
// ch <- 200
// t.Log(ch)
    
    // panic: close of closed channel [recovered, repanicked]
// close(ch)
}

读取已关闭的channel，代码不会报错，读取完后返回值为channel类型的零值，状态码为false，表示channel已关闭并且没有剩余数据。
- 如果channel里还有值，先取值，然后ok == true
- 如果channel已关闭且没有剩余值，则返回零值，ok == false
写入已关闭的channel，会panic。
关闭已关闭的channel。会panic。

所以Go官方也是明确提醒，向已关闭的channel发送数据会panic，因此通常需要确保所有发送都完成后再关闭channel。

那么，到底谁来关闭channel呢？

日常经验：通常有发送方关闭channel，不由接收方关闭。

例如：

// 单向 Channel
// chan <- int 只发送
func producer(ch chan<- int) {
defer close(ch)

for i := 1; i <= 3; i++ {
ch <- i
}
}
// <- chan int 只接收
func consumer(ch <-chan int) {
for v := range ch {
fmt.Println(v)
}
}

func TestChannel6(t *testing.T) {
ch := make(chan int)
go producer(ch)
consumer(ch)
}

这种方式挺有有，可以让函数签名更清晰，减少误用。

select

select类似Java里同时监听多个阻塞队列，但Go语法更直接

基础用法

func TestSelect(t *testing.T) {
ch1 := make(chan string)
ch2 := make(chan string)

go func() {
time.Sleep(1 * time.Second)
ch1 <- "from ch1"
}()

go func() {
time.Sleep(2 * time.Second)
ch2 <- "from ch2"
}()

select {
case msg := <-ch1:
t.Log("received", msg)
case msg := <-ch2:
t.Log("received", msg)
}
}

哪个channel先准备好，就执行哪个case。看着就像是switch。

select + timeout

这是日常开发的高频场景

func TestSelectTimeout(t *testing.T) {
ch := make(chan string)
go func() {
time.Sleep(2 * time.Second)
ch <- "result"
}()
select {
case msg := <-ch:
t.Log("received", msg)
case <-time.After(1 * time.Second):
t.Log("timeout")
}
}

可以类比于Java中的

Future.get(timeout,unit)
一些异步框架里的超市等待

select + default 非阻塞操作

func TestSelectDefault(t *testing.T) {
ch := make(chan int)

select {
case v := <-ch:
fmt.Println(v)
default:
fmt.Println("default")
}
}

如果没有任何case就绪
立即执行default
不阻塞（如果没有default，在ch没有数据时，会阻塞等待）

如果channel没有准备好，就执行default。注意：default用不好会造成忙轮询，例如下面这个错误的例子：

for {
    select {
    case v:= <- ch:
        fmt.Println(v)
    default:
        // 空转，占用CPU
    }
}

退出信号

for {
    select {
    case msg := <- ch:
        fmt.Println("msg ",msg)
    case <- done:
        fmt.Println("exit")
        return
    }
}

这种方式通常用于：

worker停止
后台协程退出
优雅关闭

如果多个case同时可执行的时候，Go会随机选择一个执行，它并不是书写顺序优先，不依赖顺序。

空select

select{}

这种一般会永久阻塞，没啥意义。

context

context.Context 用于在API边界之间传递取消信号、超时时间、deadline和请求级别的值，服务端收到请求后应创建Context，向下游调用时继续传递Context

对于Java来说，大概可以这么理解：

1	context = CancellationToken + time + RequestScope

用context取消goroutine

func worker(ctx context.Context) {
for {
select {
case <-ctx.Done():
fmt.Println("worker stopped:", ctx.Err())
return
default:
fmt.Println("worker running...")
time.Sleep(500 * time.Millisecond)
}
}
}

func TestContext(t *testing.T) {
ctx, cancel := context.WithCancel(context.Background())

go worker(ctx)

time.Sleep(2 * time.Second)
cancel()

time.Sleep(1 * time.Second)
}

打印如下：

=== RUN   TestContext
worker running...
worker running...
worker running...
worker running...
worker stopped: context canceled
--- PASS: TestContext (3.00s)
PASS

context.WithTimeout

func query(ctx context.Context) error {
select {
case <-time.After(2 * time.Second):
fmt.Println("query done")
return nil
case <-ctx.Done():
return ctx.Err()
}
}

func TestContextWithTimeout(t *testing.T) {
ctx, cancel := context.WithTimeout(context.Background(), 1*time.Second)
defer cancel()

if err := query(ctx); err != nil {
fmt.Println("query failed:", err)
}

// query failed: context deadline exceeded
}

日常开发里，HTTP 请求、数据库查询、RPC 调用都应该优先支持 context。

Mutex

Mutex实际上就是Go语言中的互斥锁。对于Java来说，它相当于synchronized和ReentrantLock的最基础互斥能力。

1	var mu sync.Mutex

虽然Go鼓励使用channel通信，但也不能完全不用锁。sync.Mutex和channel都是重要的同步手段，具体使用哪个看场景：

需要保护共享状态：优先Mutex
需要传递任务/结果/事件：优先channel

和学习Java的synchronized一样，先来一个没有锁的例子：

func TestMutex(t *testing.T) {
var wg sync.WaitGroup
count := 0

for i := 0; i < 1000; i++ {
wg.Add(1)
go func() {
defer wg.Done()
count++
}()
}
wg.Wait()
// 多次运行，每次结果都不同.
fmt.Println("count =", count)
}

出现这个原因其实和Java多线程一样，多个goroutine同时修改count，会产生data race（数据竞争）。

此时就可以使用锁Mutex来修复这个问题：

func TestMutex1(t *testing.T) {
var wg sync.WaitGroup
var mu sync.Mutex
count := 0

for i := 0; i < 1000; i++ {
wg.Add(1)
go func() {
defer wg.Done()
mu.Lock()
count++
mu.Unlock()
}()
}
wg.Wait()
// 1000
fmt.Println("count =", count)
}

当然，学习了defer那就有更安全的写法：

1
2
3

mu.Lock()
defer mu.Unlock()
count++

defer释放锁

常见写法

1
2
3

mu.Lock()

defer mu.Unlock()

优点：

避免中途return，导致忘记解锁

缺点：

在极高频短路径里，defer有一点点开销
但绝大多数业务代码优先考虑正确性和可维护性

RWmutex

语法：

1	var mu sync.RWMutex

RLock(): 读锁
Lock() 写锁

这种类型的锁非常适合读多写少，除此之外，使用Mutex即可。

对于锁，各大语言的坑应该差不多，需要特别注意以下几点：

忘记解锁：会导致死锁或者后续goroutine永久阻塞。
重复加锁顺序不一致：多个锁嵌套时，如果不同goroutine获取锁顺序不一致，容易死锁。
锁住范围过大

1
2
3

mu.Lock()
doSometingSlow()
mu.Unlock()

如果临界区里包含慢操作，会严重影响并发性能，应该尽量：

缩小加锁范围
只保护共享数据本身

Once

sync.Once用来保证某段代码只执行一次。

1	var once sync.Once

下面是一个示例：

func TestOnce(t *testing.T) {
var once sync.Once
var wg sync.WaitGroup

for i := 0; i < 5; i++ {
wg.Add(1)
go func() {
defer wg.Done()
once.Do(func() {
fmt.Println("hello once")
})
}()
}

wg.Wait()
}

无论多少 goroutine 调用，里面那段逻辑都只会执行一次。从这个名字就能看出来，应该可以用在单例模式，除此之外还支持如下场景：

配置加载一次
连接池初始化
懒加载共享资源

使用once.Do需要注意的是，一旦Do里面的函数panic，也算调用过，后续不会再重试。所以有那种可能出现失败重试的逻辑，不要使用这个特性。

Goroutine泄露

一个goroutine被永久阻塞，无法退出，这个就叫goroutine leak。

例如下面这个例子：

// fatal error: all goroutines are asleep - deadlock!
// goroutine 1 [chan receive]:
func TestGoroutineLeak(t *testing.T) {
ch := make(chan int)
go func() {
        // 无人接收，永远阻塞
ch <- 1
}()

select {}
}

此时，可以利用context来解决：

func send(ctx context.Context, ch chan<- int) {
select {
case ch <- 1:
fmt.Println("sent...")
case <-ctx.Done():
fmt.Println("cancelled...")
return
}
}

func TestGoroutineLeakContext(t *testing.T) {
ctx, cancel := context.WithTimeout(context.Background(), 1*time.Second)
defer cancel()
ch := make(chan int)
go send(ctx, ch)
time.Sleep(2 * time.Second)
}

即使没人接收，goroutine也会因为context超市而退出。

Worker Pool

学习并发，那就一定会涉及到这个问题，对于Java来说，可以使用ThreadPool来处理，对于Go，也可以实现类似的效果：

func workerPool(id int, jobs <-chan int, wg *sync.WaitGroup) {
defer wg.Done()

for job := range jobs {
fmt.Printf("worker %d processing job %d\n", id, job)
time.Sleep(500 * time.Millisecond)
}
}

func TestGoroutineWorkerPool(t *testing.T) {
// 最多3个worker同时处理任务
    const workerCount = 3
const jobCount = 10

jobs := make(chan int)
var wg sync.WaitGroup

for i := 1; i <= workerCount; i++ {
wg.Add(1)
go workerPool(i, jobs, &wg)
}

for j := 1; j <= jobCount; j++ {
jobs <- j
}

close(jobs)
wg.Wait()
fmt.Println("all jobs done")

}

panic在goroutine中不会被其他goroutine recover

下面看个例子：

func TestGoroutinePanic(t *testing.T) {
defer func() {
if r := recover(); r != nil {
fmt.Println("recover:", r)
}
}()

go func() {
panic("panic")
}()

select {}
}

这里的recover捕获不到另一个goroutine里面的panic。

recover只能捕获同一个goroutine调用栈上的panic，不能跨goroutine捕获。

Go语言学习笔记（五）- 接口与类型系统

2026-04-04T04:00:00.000Z

接口

在Go语言中，接口的设计是一个典型的“鸭子类型”(Duck Typing)。如果一个结构体拥有了某个接口定义的所有方法，那么它就实现了这个接口。

先看看Java的接口（显示实现接口）

interface Animal{
    void say();
}

class Dog implements Animal {
    public void say(){
        System.out.println("wang!")
    }
}

类必须通过implements关键字明确申明自己实现了某个接口。

再看看Go的接口

type Animal interface {
    Say();
}

type Dog struct{}

func (d Dog) Say(){
    fmt.Println("wang!")
}

Go是隐式实现接口，只要一个类型实现了接口需求的所有方法，就自动认为他实现了该接口。

func MakeSound(a Animal) {
a.Say()
}

func TestInterface1(t *testing.T) {
d := Dog{}
MakeSound(d)
    // 另一种使用方法
var a Animal
// Dog 实现了（通俗的说长得像） Animal 接口，所以可以赋值给 a
a = Dog{}
a.Say()
}

Go 的接口更像是：只关心你能做什么，不关心你是谁。

任何类型，只要有Say()方法，都可以当成Animal使用。

这一块和Java差距过大（和TypeScript几乎一致），还需要一段时间适应。当时学习TS的适合，就很容易带入Java的思维，先定义接口，再写实现。对于这类语言，似乎应该先实现，然后有需要抽象的时候再提取为接口。

对于接口，主要知识点在于：

Go是隐式实现接口
Go类型只要拥有接口申明的所有方法，就自动实现该接口
Go的接口实现是结构化类型系统的一种体现
Go更强调行为抽象，而不是继承关系。

空接口

空接口是没有任何方法的接口

1	interface{}

因为它不要求任何方法，所以所有类型都实现了空接口。(Java的Object？在Go中它也叫any)

func TestEmptyInterface(t *testing.T) {
// 老古董语法了，推荐使用any别名
var x interface{}
x = 10
x = "Hello"
x = 3.1354
x = true
x = nil
x = []int{123, 456, 789}
t.Log(x)
// Go 1.18开始，引入了 any 作为 interface{} 的别名，any 更加简洁易读。
var y any
y = 10
y = "Hello"
y = 3.1354
y = true
y = nil
y = []int{123, 456, 789}
t.Log(y)
}

那么这玩意有啥用呢？相当于通用参数，对于Java程序员，下面的例子就很直观了。

1
2
3

public void say(Object obj){
    System.out.println(obj.toString())
}

对应到Go

func PrintValue(v interface{}){
    fmt.Println(v)
}
// 或者更常用的
func PrintValueAny(v any){
    fmt.Println(v)
}

any，也就是空接口与泛型有啥区别呢？

interface{} 是运行时动态类型
泛型是编译期类型参数
interface{} 使用时通常需要类型断言
泛型可以保留类型信息

类型断言

类型断言用于从接口中取出具体类型。

类型断言的语法

// 推荐写法
value,ok := x.(T)

// 或者 偷懒写法
value := x.(T)

下面通过一个列子来说明

func TestTypeAssertion(t *testing.T) {
var x any = "Hello"
s, ok := x.(string)
if ok {
t.Log(s)
} else {
t.Log("not string")
}
}

如果是偷懒写法（不安全），如果x的动态类型不是string，程序会panic。

func TestTypeAssertionUnSafe(t *testing.T) {
var x any = 1234
// --- FAIL: TestTypeAssertionUnSafe (0.00s)
// panic: interface conversion: interface {} is int, not string [recovered, repanicked]
s := x.(string)
t.Log(s)
}

所以，推荐使用第一种写法，更安全，更可靠。

类型 switch

当一个接口可能有多种类型时，可以用 type switch。

func PrintType(v any) {
switch value := v.(type) {
case string:
fmt.Printf("string: %v\n", value)
case int:
fmt.Printf("int: %v\n", value)
case bool:
fmt.Printf("bool: %v\n", value)
default:
fmt.Printf("other: %T\n", value)
}
}

type Class struct {
Name string
}

func TestTypeSwitch(t *testing.T) {
PrintType("Hello")
PrintType(true)
PrintType(123)
// other: day5.Class
PrintType(Class{Name: "Java"})
//other: float64
PrintType(3.45)
}

在第四章的switch介绍时，顺便也加入了这个特性，这里就再啰嗦一下，毕竟既是编码常用，也是面试重点：

v.(type) 只能用于 switch 中，不能单独使用。

结构体嵌入（组合）

Go 没有传统继承

普通组合

对于Java来说，存在一个类与类之间的关系，包括继承、组合、聚合之类的关系。但是Go就只有组合。

class Animal {
    void eat(){}
}
// 继承关系
class Dog extends Animal{}

如果是Go：

type Engine struct{}

func (e Engine) Start() {
fmt.Println("start...")
}

type Car struct {
engine Engine
}

func TestComposition(t *testing.T) {
car := Car{engine: Engine{}}
car.engine.Start()
}

上述这个例子从称之为普通组合。

结构体嵌入

Go 特有的一种组合方式，通常被称为 Struct Embedding（结构体嵌套/内嵌）。

type Engine struct{}

func (e Engine) Start() {
fmt.Println("start...")
}

type Tesla struct {
Engine
}

func TestComposition1(t *testing.T) {
car := Tesla{Engine{}}
car.Start()
}

看起来像继承，但本质是组合。

上述例子可行的原因是：方法提升

当结构体嵌入另一个结构体时，被嵌入类型的方法会被提升。现在再通过一个类似的例子说明：

type Animal1 struct{}

func (a Animal1) Eat() {
fmt.Println("eat....")
}

type Dog1 struct {
Animal1
}

func TestComposition2(t *testing.T) {
d := Dog1{}
d.Eat()
}

Dog1 可以直接调用 Eat()，但不是继承。本质上相当于

1	d.Animal.Eat()

当然对于组合来说，Java存在的问题，Go肯定也会存在。那就是如果两个结构体的字段名称和类型一模一样，那么该如何处理呢？

type A struct {
Name string
}

type B struct {
Name string
}

type C struct {
A
B
}

func TestComposition3(t *testing.T) {
c := C{}
//不明确的引用 'Name'
//fmt.Println(c.Name)
fmt.Println(c.A.Name)
fmt.Println(c.B.Name)
}

遇到这种情况时，就必须明确指定，访问的是谁的Name。

这个特性应该会比较常用，例如Java中，会讲一些固定的字段抽取出来放在Base中，其他类只需要继承这个类就可以复用基础字段，对于Go也可以，但不是继承，而是组合

type BaseModel struct {
ID        int
CreatedAt time.Time
UpdatedAt time.Time
}

type user struct {
BaseModel
Name string
}

func TestComposition4(t *testing.T) {
u := user{Name: "Tom", BaseModel: BaseModel{
ID:        1,
CreatedAt: time.Now(),
UpdatedAt: time.Now(),
}}
fmt.Println(u.ID)
fmt.Println(u.CreatedAt)
}

Favor composition over inheritance (组合优于继承)

对于面试来说，只需要记住一点：

Go没有传统继承，它使用结构体嵌入和接口实现来完成代码复用和多态。

方法接收者(Receiver)

Go 没有 Java 中的类方法语法，但可以给类型定义方法。例如：

type User struct {
    Name string
}

func (u User) SayHello(){
    fmt.Println("Hello",u.Name)
}

这里的(u User)就是方法接收者。类似的Java代码如下：

class User {
    void sayHello(){
        System.out.println(this.name);
    }
}

在Go语言中，方法接收者有两种：值接收者和指针接收者

// 值接收者
func (u User) Method()
// 指针接收者
func(u *User) Method()

值接收者

type User struct {
Name string
}

// 这里会复制一个对象
func (u User) Rename(name string) {
u.Name = name
}

// 加了 (u User/*User) 就是这个结构体的方法
func (u User) Add(a, b int) int {
return a + b
}

func TestReceiver(t *testing.T) {
u := User{Name: "Tom"}
u.Rename("Jerry")
// Tom
t.Log(u.Name)
}

这里修改名字是不会生效的，因为对于值接收者，他是复制一个对象，然后再去修改。日常编码中，这种方式使用的频率很低。

指针接受者

如果想要修改原对象里的某个值，那就需要传入指针，这也是日常编码中最常用的方式。

type User struct {
Name string
}

func (u *User) RenamePointer(name string) {
u.Name = name
}

// 加了 (u User/*User) 就是这个结构体的方法
func (u User) Add(a, b int) int {
return a + b
}

func TestReceiver(t *testing.T) {
u := User{Name: "Tom"}
u.RenamePointer("Tony")
t.Log(u.Name)
}

对于Java程序员来说，稍微有些区别，需要特别注意这一点。

这两个特性其实在前期学习slice、map、函数等地方已经提前接触过了。

下面再温故而知新，复述一下，使用场景：

使用指针接收者的场景

方法需要修改接收者

// 例如
func (u *User) RenamePointer(name string) {
u.Name = name
}

结构体较大，避免复制成本

type BigStruct struct {
    Data [1024]int
}

func (b *BigStruct) Process(){}

保持方法集一致

如果一个类型有些方法用了指针接收者，通常建议其他方法也是用指针接收者。

1
2
3

func (u *User) SetName(name string){}

func (u *User) GetName() string{}

这样可以避免接口实现时出现混乱。

使用值接收者的场景

小对象且不可变语义

type Point struct {
    X int
    Y int
}

func (p Point) Distance() float64 {
    return math.Sqrt(float64(p.X*p.X + p.Y * p.Y))
}

基础类型别名

type MyInt int

func (m MyInt) IsPositive() bool {
    return m > 0
}

不希望方法修改原始对象

1
2
3

func (u User) Display(){
    fmt.Println(u.Name)
}

方法调用时得自动取址

Go语言有一个语法糖：

1 2	user := User{} user.SetName("Tom")

如果SetName是指针接收者

1	func (u *User) SetName(name string){}

Go语言会自动转换为

1	(&user).SetName("Tom")

但是，这只在变量可寻址时有效。

不可寻址得情况：

1 2	// 无法在 'User{}' 中调用指针方法 // User{}.SetName("Tom")

如果SetName是市政接收者，这通常不允许，因为临时值不可获取地址。

方法集与接口实现

换一种说法就是： T 和 *T 的方法集。

对于值接受者：

type Speaker interface {
Speak()
}

type Cat struct{}

func (cat Cat) Speak() {
fmt.Println("wangwang")
}

func TestInterface(t *testing.T) {
var s Speaker
cat := Cat{}
// 这样可以
s = cat
s.Speak()
// 这样也可以
s = &cat
s.Speak()
}

因为值接收者方法属于：

Cat的方法集
*Cat的方法集

对于指针接收者：

type Bird struct{}

func (bird *Bird) Speak() {
fmt.Println("jijizhazha")
}

func TestInterface2(t *testing.T) {
var s Speaker
bird := Bird{}
// 这样可以
s = &bird
s.Speak()
// 这样不可以
//无法将 bird (类型 Bird) 用作类型 Speaker
//类型未实现 Speaker，因为 Speak 方法有指针接收器
//s = bird
//s.Speak()
}

因为指针接收者方法只属于*Bird的方法集，不属于Bird的方法集。

总结下，值接收者和指针接受者的区别：

值接收者会复制接收者
指针接收者传递地址
指针接收者可以修改原来的对象
大结构体通常用指针接收者，避免复制
方法集不同，会影响接口实现

综合案例

下面通过一个综合案例，将上面的知识点都串联起来。

package day5

import (
"errors"
"fmt"
"testing"
)

type UserInfo struct {
ID   int64
Name string
}

// 知识点1：接口定义
type UserRepository interface {
FindByID(id int64) (*UserInfo, error)
Save(user *UserInfo) error
}

type MemoryUserRepository struct {
data map[int64]*UserInfo
}

func NewMemoryUserRepository() *MemoryUserRepository {
return &MemoryUserRepository{
data: make(map[int64]*UserInfo),
}
}

// 知识点2： 隐式实现
func (r *MemoryUserRepository) FindByID(id int64) (*UserInfo, error) {
user, ok := r.data[id]
if !ok {
return nil, errors.New("not found")
}
return user, nil
}

// 知识点2： 隐式实现，知识点3：指针接收者
func (r *MemoryUserRepository) Save(user *UserInfo) error {
r.data[user.ID] = user
return nil
}

type Logger struct{}

func (log Logger) Info(message string) {
fmt.Println("[INFO]", message)
}

// 知识点4：结构体嵌入，知识点5组合复用
type UserService struct {
repo UserRepository
Logger
}

func NewUserService(repo UserRepository) *UserService {
return &UserService{
repo: repo,
}
}

func (s *UserService) CreateUser(id int64, name string) error {
s.Info("Creating user...")
user := &UserInfo{
ID:   id,
Name: name,
}
return s.repo.Save(user)
}

func (s *UserService) GetUser(id int64) (*UserInfo, error) {
return s.repo.FindByID(id)
}

func TestDay5(t *testing.T) {
repo := NewMemoryUserRepository()
service := NewUserService(repo)

err := service.CreateUser(1, "John")
if err != nil {
panic(err)
}

user, err := service.GetUser(1)
if err != nil {
panic(err)
}
fmt.Println(user.Name)
}

Go语言学习笔记（四）- 控制流与函数

2026-04-03T04:00:00.000Z

今天简单的学习下流程控制与函数，这一块大多数语言都差不多。

if/else

Go语言的if不需要小括号，但代码块必须使用{}包裹。

func TestIf(t *testing.T) {
age := 30
if age >= 18 {
t.Log("adult")
} else {
t.Log("teenager")
}
}

其次，if条件必须是bool，不支持将整数、字符串、指针等作为条件。

Go 不像 C / C++ / JavaScript，不能用 0、1、nil 等隐式转 bool。

func TestIf1(t *testing.T) {
n := 1
//非布尔值 'n' (类型 int) 用作条件
if n {
t.Log("error")
}
}

if支持初始化语句

这是 Go 很常见的写法，尤其用于错误处理、map 查询、类型转换等场景。

1
2
3

if err := doSomething(); err != nil {
t.Log(err)
}

例如：

func readConfig() error {
if err := loadFile(); err != nil {
return err
}
return nil
}

func loadFile() error {
return error(nil)
}

初始化语句中的变量，只有在if/else if/ else结构中可见。

func TestIfScope(t *testing.T) {
if x := 15; x > 5 {
t.Log("x is greater than 5")
} else {
t.Log(x)
}
}

常见用法：错误处理、map查询、类型断言，例如：

func TestIfMap(t *testing.T) {
m := map[string]int{
"index": 1,
}
if value, ok := m["index"]; ok {
t.Log(value)
} else {
t.Log("not found")
}
}

//或者错误处理
if err:=saveUser(user); err !=nil {
    return err
}

除了必须有{}，还有一个必须那就是else必须紧跟着if的右花括号。

func TestIfElse(t *testing.T) {
n := 20
if n >=18 {
t.Log("adult")
}
    // 这里会报错，Go对换行很敏感，因为编译器会自动插入分号。
else {
t.Log("teenager")
}
}

// 需要紧跟着if的右边花括号。
func TestIfElse(t *testing.T) {
n := 20
if n >=18 {
t.Log("adult")
} else {
t.Log("teenager")
}
}

else if

没啥好说的，好java一样，其他的遵循go的规则，主要是没有小括号，必须花括号，并且紧跟着上一个的右边花括号。

func TestElseIf(t *testing.T) {
s := 80
if s >= 90 {
t.Log("A")
} else if s >= 80 {
t.Log("B")
} else if s >= 60 {
t.Log("C")
}
}

编码时，可以用if实现Guard Clause（守卫语句），在方法的开头先检查不满足继续执行条件的情况，遇到异常、非法参数、边界条件就提前返回、抛异常、跳过。避免后面的主逻辑被多层if包裹起来。下面的例子做个对比。

// guard clause写法
func Process() error {
 data, err := LoadData()
 if err != nil {
  return err
 }
 if len(data) == 0 {
  return fmt.Errorf("empty data")
 }
 return SaveData(data)
}

// 嵌套写法
func Process() error {
 data, err := LoadData()
 if err == nil {
     if len(data) != 0 {
         return SaveData(data)
     } else {
         return fmt.Errorf("empty data")
     }
 } else {
     return err
 }
}

switch

对于switch，和Java区别也不大。只是不需要写break，因为默认不会向下执行(fallthrough)。

func TestSwitch(t *testing.T) {
day := "Monday"
switch day {
case "Monday":
t.Log("Monday")
case "Tuesday":
t.Log("Tuesday")
case "Wednesday":
t.Log("Wednesday")
case "Thursday":
t.Log("Thursday")
case "Friday":
t.Log("Friday")
}
}

当然，case里支持多个条件：

switch day {
case "Monday":
t.Log("work day")
case "Saturday", "Sunday":
t.Log("weekend")
default:
t.Log("normal")

}

如果想继续执行下一个case，可以使用fallthrough

func TestFallThrough(t *testing.T) {
n := 1
switch n {
case 1:
t.Log("1")
fallthrough
case 2:
t.Log("2")
fallthrough
default:
t.Log("default")

}
}

fallthrough 只会进入下一个 case，不会重新判断下一个 case 的条件。

switch和if一样，都支持初始化语句

func TestSwitchInit(t *testing.T) {
switch os := runtime.GOOS; os {
case "darwin":
t.Log("macOS")
case "linux":
t.Log("Linux")
case "windows":
t.Log("Windows")
default:
t.Log("Other OS")
}
}

和if一样的，这里的os也只有在switch内部可见。对于上面if的判断TestElseIf()，也可以修改为switch

func TestSwitch1(t *testing.T) {
s := 80
switch {
case s >= 90:
t.Log("A")
case s >= 80:
t.Log("B")
case s >= 60:
t.Log("C")
}
}

这里可以看到，switch后面没有更任何表达式，这就相当于switch true，通常用来替代复杂的if/else if语句。

switch的case表达式，还可以是任意可比较的表达式

func TestSwitch2(t *testing.T) {
x := 10
switch x {
case 1 + 1:
t.Log("2")
case 5 * 2:
t.Log(10)
}
}

switch的case是从上到下匹配，只要有一个条件匹配成功，后面的就不会再执行。

func TestSwitch3(t *testing.T) {
s := 80
switch {
case s >= 60:
t.Log("C")
case s >= 80:
t.Log("B")
case s >= 90:
t.Log("A")
}
}

此时，只会输出c,，因为第一个已经匹配成功，后面的就不会执行了。编写代码时，一定要注意case的条件，要把更具体的条件放在最前面。

type switch 类型选择

这是比较重要的一点，主要用于判断接口变量的动态类型：

func PrintType(v any) {
switch value := v.(type) {
case int:
fmt.Println("int: ", value)
case float64:
fmt.Println("float64: ", value)
case string:
fmt.Println("string: ", value)
case bool:
fmt.Println("bool: ", value)
default:
fmt.Println("unknown")
}
}

func TestSwitchType(t *testing.T) {
PrintType(123)
PrintType("Hello")
PrintType(3.14)
PrintType(true)
}

v.(type) 只能用于 switch 中，不能单独使用。

在每个 case 中，变量 x 的静态类型会变成对应 case 的类型。

for 循环

对于Go语言来说，循环只有一个for。不过for有多种写法：

类C语言的三段式for
类似while的for
无限循环
for range

下面通过几个小例子展示一下：

// 三段式
for i := 0; i <= 10; i++ {
t.Log(i)
}

// 类似while的for，相当于 while n > 0
n := 5
for n > 0 {
t.Log(n)
n--
}
// 无限循环  while true
// 通常用于服务监听、消费消息队列、重试逻辑、goroutine后台任务
for {
t.Log("running")
}
/**
for {
 msg := receive()
 if msg == "quit" {
  break
 }
 handle(msg)
}
*/

// for range，前面学习slice、map等经常使用
nums := []int{2, 3, 4}
for index, num := range nums {
t.Log(index, num)
}

只要有循环，那就会有break和continue

func TestForBreak(t *testing.T) {
for i := 0; i < 10; i++ {
if i > 5 {
break
}
t.Log(i)
}
}


func TestForContinue(t *testing.T) {
for i := 0; i < 10; i++ {
if i%2 == 0 {
continue
}
t.Log(i)
}
}

遍历string

func TestForString(t *testing.T) {
for i, c := range "Go语言" {
t.Log(i, c, string(c))
}
}

输出如下：

for_test.go:57: 0 71 G
for_test.go:57: 1 111 o
for_test.go:57: 2 35821 语
for_test.go:57: 5 35328 言

range string 遍历的是 rune，不是 byte。

如果想按字节遍历

s := "Go语言"

for i := 0; i < len(s); i++ {
 fmt.Println(i, s[i])
}

可参考day2的字符串

遍历数组时，range 会复制数组。

func TestForArray(t *testing.T) {
arr := [3]int{1, 2, 3}
// 复制数组，这里的v是元素得副本，修改v不会修原来数组的值
for _, v := range arr {
t.Log(v)
}
//如果数组很大，可以遍历数组指针避免复制
for _, v := range &arr {
t.Log(v)
}
}

数组得使用率远不如切片，不过这一问题对于切片，和数组基本上通用。

range获取地址

对于Go1.26来说，使用range获取地址不会再像1.22之前那样，出现多个地址可能指向同一个变量得问题，例如在Go 1.22之前，如下代码会出问题：

func TestForPointer1(t *testing.T) {
nums := []int{1, 2, 3}
var ptrs []*int
for _, v := range nums {
ptrs = append(ptrs, &v)
}
t.Log(ptrs)
}

在Go 1.22开始，for range循环变量每次迭代都会创建新的变量，闭包捕获问题被改善，上述代码就不会有问题，但实际开发中，仍然推荐如下写法：

/*
*
更推荐使用索引方式获取元素地址，避免循环变量v被复用导致所有指针指向同一地址的问题。
*/
func TestForPointer2(t *testing.T) {
nums := []int{1, 2, 3}
var ptrs []*int
for i := range nums {
ptrs = append(ptrs, &nums[i])
}
t.Log(ptrs)
}

labeled break/continue

和Java一样，Go语言也支持label跳出多层循环

func TestForLabeledBreak(t *testing.T) {
outer:
for i := 0; i < 5; i++ {
for j := 0; j < 5; j++ {
if i == 1 && j == 1 {
break outer
}
t.Log(i, j)
}
}
}

break outer 会跳出标记为 outer 的循环。如果是continue

func TestForLabeledContinue(t *testing.T) {
outer:
for i := 0; i < 5; i++ {
for j := 0; j < 5; j++ {
if i == 1 && j == 1 {
continue outer
}
t.Log(i, j)
}
}
}

continue outer 会直接进入外层循环的下一轮。

函数

函数语法

Go语言中的函数，基本上也就是Java中的方法。其基本定义方式如下：

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

// func + 函数名(参数1 类型，参数2，类型 ...) 返回值类型 {函数体}

对于如果连续多个参数类型相同，可以进行参数类型简写：

1
2
3

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

多返回值

和Java不同的是，Go语言中的函数是支持多个返回值的。

// 返回结果+异常
func div(a, b int) (int, error) {
if b == 0 {
return 0, fmt.Errorf("分母不能为0")
}
return a / b, nil
}

func TestMultiReturn(t *testing.T) {
result, err := div(10, 0)
if err != nil {
t.Error(err)
}
t.Log(result)
}

注意，这里并不是异常处理机制，而是Go语言使用多返回值来处理错误。

当然，返回值也是可以忽略的，前面学习其他知识点的时候都有提及，方法就是使用_忽略不需要的返回值。

1 2	value, _ := strconv.Atoi("123") fmt.Println(value)

一般不建议在实际开发中随便忽略错误。更推荐如下：

value,err := strconv.Atoi("123")
if err != nil {
    return err
}
fmt.Println(vlaue)

命名返回值

func GetSize() (width, height int) {
width = 100
height = 200
return
}

func TestNakedReturn(t *testing.T) {
x, y := GetSize()
t.Log(x, y)
}

这里 return 没有显式返回值，称为 naked return。

命名返回值适合短函数。复杂函数中不建议大量使用 naked return，可读性差。

如果是复杂函数，则更推荐如下写法：

func split(sum int) (int, int) {
x := sum / 2
y := sum - x
return x, y
}

func TestNakedReturn1(t *testing.T) {
a, b := split(200)
t.Log(a, b)
}

函数参数是值传递

Go 中函数参数默认都是值传递。

func change(num int) {
num = num * 2
}

func TestMethodArgs(t *testing.T) {
num := 10
change(num)
t.Log(num)
}

回忆在昨天指针章节学习中，如果要修改原始值，需要传递指针

func changePointer(num *int) {
*num = *num * 2
}

func TestMethodArgs2(t *testing.T) {
num := 10
changePointer(&num)
t.Log(num)
}

Go 只有值传递。即使传的是 slice、map、channel，本质上也是拷贝它们的描述符或引用头部。

对于slice、map，可参考前一天的介绍，尤其注意append，它返回的是新的slice，所以需要接受返回值。

可变参数

和Java一样，Go也支持可变参数，其代码如下：

func sum(nums ...int) int {
    // nums ...int 在函数内部是 []int。
    fmt.Printf("nums Type: %T", nums)
total := 0
for _, v := range nums {
total += v
}
return total
}

func TestMethodArray(t *testing.T) {
total := sum(10, 20, 32, 423, 12, 342, 54, 3)
t.Logf("Total : %v", total)

// 对于slice，在调用的时候后面加...
s := []int{1, 2, 3, 4, 5}
t.Logf("Slice: %v", sum(s...))
}

函数是一等公民

在Go语言中，函数是一等公民，可以赋值给变量

func TestMethod1(t *testing.T) {
add := func(a, b int) int {
return a + b
}
t.Log(add(1, 2))
}

也可以作为参数

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

func TestMethod2(t *testing.T) {
t.Log(calculate(10, 20, func(a, b int) int {
return a * b
}))
}

还可以作为返回值

func multiplier(factor int) func(int) int {
return func(n int) int {
return n * factor
}
}

func TestMethod3(t *testing.T) {
double := multiplier(2)
t.Log(double(10))
}

闭包

闭包可以捕获外部变量。

func counter() func() int {
count := 0
return func() int {
count++
return count
}
}

func TestMethod4(t *testing.T) {
next := counter()
t.Log(next())
t.Log(next())
t.Log(next())
}

闭包捕获的是变量本身，不只是值。

defer

defer 用于延迟执行函数，常用于释放资源。

func readFile() error {
file, err := os.Open("./test.txt")
if err != nil {
return err
}
defer file.Close()
return nil
}

defer执行顺序：多个defer按照后进先出执行，也就是栈结构。

func TestMethod5(t *testing.T) {
defer fmt.Println("first")
defer fmt.Println("second")
defer fmt.Println("third")
}

defer参数立即求值

defer 后面的函数如果需要传参，在 defer 声明的那一刻，参数的值就已经定格了。

func TestMethod6(t *testing.T) {
x := 1
    // 1，此时Go已经知道函数结束时，要打印1
defer fmt.Println(x)
x = 2
}

因为 defer fmt.Println(x) 注册时，就已经把传给函数的参数给固定下来了，而不是等到函数结束，真正执行defer时才去搞清楚x的值。

如果让其打印2呢？

func TestMethod7(t *testing.T) {
x := 1
// 1，此时Go已经知道函数结束时，要打印1
defer func(p *int) {
fmt.Println(*p)
}(&x)
x = 2
}
// 或者使用闭包也可以实现,因为闭包捕获变量本身。
func TestMethod8(t *testing.T) {
x := 1
// 1，此时Go已经知道函数结束时，要打印1
defer func() {
fmt.Println(x)
}()
x = 2
}

原因： 注册 defer 时，参数立即求值，求出来的是 x 的内存地址。函数结束时，Go 顺着这个地址去找，发现里面的值已经被改成 2 了。

defer还可以修改命名返回值

func test() (result int) {
defer func() {
result++
}()
return 1
}

func TestMethod9(t *testing.T) {
    // 2
t.Logf("test() result %v", test())
}

执行流程：

return 1 先把返回值 result 赋值为 1
执行 defer，result++
真正返回，结果是 2

panic和recover

在 Go 语言中，panic 和 recover 是处理运行时恐慌（致命错误）的特有机制。它们通常与 defer 配合使用，形成了类似于其他语言中 try-catch-finally 的结构，但其哲学和使用场景有着很大的区别。

panic

panic 是一个 Go 内置的函数，用来主动抛出程序无法继续运行的致命错误。

触发方式： 可以是程序自动触发（如空指针引用、数组越界、除以 0），也可以是开发者手动调用 panic()。
执行流程： 当一个函数发生 panic 时，当前函数的正常执行流程会立即中断，但已注册的 defer 函数依然会被逐个执行。接着，panic 会沿着调用栈一层层向上抛出，直到程序崩溃并打印出堆栈信息。

recover

recover 也是一个内置函数，用来“拦截”并捕获 panic，让程序不至于崩溃。

使用限制： recover() 必须在 defer 调用的函数中直接执行。在正常执行流程中调用 recover 会直接返回 nil 且毫无作用。
执行效果： 如果在 defer 中捕获到了 panic，程序会停止向上崩溃，并恢复正常的执行逻辑（继续执行该 defer 之后的代码，或者安全退出当前函数）。

核心规则

recover 必须写在 defer 中：直接写在函数体里的 recover() 是无法捕获任何恐慌的。
recover 只能捕获同一个 Goroutine 的 panic：Go 语言的恐慌是协程（Goroutine）隔离的。如果 A 协程发生了 panic，B 协程里的 defer recover 是管不着的，程序依然会挂掉。
不要滥用 panic：Go 官方推崇的错误处理方式是返回 error。panic 应该只用于真正致命的、无法挽回的错误（例如：数据库初始化失败、配置解析失败等）。

func safeRun() {
    defer func() {
        if err := recover(); err != nil {
            fmt.Println("recover:",err)
        }
    }()
    panic("oom")
}

另一个小例子：

func TestMethod11(t *testing.T) {
fmt.Println(" running ...")
defer func() {
if err := recover(); err != nil {
fmt.Printf("成功捕获异常，recover : %v\n", err)
}
}()
panic("OutOfMemory")
fmt.Println(" panic之后的代码不会被执行")
}

init 函数

看样子有点像Java的static{}

特点：

没有参数
没有返回值
自动执行
早于 main
一个包中可以有多个 init

执行顺序大致是：

初始化导入的包
初始化包级变量
执行 init
执行 main

1
2
3

func init() {
fmt.Println("Init。。。。")
}

执行任意一个测试用例，即可输出如下：

Init。。。。
=== RUN   TestMethod11
 running ...
成功捕获异常，recover : OutOfMemory
--- PASS: TestMethod11 (0.00s)

如果导入某一个包

1	import _ "github.com/go-sql-driver/mysql" // 这会触发该包的 init() 来注册驱动

那么init函数和Java的static代码块有啥区别呢？

特性	Go 的 init 函数	Java 的 static 静态块
依附对象	Package（包级别）	Class（类级别）
执行时机	`main` 函数运行前，包被加载时	类被加载（Class Load）时
手动调用	不允许	不允许
编写数量	同一个包/文件内可以写多个	同一个类里可以写多个（但极少这么做）
主要用途	初始化包级变量、环境检查、注册驱动	初始化静态成员变量

Go语言学习笔记（三）- 复合数据类型

2026-04-02T04:00:00.000Z

本章知识点：

数组与切片
map（字典）
struct（结构体）
指针
泛型

数组与切片

在 Go 中，数组是固定长度的，而切片是动态的、是对数组的抽象。

数组

不管在Java还是Go似乎都不太常用，比较常用List或者Go中的切片。其语法如下：

package main

import "testing"

func Test_Array(t *testing.T) {

// 数组时值类型，当一个数组被赋值给另一个数组时，实际上是创建了一个新的数组，并将原数组的值复制到新数组中。这意味着对新数组的修改不会影响原数组，反之亦然。
// 定义一个长度为5的int数组，其默认值为0
var arr1 [5]int
t.Log(arr1)
// 定义一个长度为3的字符串数组，默认值为""
var arr2 [3]string
t.Log(arr2)

// 初始化

//字面量初始化
arr3 := [3]string{"a", "b", "c"}
t.Log(arr3)

//省略长度，让编译器自动推断
arr4 := []string{"a", "b", "c"}
t.Log(len(arr4))

//指定下标初始化
arr5 := [5]int{1: 100, 2: 200}
t.Log(arr5)
}

访问数组

func Test_ArrayOpera(t *testing.T) {
// 定义一个长度为5的int数组，其默认值为0
var arr1 [5]int
// 给指定下表赋值/或者是修改
arr1[0] = 10
arr1[3] = 88
t.Log(arr1)
// 获取数组指定下标的值
t.Log(arr1[3])
//获取数组长度
t.Log(len(arr1))

//二维数组
var arrab [2][3]string
arrab[0][0] = "a"
arrab[0][1] = "b"
arrab[0][2] = "c"
// invalid argument: index 3 out of bounds [0:3]
// arrab[0][3] = "c"
arrab[1][0] = "d"
t.Log(arrab)

//二维数组初始化
arrab1 := [2][3]string{
{"a", "b", "c"},
// 必须有,结尾，否则会报错：syntax error: unexpected newline, expecting }
{"a1", "b1", "c1"},
}
t.Log(arrab1)

//获取指定下标
t.Log(arrab1[0][1])
}

对于数组的便利，下一章会有介绍。

关于数组，还有一个最主要的特性：

Go 中数组是值类型，赋值或传参会复制整个数组，处理大数据时非常低效

func Test_ArrayCopy(t *testing.T) {
arr := [3]int{1, 2, 3}
// 完整的拷贝
b := arr
b[0] = 6
t.Log(arr, b)
//调用后，不影响arr的值
modifyArray(arr)
t.Log(arr)
}

func modifyArray(arr [3]int) {
//这里修改的是副本，不影响原来的数组
arr[0] = 6
}

数组的长度必须是常量，且是类型的一部分。[3]int 和 [5]int 在编译器看来是完全不同的两种类型，不能互相赋值或比较。

func Test_ArrayCompare(t *testing.T) {
arr1 := [3]int{1, 2, 3}
arr2 := [3]int{1, 2, 3}
arr3 := [3]int{1, 2, 4}
t.Log(arr1 == arr2)
t.Log(arr1 == arr3)

//arr4 := [4]int{1, 2, 3, 4}
// 无效运算: arr1 == arr4(类型 [3]int 和 [4]int 不匹配)
//t.Log(arr1 == arr4)
}

切片（重点）

切片是 Go 最核心的设计之一。它不是动态数组，而是对底层数组的描述符。

切片三要素：

指针（指向底层数组的起始位置）
长度（len，当前可见的元素个数）
容量（cap，从起始位置到底层数组末尾的元素个数）

它的底层结构体runtime/slice.go:

type slice struct {
    array unsafe.Pointer // 指向底层数组的指针
    len   int            // 长度：当前切片内的元素个数
    cap   int            // 容量：从切片指针开始到数组末尾的元素个数
}

当你传递切片时，实际复制的是这个 header，底层数组是共享的。

下面是切片的初始化方式

func Test_Slice(t *testing.T) {
//nil切片
var s1 []int
// 空切片
s2 := []int{}
//字面量创建
s3 := []int{1, 2, 3}
//[] [] [1 2 3]
t.Log(s1, s2, s3)

// 使用make创建 长度为3，容量为10
s4 := make([]int, 3, 10)
// 长度为3，容量为3
s5 := make([]int, 3)
t.Log(s4, s5)

//从数组中创建
arr := [4]int{1, 2, 3, 4}
s6 := arr[1:3]
t.Log(s6)

//使用new创建  返回 *[]int，需要解引用
s7 := new([]int)
//&[]
t.Log(s7)

//俄罗斯套娃，从切片中创建切片
s8 := s3[1:3]
t.Log(s8)
}

看样子，切片很像Java中的List，顺序存储、动态扩容。它和数组的区别是：

特性	数组	切片
长度	固定，是类型的一部分	可变
类型	值类型	引用类型（底层是结构体）
传参开销	复制整个数组	复制头信息（24字节）
动态扩展	不支持	支持 append
比较	支持 ==	不支持 ==（只能和 nil 比）

切片表达式

规则：

0 <= low <= high <= max <= cap(底层数组)
省略 low 默认为 0
省略 high 默认为 len
完整形式 [low:high:max] 限制新切片的容量

func Test_SliceReg(t *testing.T) {
//切片是引用类型，当一个切片被赋值给另一个切片时，实际上是创建了一个新的切片，但它们指向同一个底层数组。这意味着对新切片的修改会影响原切片，反之亦然。
// 语法 slice[low:high:max]
arr := [10]int{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}

s1 := arr[2:5]
// 2 3 4   len=3 cap=8
t.Log(s1)

s2 := arr[2:5:7]
// 2, 3, 4   len=3 cap=5 max-low
t.Log(s2)

s3 := arr[:5] //省略 low
// 0,1,2,3,4
t.Log(s3)

s4 := arr[5:] //省略 high
// 5,6,7,8,9
t.Log(s4)

s5 := arr[:] // 完整拷贝
// 0,1,2,3,4,5,6,7,8,9
t.Log(s5)
}

切片Append

append函数会返回一个新的切片，新的切片可能指向同一个底层数组，也可能指向一个新的底层数组，这取决于原切片的容量和追加元素的数量。

func Test_SliceAppend(t *testing.T) {
s1 := []int{1, 2, 3}
    // 追加一个
s2 := append(s1, 4)
    // 追加多个
s3 := append(s1, 5, 6)
    // 追加另一个切片
s4 := append(s1, []int{7, 8, 9}...)
t.Log(s1, s2, s3, s4)
}

如果容量足够，就会出现共享底层数组的情况：

func Test_ShareArray(t *testing.T) {
a := []int{1, 2, 3, 4, 5}
b := a[:3]
b = append(b, 99)
t.Log(a, b)
}

输出如下：

1 2	=== RUN Test_ShareArray array_test.go:206: [1 2 3 99 5] [1 2 3 99]

解决方案：使用完整切片表达式限制容量

func Test_ShareArray(t *testing.T) {
a := []int{1, 2, 3, 4, 5}
//b := a[:3]
//b = append(b, 99)
b := a[:3:3] // len=3,cap=3，append会创建新底层数组，不影响a
b = append(b, 99)
t.Log(a, b)
}

此时，输出如下：

1 2	=== RUN Test_ShareArray array_test.go:208: [1 2 3 4 5] [1 2 3 99]

还可能出现append以后，原切片可能被覆盖的情况

func Test_OverwriteSlice(t *testing.T) {
s := make([]int, 3, 5)
s1 := append(s, 1)
s2 := append(s, 2)
t.Log(s, s1, s2)
}

输出如下：

1 2	=== RUN Test_OverwriteSlice array_test.go:215: [0 0 0] [0 0 0 2] [0 0 0 2]

此时可以看到，s2覆盖了s1的最后一个元素。原因就是s1和s2指向了同一个底层数组。

解决方案：在 append 前对原切片做一次完整拷贝，让每次 append 独占底层数组

func Test_OverwriteSlice(t *testing.T) {
s := make([]int, 3, 5)
//s1 := append(s, 1)
//s2 := append(s, 2)
s1 := append(slices.Clone(s), 1)
s2 := append(slices.Clone(s), 2)
t.Log(s, s1, s2)
}

切片扩容

既然涉及到自动扩容，那就要了解下扩容的原理：

当执行 s = append(s, val) 时，Go 的扩容策略在不同版本有所微调（以 Go 1.25 为准）：

如果新长度大于容量的 2 倍，直接使用新长度作为新容量。
否则，如果旧容量 < 256，翻倍。
如果旧容量 >= 256，则增加 (old_cap + 3*256) / 4，直到满足要求。
注意：扩容会触发内存重新分配和数据拷贝，旧底层数组将被 GC 回收。

扩容可能导致底层数组重新分配！此时原切片和新切片不再共享数据。

例如：

a := []int{1, 2, 3}
b := append(a, 4)

// 如果 a 的容量足够，b 和 a 共享底层数组
// 如果容量不够，b 指向全新数组，a 不受影响

切片的拷贝

copy函数会将源切片中的元素复制到目标切片中，复制的元素数量取决于源切片和目标切片的长度。copy函数返回实际复制的元素数量。

func Test_SliceCopy(t *testing.T) {
ss := []int{1, 2, 3, 4, 5}
sd := make([]int, 3)
// 将ss（src）切片中的前3个元素复制到sd(dst)切片中
n := copy(sd, ss)
t.Log(sd, n)
}

特点：

复制个数 = min(len(src), len(dst))
两个切片可以重叠
可用于切片截断：copy(s, s[i:])

常用技巧：

// 删除索引 i 的元素
copy(s[i:], s[i+1:])
s = s[:len(s)-1]

// 在开头插入元素（效率低，需要移动所有元素）
s = append([]int{x}, s...)

//解决大切片不释放内存的问题
// 假设 data是一个超级大的切片
small := make([]int, 10)
//只copy出需要的部分，否则只要small存在，data的整个底层数组都不会被GC
copy(small, data)

切片是引用类型，函数内修改会影响原切片（注意区分修改元素和改变切片本身）：

func Test_SliceArgs(t *testing.T) {
s := []int{1, 2, 3, 4, 5}
modifySlice(s)
t.Log(s)

modifySlice1(s)
t.Log(s)

appendValue(&s, 8)
t.Log(s)
}

func modifySlice(s []int) {
// 会改变原始切片的值
s[0] = 99
}

func modifySlice1(s []int) {
// 不会改变原始切片的值
s = append(s, 6)
}

// 如果想要实现切片的append，需要传递指针
func appendValue(s *[]int, v int) {
if s == nil {
return
}
*s = append(*s, v)
}

多维切片

func Test_MultiSlice(t *testing.T) {
// 多维切片
var s [][]int
// 切片的每行长度可以不同（俗称锯齿数组）
rows, cols := 3, 4
s = make([][]int, rows, cols)
for i := range s {
s[i] = make([]int, cols)
}
s[1][2] = 99

t.Log(s)
    // [[0 0 0 0] [0 0 99 0] [0 0 0 0]]
// 切片的每行长度可以不同（俗称锯齿数组）
s2 := [][]int{
{1},
{1, 2},
{1, 2, 3},
}
t.Log(s2)
    // [[1] [1 2] [1 2 3]]
}

map(字典)

map 是 Go 内置的哈希表类型，用于存储 键值对。其语法结构为

1	map[KeyType]ValueType

申明与初始化

nil map

1 2	// nil map，不能写入 var m1 map[string]int

map 的零值是 nil

1
2
3

var m1 map[string]int
t.Logf("m1 == nil 的结果是 : %v", m1 == nil)
// m1 == nil 的结果是 : true

nil不能写入，但可以有以下操作：

func Test_NilMap(t *testing.T) {
var m map[string]int
// nil map可以获取值
v := m["x"]
t.Logf("nil map get key : %v", v)
// nil map 可以作为判断
_, ok := m["x"]
t.Logf("nil map get status : %v", ok)
// nil map可以删除元素
delete(m, "x")
// nil map可以clear
clear(m)
// nil map可以遍历
for i := range m {
t.Log(i)
}
}

通过make创建map

1
2
3

m := make(map[string]int)
// 或者指定容量
m1:= make(map[string]int,1000)

注意：这个 1000 是 容量提示，不是最大容量限制。map会自动扩容。

通过字面量创建map

m := map[string]int {
    "a":1,
    "b":2
}

当然，也可以创建一个空的map（注意：空map和nil map是两码事），空map可以写入数据。

1	m := map[string]int{}

此处附上nil map 与 空map对比：

	nil map	空map `map[k]v{}`
读取	返回零值	返回零值
写入	panic	正常
删除	panic	正常
len	0	0

map的CRUD

增加/修改

m := map[string]int{}
// 新增一条数据
m["age"] = 18
// 将原有的数据修改为28
m["age"] = 28

总结下来就是：

如果key不存在，就是新增。
如果key存在，就是修改。

读取

v := m["age"] 
// 此时输出28
t.Log(v)
// 如果key不存在，则返回value类型零值
v1 := m["age1"]
// 输出0
t.Log(v)

判断key是否存在（核心写法）

v,ok := m["age"]
if ok {
    t.Log("存在",v)
} else {
    t.Log("不存在")
}

删除元素

1
2
3

delete(m,"age")
// 即使key不存在也不会报错，所以nil map使用delete也不会报错。
delete(m, "not-exist")

清空map

此特性是Go 1.21之后内置的函数clear()

clear(m)

删除map中的所有元素，对于nil map调用也安全的。

获取长度

1 2	// 返回的是当前key-value对的数量。 len(m)

遍历map

m := map[string]int{
    "key1":100,
    "key2":150,
    "key3":200,
}

for k,v := range m {
    t.Logf("key = %v, value = %v",k,v)
}

// 只遍历key
for k:= range m {
    t.Logf("key = %v",k)
}

// 只便利value
for _,v := range m {
    t.Logf("value = %v",v)
}

注意：map 遍历顺序是不确定的

那么如何确保输出顺序是稳定的呢？那就是先取key，在排序：

func Test_LoopMapSort(t *testing.T) {
m := map[string]int{
"key1": 100,
"key2": 150,
"key3": 200,
}

for k, v := range m {
t.Log(k, v)
}
keys := make([]string, 0, len(m))
for k := range m {
keys = append(keys, k)
}
sort.Strings(keys)
for _, k := range keys {
t.Logf("key = %v, value = %v", k, m[k])
}
}

多次执行，观察输出：

=== RUN   Test_LoopMapSort
    map_test.go:71: key3 200
    map_test.go:71: key1 100
    map_test.go:71: key2 150
    map_test.go:80: key = key1, value = 100
    map_test.go:80: key = key2, value = 150
    map_test.go:80: key = key3, value = 200

对于Go语言的map，它对key还是略微有一些要求的，那就是map的key必须是可比较的类型，也就是说可以使用==或者!=比较的类型，以下类型都可以作为map的key:

string
int
bool
float64
complex64
pointer
channel
interface
array
struct

其中array和struct的元素/字段也必须为可比较。

下面三个是不能作为key的类型：

slice
map
func

func Test_MapKeyType(t *testing.T) {
m := map[[2]int]string{
{1, 2}: "1",
{3, 4}: "2",
}

m1 := map[struct {
Name string
Age  int
}]string{
{"zhangsan", 18}: "1",
{"lisi", 18}:     "2",
}

t.Log(m, m1)

//无效的映射键类型: 必须为键类型完全定义比较运算符 == 和 !=
// m2 := map[func()]string{}
}

至于slice不能作为map的key，主要原因是slice不能使用==比较

a := []int{1, 2, 3}
b := []int{1, 2, 3}
//无效运算: a == b (在 []int 中未定义运算符 ==)
t.Log(a == b)

因为slice底层有三个属性指针、长度、容量，Go语言没有定义两个slice内容相等的比较语义。所以slice不能作为map的key。如果想用 slice 内容作为 key，可以转成 string 或 array。

m3 := map[string]int{}
key := fmt.Sprint([]int{1, 2, 3})
m3[key] = 11
t.Log(m3)
// 或者固定长度
m4 := map[[3]int]string{}
m4[[3]int{1, 2, 3}] = "ok"
t.Log(m4)

还需要注意的是，两个map不能直接比较，但任意一个map可以和nil map比较，如果需要比较两个map，可以使用maps.Equal(m1,m2)来实现（注意，此时需要valuie也是可比较的才行），或者根据业务需求，自己定义比较逻辑。

map 是引用类型吗？

Go 语言规范并没有把 map 正式定义为“引用类型”这一类别，但规范明确说明：非 nil 的 map 值包含对底层数据的引用；具体来说，map 值是对实现相关数据结构的引用。因此从使用效果看，map 赋值或传参会复制这个引用，而不会复制整张 map。

func Test_Map1(t *testing.T) {
m1 := map[string]int{
"a": 1,
}
m2 := m1
m2["a"] = 100
// map[a:100]
t.Log(m1)
}

或者传参也是类似：

func TestMapArg(t *testing.T) {
m := make(map[string]int)
changeMap(m)
t.Log(m)
}

func changeMap(m map[string]int) {
m["x"] = 1
}

但是如果在函数里让参数指向一个新 map，不会影响外部变量本身：

func TestMapArg(t *testing.T) {
m := make(map[string]int)
changeMap1(m)
t.Log(m)
}

func changeMap1(m map[string]int) {
    // 新的map
m = make(map[string]int)
m["y"] = 1
}

如果想替换外部 map，需要返回新 map，或传 *map[...]...。

// 更推荐这种写法
func reset() map[string]int {
return make(map[string]int)
}
// 只有在必须修改调用者持有的那个变量时，才考虑 *map[...]...
func reset1(m *map[string]int) {
*m = make(map[string]int)
}

其他关于map线程安全、其他map常用api或编码技巧等在后续学习中逐渐补充。

struct(结构体)

struct 是 Go 中用于组合多个字段的数据类型，类似于Java中的classs。

type User struct {
//同类型的可以合并写
Id, Age int
Name    string
}

func TestStruct(t *testing.T) {
u := User{}
u.Age = 18
u.Name = "John"
u.Id = 1
t.Log(u)

u1 := User{
Id:   2,
Age:  25,
Name: "Tom",
}
t.Log(u1)
}

struct 的零值是：所有字段都是各自类型的零值。

type User struct {
//同类型的可以合并写
Id, Age int
Name    string
Active  bool
Tags    []string
}

func TestStruct(t *testing.T) {
u2 := User{}
    // {0 0  false []}
t.Log(u2.Id)   // 0
t.Log(u2.Age)  //0
t.Log(u2.Name) // “”
t.Log(u2.Tags) // []
t.Log(u2.Active)// false
    t.Log(u2.Tags == nil) // true
}

struct 本身通常不为 nil，除非你使用的是 *Struct 指针。

初始化

对于struct，初始化方式有两种方式：

按照字段名初始化（推荐）

u1 := User{
Id:   2,
Age:  25,
Name: "Tom",
}

日常编码应当使用这种方式进行初始化。

按照字段顺序初始化

1	u2:= User{3,30,"Jerry"}

这种方式似乎看起来简单，但可读性差，一旦后期修改了struct的字段顺序，这样的代码就会出现错位或者报错。所以日常开发尽量不要使用这种方式。

个人觉得似乎还有一种，不过我是以Java程序员的视角似乎也是一种初始化，回头查查这样的初始化是不是有啥坑。

u := User{}
u.Age = 18
u.Name = "John"
u.Id = 1
t.Log(u)

访问和修改字段

func TestStructRU(t *testing.T) {
u := User{Id: 1, Name: "zhangsan", Active: true, Tags: []string{"Java", "Go"}, Age: 28}
t.Log(u.Tags)

u.Age = 32
t.Log(u.Age)
}

struct是值类型

struct 赋值时会拷贝整个值，不像 map、slice 那样共享整体结构。

func TestStructType(t *testing.T) {
u := User{Id: 1, Name: "zhangsan", Active: true, Tags: []string{"Java", "Go"}, Age: 28}
u1 := u
u1.Name = "Jack"
t.Log(u.Name)
t.Log(u1.Name)
}

当然，struct中的字段如果是引用类型，那么字段内部引用的数据仍然可能是共享的。

拷贝

如果struct中包含slice/map/pointer时，拷贝是浅拷贝

type Person struct {
Name string
Tags []string
}

func TestStructCopy(t *testing.T) {
p1 := Person{
Name: "Jack",
Tags: []string{"Java", "Go"},
}
p2 := p1
p2.Tags[0] = "Python"
    // [Python Go]
t.Log(p1.Tags)
    // [Python Go]
t.Log(p2.Tags)
}

原因：

struct 本身被拷贝了
但 Tags 这个 slice 头部被拷贝
slice底层数组仍然共享

函数传struct默认也是值拷贝

type Person struct {
Name string
Tags []string
Age  int
}

func grow(p Person) {
p.Age++
}

func TestStructCopyArg(t *testing.T) {
p1 := Person{
Name: "Jack",
Tags: []string{"Java", "Go"},
Age:  28,
}
grow(p1)
    // 28
t.Log(p1.Age)
}

如果想要修改原来的对象，那么就需要传指针

func grow1(p *Person) {
p.Age++
}

func TestStructCopyArg(t *testing.T) {
p1 := Person{
Name: "Jack",
Tags: []string{"Java", "Go"},
Age:  28,
}
grow1(&p1)
    // 29
t.Log(p1.Age)
}

struct 指针访问字段可以省略解引用

Go 允许自动解引用。

func TestStruct2(t *testing.T) {
p := &Person{Name: "Jack", Tags: []string{"Java", "Go"}, Age: 28}
t.Log(p.Name) // 等价于(*p).Name
p.Age = 20
t.Log(p.Age)
}

如何判断使用struct还是*struct

用 struct 值的情况

适合：

数据很小
不需要修改原对象
想避免共享状态
临时值、配置值、小对象

type Point struct {
    X, Y int
}

func Move(p Point, dx, dy int) Point {
    p.X += dx
    p.Y += dy
    return p
}

用 *struct 指针的情况

适合：

struct 较大
需要修改原对象
避免频繁拷贝
方法需要改变 receiver（相当于Java的this）
包含锁、缓存、连接等状态

type Counter struct {
    N int
}

func (c *Counter) Inc() {
    c.N++
}

func main() {
    c := &Counter{}
    c.Inc()
    c.Inc()

    fmt.Println(c.N) // 2
}

Go 没有 class，但可以给类型定义方法。

参考上面的例子就可以说明问题。Inc()方法可以被Counter调用。

receiver 选择原则：如果一个类型的方法中，有任意一个方法需要指针 receiver，通常所有方法都用指针 receiver，保持一致。

type User struct {
    Name string
    Age int
}

func(u *User) Rename(name string){
    u.Name = name
}

func(u *User) IsAdult() bool {
    return u.Age >= 18
}

指针

指针保存的是一个变量的内存地址。其语法如下：

1	var p *int

p 是一个指针变量
它指向一个 int 类型的变量
*int 表示“指向 int 的指针类型”

取地址

在Go语言中，使用&获取变量地址。

func TestGetAddress(t *testing.T) {
x := 10
// x 的内存地址，例如 0xc0000120a
p := &x
// x = 10, p = 44087471899344
t.Logf("x = %d, p = %d", x, p)
}

解引用

以上一个例子为例，使用*p访问指针指向的值。

func TestDeref(t *testing.T) {
x := 10
p := &x
// *p = 10
t.Logf("*p = %v", *p)
    // 表示修改 p 指向的变量的值。
*p = 20
// x = 20, *p = 20
t.Logf("x = %d, *p = %d", x, *p)
}

指针的零值

指针类型的零值是 nil。

func TestZeroValue(t *testing.T) {
var p *int
//p == nil 的值是 true
t.Logf("p == nil 的值是 %v", p == nil)
    // 潜在的 nil 解引用
    // 第 26 行: 'p == nil' 被假定等于 'nil'  
    // 第 27 行: 'p' 被解引用 
    // t.Log(*p)
}

注意：不能解引用nil 指针。

通常为了避免这个问题，使用如下写法：

func TestZeroValue1(t *testing.T) {
// 假设任意一个指针
x := 10
p := &x
if p != nil {
// 执行正常的逻辑
t.Log(*p)
} else {
t.Log("p is nil")
}
}

函数传值和传指针

其实前面的学习中，已经使用过几次。这里再介绍一下。

Go 默认是值传递。

如果传普通变量，函数内部修改的是副本。

func change(x int) {
// 如果传普通变量，函数内部修改的是副本。
x = 20
}

func TestArgsValue(t *testing.T) {
n := 10
change(n)
    // n = 10
t.Logf("n = %d", n)
}

// 如果想让函数修改外部变量，需要传指针。
func changePoint(p *int) {
*p = 20
}

func TestArgsPoint(t *testing.T) {
n := 10
changePoint(&n)
    // n = 20
t.Logf("n = %d", n)
}

struct指针（重点）

如果要修改struct的值，需要传递指针。

type UserInfo struct {
Name string
Age  int
}

// 方法里的指针 receiver，通常修改struct时，需要这么定义。如果传值，那么修改不会影响元对象。
func birthday(u *UserInfo) {
    // 等价于 (*u).Age++，Go 会自动解引用 struct 指针，所以一般不用写 (*u).Age。
u.Age++
}

func TestStructPointer(t *testing.T) {
u := UserInfo{
Name: "Jerry",
Age:  18,
}
birthday(&u)
// Name = Jerry Age = 19
t.Logf("Name = %v Age = %d", u.Name, u.Age)
}

new函数

new(T)会分配一个T类型的值，并返回*T

func TestNew(t *testing.T) {
p := new(int)
t.Logf("p = %v, *p = %v", p, *p)
*p = 10
t.Logf(" *p = %v", *p)
// 对于struct,以下方式等价于u := &User{}，后者更常用
u := new(UserInfo)
u.Name = "Tom"
u.Age = 18
t.Logf("Name = %v Age = %d", u.Name, u.Age)
}

指针不能做算数运算

Go 指针不能像 C/C++ 那样做指针偏移。

func TestPointCompute(t *testing.T) {
x := 10
p := &x
// 无效运算: p++(非数值类型 *int)
// p++
}

// 同样也不支持下列操作：
//p + 1
//p--

指针和（数组、slice、map）

数组是值类型，传参会拷贝整个数组。

// 传数组：会拷贝
func changeArray(a [3]int) {
a[0] = 99
}

// 传数组指针：可以修改原数组
func chageArrayPoint(a *[3]int) {
a[0] = 99
}

func TestArray(t *testing.T) {
arr := [3]int{1, 2, 3}
changeArray(arr)
    // arr = [1 2 3]
t.Logf("arr = %v", arr)

chageArrayPoint(&arr)
    // arr = [99 2 3]
t.Logf("arr = %v", arr)
}

slice 本身包含指向底层数组的指针，所以传 slice 通常就能修改底层元素。

对于Go语言，slice的使用频率要远高于数组。下面通过一个例子来说明指针与切片：

func changeSlice(nums []int) {
nums[0] = 99
}

func changeSliceAppend(nums []int) {
nums = append(nums, 4)
}

func changeSliceReturnNew(nums []int) []int {
nums = append(nums, 5)
return nums
}

func TestSlice(t *testing.T) {
nums := []int{1, 2, 3}
// 修改第一值
changeSlice(nums)
// 修改第一个值：nums = [99 2 3]
t.Logf("修改第一个值：nums = %v", nums)
changeSliceAppend(nums)
//追加一个新值：nums = [99 2 3]
t.Logf("追加一个新值：nums = %v", nums)
nums = changeSliceReturnNew(nums)
// 追加一个新值，并返回新的slice: nums = [99 2 3 5]
t.Logf("追加一个新值，并返回新的slice: nums = %v", nums)
}

一般不推荐用 *[]T，除非你真的需要修改 slice 变量本身。

对于map来说，map 本身也是引用语义的数据结构，所以通常不需要传 *map。其他方式和slice基本一致。

泛型

与Java的泛型类似，Go语言泛型允许在定义函数、类型或方法时，暂时不指定具体类型，而是在使用时再传入具体类型。

它的核心作用是：

减少重复代码
提高类型安全
编写更通用的函数和数据结构

下面是一个最直观的例子：

func maxInt(x int, y int) int {
if x > y {
return x
} else {
return y
}
}

func maxFloat(x float64, y float64) float64 {
if x > y {
return x
} else {
return y
}
}

// 使用泛型
func Max[T int | float64](a, b T) T {
if a > b {
return a
} else {
return b
}
}

func TestGetMax(t *testing.T) {
// 不使用泛型
t.Logf("maxInt(1, 2) = %d", maxInt(1, 2))
t.Logf("maxFloat(1.1, 2.2) = %f", maxFloat(1.1, 2.2))
// 使用泛型
t.Logf("Max[int](1, 2) = %d", Max[int](1, 2))
    t.Logf("Max[float64](1.1, 2.2) = %f", Max[float64](1.1, 2.2))
}

使用泛型可以减少重复代码。

泛型的语法格式

1	func 函数名[T 约束](参数 T) T

T是类型参数
约束限制T可以是什么类型

func Identity[T any](value T) T {
return value
}

func TestGenerics(t *testing.T) {
t.Logf("Identity[int](1) = %d", Identity[int](1))
t.Logf("Identity[string]('hello') = %v", Identity[string]("Hello"))
// 也可以让Go取自动类型推导
t.Logf("Identity(2) = %v", Identity(2))
}

any约束

any 是 Go 1.18 引入的内置类型别名，本质上等价于 interface{}。它表示可以接受任何类型。

func PrintValue[T any](value T) {
fmt.Println(value)
}

func TestAny(t *testing.T) {
PrintValue(123)
PrintValue("Hello World!")
PrintValue(true)
PrintValue(3.1415)
}

comparable约束

comparable 表示该类型可以使用 == 和 != 比较。

常见可比较类型：

int
string
bool
指针
channel
由可比较字段组成的 struct

不可比较类型：

slice
map
function

这一块和map的key比较像。

func Equal[T comparable](a, b T) bool {
return a == b
}

func TestComparable(t *testing.T) {
t.Logf("Equal(1, 1) = %t", Equal(1, 1))
t.Logf("Equal('hello', 'hello') = %t", Equal("hello", "hello"))
t.Logf("Equal(1.1, 1.1) = %t", Equal(1.1, 1.1))
// 下面的代码会报错，因为slice类型不支持比较
// t.Logf("Equal([]int{1, 2}, []int{1, 2}) = %t", Equal([]int{1, 2}, []int{1, 2}))
}

自定义类型约束

可以通过接口定义自己的类型约束（TypeScript?）

type Number interface {
int | int64 | float64
}

func Add[T Number](a, b T) T {
return a + b
}

func TestCustomType(t *testing.T) {
num1 := Add(2, 3)
num2 := Add(1.9, 2.1)
t.Logf("Add(2, 3) = %v", num1)
t.Logf("Add(1.9, 2.1) = %v", num2)
}

定义Number类型的|称之为类型联合，意思是可以是这些类型中的任意一种。例如如下：

1
2
3

type Integer interface {
    int | int8 | int16 | int32 | int64
}

表示满足该约束的类型是：

int
int8
int16
int32
int64

这样的方式，也可以叫做类型集合。

底层类型约束

~ 表示允许使用某个类型以及以该类型为底层类型的自定义类型。

下面通过两个例子作为对比：

不使用~

type MyInt int

type IntOnly interface {
int
}

func Double[T IntOnly](v T) T {
return v * 2
}

// 使用~

type IntLike interface {
~int
}

func DoubleIntLike[T IntLike](v T) T {
return v * 2
}

func Test1(t *testing.T) {
//var x MyInt = 10
/**
无法将 MyInt 用作类型 IntOnly
类型未实现约束 IntOnly，因为类型未包括在类型集(int)中
*/
//t.Logf("Double(x) = %v", Double(x))

var y MyInt = 20
t.Logf("Double(y) = %v", DoubleIntLike(y))
}

~int 的意思是：只要底层类型是 int，都可以满足这个约束。

泛型函数

泛型函数是最常见的泛型用法。

func Contains[T comparable](items []T, target T) bool {
for _, item := range items {
if item == target {
return true
}
}
return false
}

func TestGenericsFunc(t *testing.T) {
t.Logf("Contains([]int{1, 2, 3}, 2) = %t", Contains([]int{1, 2, 3}, 2))
t.Logf("Contains([]string{'a', 'b', 'c'}, 'd') = %t", Contains([]string{"a", "b", "c"}, "d"))
}

可以实现一个类似lambda中的map操作。

func Map[T any, R any](items []T, fn func(T) R) []R {
result := make([]R, len(items))
for i, item := range items {
result[i] = fn(item)
}
return result
}

func TestMapFunc(t *testing.T) {
nums := []int{1, 2, 3}

strs := Map(nums, func(n int) string {
return fmt.Sprintf("Number: %d", n)
})

t.Log(strs)
}

同理，实现一个Filter和Reduce

func Filter[T any](items []T, fn func(T) bool) []T {
result := make([]T, 0, len(items))
for _, item := range items {
if fn(item) {
result = append(result, item)
}
}
return result
}

func Reduce[T any, R any](items []T, initial R, fn func(R, T) R) R {
result := initial

for _, item := range items {
result = fn(result, item)
}

return result
}

func TestLambdaFunc(t *testing.T) {
nums := []int{1, 2, 3, 4, 5}
evens := Filter(nums, func(n int) bool {
return n%2 == 0
})
t.Log(evens)

sum := Reduce(nums, 0, func(acc int, n int) int {
return acc + n
})

t.Logf("Sum of nums = %d", sum)

}

结构体泛型

不仅函数可以使用泛型，结构体也可以使用泛型。

type Box[T any] struct {
value T
}

type Pair[K comparable, V any] struct {
Key   K
Value V
}

func TestGenericsStruct(t *testing.T) {
intBox := Box[int]{value: 28}
stringBox := Box[string]{value: "Hello Go"}
t.Logf("intBox = %v, stringBox = %v", intBox.value, stringBox.value)

p1 := Pair[string, int]{
Key:   "age",
Value: 28,
}

p2 := Pair[string, string]{
Key:   "Name",
Value: "Jerry",
}

t.Logf("p1 = {Key: %v, Value: %v}, p2 = {Key: %v, Value: %v}", p1.Key, p1.Value, p2.Key, p2.Value)
}

泛型与接口的区别

虽然自定义泛型使用的是interface，看起来像是接口，但和接口还有些区别。普通接口关注的是行为，泛型约束关注的是类型集合。

1
2
3

type Writer interface {
    Write([]byte) (int,error)
}

只要实现Write方法，就满足接口。

1
2
3

type Number interface{
    int | int32 | float64
}

表示类型必须属于这个类型集合，也可以同时约束类型和方法。

type StringNumber interface {
    ~int | ~int64
    String() string
}

但这种约束要求类型：

底层类型是 int 或 int64
实现了 String() string

Go语言学习笔记（二）- 基础语法与数据类型

2026-04-01T03:00:00.000Z

作为Java程序员，本章内容就走马观花的了解一下即可，这一章内容和其他语言没有太大的不同。

本章学习的内容

包申明、导入、main方法
变量声明（var和:=的区别）
基本类型：int、float、string、bool
常量与iota
类型转换

main方法

通过一个HelloWorld的程序，说明第一小节内容：包申明、导入包、main方法。创建一个main.go

package main

import "fmt"

func main() {
fmt.Print("Hello World")
}

包申明：

1	package main

在Go语言中，每一个源文件都必须以package开头，它的作用就是定义了该文件属于哪个命名空间。这个名称可以随意定义，但main这个名称很特殊：

如果该文件的package是main，那么这个程序将会被编译成一个可执行程序。
对于不同的文件，也可以将包名定义为main，但是main方法只能有一个。

例如在main.go的同一级目录，创建一个utils.go，并且也声明为main。

package main

func max(a, b int) int {
if a > b {
return a
}
return b
}

这样是可以的，但如果在这个文件里也定义一个main方法，作为项目整体运行的时候，就会报错。

错误: 软件包 hellogo 包含多个 main 函数
请考虑改用文件种类

如果运行种类那里换成目录，会提示如下错误：

1
2
3

# hellogo
.\utils.go:12:6: main redeclared in this block
.\main.go:9:6: other declaration of main

如果你在终端执行go run utils.go是可以执行的，因为它执行的模式是文件。

导入包：

1	import "fmt"

这就和Java差不多，主要的区别就是不用的包不允许导入。

包名必须使用双引号”“包裹。
导入的包必须使用，否则编译器会报错
如果有多个包，通常使用圆括号

import (
  "fmt"
  "math"
)

main方法：

1 2	func main() { }

和Java的public static void main(String[] args)一样，是程序的入口。

func关键字：用于定义方法（函数）
main方法不接受任何参数，也不返回任何值。
花括号必须跟在 main()后面，如果使用c#那种换行会报错。

变量申明

在Go语言中，通常变量申明有两种方式：第一种是var，另一种是简洁的申明方式:=，二者略有区别。

单个变量申明

package main

import "fmt"

var global = "全局变量"
//globalval :=100 不能作为全局变量

func main() {
    // 声明一个变量
    var a1 = "张三"
    fmt.Print(a1)
    
    var username string
    username = "zhangsan"
    
    a2:= "李四"  // 只能申明局部变量
    fmt.Println(a2)
}

和早期（JDK11以前）的Java不同，Go语言的类型时自己推断出来的，通常不需要显示的申明变量类型。

上述例子，分别体现了三种声明变量的方式：

类型推导：编译器根据等号右边的值自动判断a1的类型是string，一旦确定，那么a1的类型就会固定，不能再修改为其他类型。
标准声明(var + 类型)：会和Java一样，有一个默认值的机制：如果你只声明 var a int 而不赋值，Go 会自动将其初始化为 0（字符串是 ""，布尔是 false）。
短变量申明:=：偷懒专用，但只能使用在方法（函数）内部，不能用于包级变量，且必须至少有一个变量是新声明的。

批量变量申明：

package main

import "fmt"

func main() {    
    var name1, name2 = "李四", 22
fmt.Println(name1, name2)
    // 声明时就赋值
    var (
age1     = 18
age2     = 20
nickname = "王五"
)
fmt.Println(age1, age2, nickname)
    
    // 声明后赋值
    var (
username11 string
age11      int
sex11      string
)
username11 = "zhangsan"
age11 = 11
sex11 = "男"
fmt.Println(username11, age11, sex11)
    
    // 使用:=申明多个变量
    a, b, c := 1, 2, "C"
fmt.Println(a, b, c)
    // 打印类型
fmt.Printf("%T %T", a, c)
}

对于批量变量申明，只需要var(多个变量)即可，非常优雅。非常适合归类，对于同一类的变量可以申明到一起，还增加了可读性。

匿名变量

package main

import "fmt"

func main() {  
    var username, age = getUserInfo()
    fmt.Println(username, age)
    //匿名变量
    var username1, _ = getUserInfo()
    fmt.Println(username1)
} 
// 定义一个方法
func getUserInfo() (string, int) {
return "zhangsan", 18
}

如果某个方法返回的值不需要，为了避免代码报错，那么可以使用下划线_作为匿名变量，这也是比较常用的方式。

和导入包一样，未使用的变量也会报错，不用变量的请及时清理。（谁懂读别人Java代码的苦啊）

基本类型

Go语言的基本类型有：

整数类型

平台无关(需要明确长度的)
- 有符号：int8、int16、int32、int64
- 无符号：uint8、uint16、uint32、uint64
- 特殊别名：
  - byte：等用于uint8，常用于处理二进制原始数据。
  - rune：等同于int32，专用用于表示一个Unicode字符(Java里的char？)
平台相关
- int/uint：在 32 位系统上占 4 字节，在 64 位系统上占 8 字节（ Debian 13，int 默认就是 64 位）。
- uintptr：无符号整数，大小足以存放一个指针的位模式，多用于底层 unsafe 编程。

在 Go 中，int 和 int64 被视为不同的类型。即使在 64 位系统上两者的长度相同，你也不能直接将 int 变量赋值给 int64，必须显式转换：int64(myInt)。

浮点型

float32：单精度浮点数（约7位有效数字）
float64：双精度浮点数（约15位有效数字），它是Go语言的类型推导的默认值。

所有语言的通病，也是面试题位数不懂相同的就是0.1 + 0.2的问题，Go也有！对于Java有BigDecimal，对于Go同样有shopspring/decimal。

字符串

字符串string(小写)，它是不可变类型，一旦创建，字符串内部的字节序列就不允许修改。其次，它的默认编码是UTF-8，本质上上一个只读的字节切片（[]byte）。

有几个坑需要注意：

len()返回的是字符串的字节长度，而非字符个数

1
2
3

s := "Hello Go语言"
//打印出的长度位14(中文每个占用3字节)
t.Log(len(s))

当然，非要统计字符个数，请使用unicode/utf8这个包

import (
"testing"
"unicode/utf8"  //要导入这个包
)

s := "Hello Go语言"
// 打印长度为10
t.Log(utf8.RuneCountInString(s))

布尔类型

类型名为bool,默认值为false，取值只有两个：true或者false，不允许像c那样，将0当作false。

常量与`iota`

常量

Go语言的常量使用const定义，可以显式声明类型，也可以利用类型推导。和其他语言一样，编译时就确定了值，并且不可改变。

其规则如下：

编译时确定：常量的赋值必须是一个在编译期就能确定的值（如字面量、算术运算、内置函数如 len()）。不能把一个函数的返回值赋值给常量。
批量申明
常量展开（跳过赋值）：在一组常量中，如果某一行没有写赋值，那么它会自动复用上一行的表达式。

下面通过一个例子来说明

//常量
const pi = 3.14
//pi = 11 会报错
fmt.Println(pi)
// 批量声明
const (
A = "a"
B = "b"
)

fmt.Println(A, B)

//常量展开
const (
n1 = 100
n2
n3
n4
)
// 都是100
fmt.Println(n1, n2, n3, n4)

iota(常量计数器)

iota 是 Go 语言的一个特殊常量，它被设计用来简化累加数字的定义。你可以把它理解为 const 块中的行索引。通常用来做枚举、错误码、权限位、物理单位、状态机等。

`iota` 的基本行为

iota 在 const 关键字出现时将被重置为 0。
每新增一行常量声明，iota 就会自动累加 1。

  // 这里还使用了常量展开，学以致用。
  const (
Java = iota
Go
Rust
C
CPP
Python
)
   // 0,1,2,3,4,5
t.Log(Java, Go, Rust, C, CPP, Python)

如果像跳过某个值，可以使用如下方式：

const (
n1, n2 = iota + 1, iota + 2
n3, n4
n5, n6
)
   // 1 2 2 3 3 4
t.Log(n1, n2, n3, n4, n5, n6)

const (
       // 跳过0
_ = iota
n7
n8
       //跳过3
_
n9
)
   // 1 2 4
t.Log(n7, n8, n9)

iota 最强大的地方在于它不仅能代表数字，还能参与位运算。这在定义权限、状态位或文件单位时非常高效。

const (
READABLE   = 1 << iota // 1 << 0 = 1 (二进制 001)
WRITEABLE              // 1 << 1 = 2 (二进制 010)
EXECUTABLE             // 1 << 2 = 4 (二进制 100)
)
   t.Log(READABLE, WRITEABLE, EXECUTABLE)

还有存储单位：

const (
_  = iota
KB = 1 << (iota * 10) // 1 << (10*1) = 1024
MB = 1 << (iota * 10) // 1 << (10*2) = 1048576
GB = 1 << (iota * 10) // 1 << (10*2) = 1073741824
TB = 1 << (iota * 10) // 1 << (10*2) = 1099511627776
)
t.Log(KB, MB, GB, TB)

对于整形和浮点型，还有一个类型的问题：

无类型常量： const x = 123，它们具有“高精度”且没有固定类型，可以根据上下文自动转换。
类型化常量：如 const x int32 = 123。它的类型是死板的，只能与 int32 运算。

类型转换

Go 语言的类型转换遵循一个核心原则：显式大于隐式。它不支持像Java那样的括号强转(int) a，并且只有两种类型相互兼容时，才能转换（数值类型、或者对象底层结构相同）。

语法T(v)

Go 的类型转换非常直观，语法类似于函数调用：将变量 v 转换为类型 T。

// 直接用testing了，省得互相干扰
func Test_Convert(t *testing.T) {
var a int = 18
var b float64 = float64(a)
var c uint = uint(b)
t.Log(a, b, c)
t.Logf("%T,%T,%T", a, b, c)
}

main_test.go:80: 18 18 18
main_test.go:81: int,float64,uint

数值转换时，开发者必须亲自处理溢出和精度丢失的问题。

从浮点数转为整数时，小数部分会被直接截断，而不是四舍五入。

f := 3.9889
i := int(f)
// 3.9889 3
t.Log(f, i)

如果将大范围类型转换为小范围类型时，会发生截断。

var d int64 = 257
var e int8 = int8(d)
// 257 1
t.Log(d, e)

还有一个比较常见的场景，那就是字符串与切片的转换：

字符串与字节切片([]byte)

Go 的字符串底层就是字节数组，转换效率很高，但会发生内存拷贝（除非使用 unsafe 包）。

func Test_StringCovert(t *testing.T) {
s := "Hello Go语言"
b := []byte(s)
s2 := string(b)
    // Hello Go语言 [72 101 108 108 111 32 71 111 232 175 173 232 168 128] Hello Go语言
t.Log(s, b, s2)
}

字符串与字符切片（[]rune）

如果需要按字符（Unicode）处理中文，必须转为 []rune。

func Test_StringCovert(t *testing.T) {
s := "Hello Go语言"
b1 := []rune(s)
s3 := string(b1)
    // Hello Go语言 [72 101 108 108 111 32 71 111 35821 35328] Hello Go语言
t.Log(s, b1, s3)
}

字符串与数值的转换

从这里开始，之前的语法T(v)就不好使了。需要使用strconv这个包

package main
import (
"strconv"
"testing"
"unicode/utf8"
)

func Test_Str2Num(t *testing.T) {
a1 := 100

// int -> string
s1 := strconv.Itoa(a1)
//100: int ,100: string
t.Logf("%d: %T ,%s: %T", a1, a1, s1, s1)
// string -> int
a2, _ := strconv.Atoi(s1)
// 100: string, 100: int
t.Logf("%s: %T, %d: %T", s1, s1, a2, a2)

// 浮点数
f1 := 1.23554434344

// float -> string
// 需要指定精度和格式
    /**
第一个参数  float64
第二个参数  格式化类型：
   'f' 代表十进制 -ddd.dddd
'b' 代表二进制 -ddd.ddddp±ddd
'e'  代表科学计数法 -d.ddddde±ddd
'E'  代表科学计数法 -d.ddddE±ddd
'g'  代表十进制或科学计数法 -ddd.dddd
'G'  代表十进制或科学计数法 -ddd.ddddE±ddd
第三个参数  精度
第四个参数  精度范围 32 or 64
*/
sf1 := strconv.FormatFloat(f1, 'f', 2, 64)
// 1.235544: float64, 1.24: string
t.Logf("%f: %T, %s: %T", f1, f1, sf1, sf1)

// string -> float
f2, _ := strconv.ParseFloat(sf1, 64)
// 1.24: string, 1.240000: float64
t.Logf("%s: %T, %f: %T", sf1, sf1, f2, f2)

// bool
flag := true

// bool -> string
s2 := strconv.FormatBool(flag)
//true: bool, true: string
t.Logf("%t: %T, %s: %T", flag, flag, s2, s2)

// string -> bool

b1, err := strconv.ParseBool(s2)
if err == nil {
//true: string, true: bool
t.Logf("%s: %T, %t: %T", s2, s2, b1, b1)
}
}

看样子除了string<->int，其他的都是ParseT和FormatT，并且使用ParseT的时候，会返回多返回err，学习阶段使用匿名变量接收即可，实际开发中需要判断错误。

Go语言学习笔记（一）- 环境配置

2026-04-01T02:00:00.000Z

前言

2017年，简单的学习了一下Go语言，但苦于当时的工作没有办法实践，而我又刚换了工作，每天都要加班到最后一班地铁，没多久，学习的内容就基本上忘光光了，今年得空，可以在学习下Go语言，手头上也有两个项目有时间去重构，那就重新学习一次吧。本次学习使用go 1.26版本。

Go语言介绍

Go语言由Google开发，对于程序开发效率、并发、云原生等有非常好的支持。对于Java程序员来说，学习起来非常容易。

核心特性：天然并发（Goroutine）、强类型、编译速度极快、垃圾回收（GC）、静态链接成单个可执行二进制文件。
适用场景：云原生开发（Docker/K8s 均由 Go 编写）、微服务、系统工具、高性能网络服务。

GOROOT和GOPATH

对于Go新手还是有必要明确下这两个环境变量的含义，不然很容易纯靠字面意思搞错。

GOROOT，就是Go SDK的安装路径，不是go语言的项目路径，对于Java程序员来说，就是JDK的路径。

GOPATH，工作区路径，类似于Eclipse+maven的组合，将workspace和.m2合并在一个目录。最开始用起来老别扭了，不过从Go 1.11以后，就进入Go Modules时代。将GOPATH理解为maven的仓库，里面存放了不项目的不同依赖（以及同一个库的多个版本），Go Modules则负责隔离，每个项目可以存放在任意目录，并且根目录下有一个go.mod文件，记录该项目具体以来那个版本的库。

安装配置Go

对于Windows，推荐使用Scoop来安装管理

1	scoop install go

# 对于使用brew的用户
brew install go
# 对于使用port的用户
port install go

1 2	wget https://go.dev/dl/go1.26.1.linux-amd64.tar.gz tar -C /usr/local -xzf go1.26.1.linux-amd64.tar.gz

安装完成后，执行go version，如果能正确输出go版本号，那就说明安装成功（以上三种方式都不需要单独设置环境变量，其他方式请自行配置）。下面配置Go env，以Windows为例：

GOROOT=D:\Scoop\apps\go\current
GOPATH=D:\devtools\go

# 启用go module
go env -w GO111MODULE=on
go env -w GOPROXY=https://goproxy.cn,direct

除非你有特殊的目录洁癖，否则保持 GOBIN 为空，只需确保将 $(go env GOPATH)/bin 加入系统 PATH 即可。

对于新手最容易混淆的地方：

go build：在当前目录生成二进制文件。它不受 GOBIN 影响。
go install：将二进制文件编译并移动到 GOBIN（或默认的 bin）目录下。

配置完成后，执行go env查看是否正确。

编辑器选择

VS Code

对于喜欢轻量级的开发者来说，VS Code是最佳选择，使用VS Code开发Go，只需要安装go插件即可。安装完成后Ctrl + Shift + P，输入Go: Install/Update Tools，全选并安装，它会提供自动补全、调试等功能。按下F5即可调试程序，或者安装Code Runner插件，亦或者是在命令行中执行go run .。

GoLand（推荐）

由于我是Jetbrains的全家桶套餐订阅者，所以我更偏向于Goland，用起来更顺手。

Rust学习笔记

2026-03-26T02:00:00.000Z

从2024年简单的学习了下Rust后，就再也没怎么使用过，最近得闲，准备好好学习下rust。看了下之前记录的Rust笔记略显过时，倒不如从头再来，再学一遍！

安装Rust

下载rustup

和其他编程语言不同，安装Rust需要安装的是rustup，然后再利用rustup来安装Rust。这里就推荐使用官网的下载器来安装，我之前使用Scoop安装了rust，但是实际上它不过是个二进制的程序而已，并不满足rust开发。

打开官方文档安装 Rust - Rust 程序设计语言，在这里下载rustup-init.exe，下载后先不着急安装，配置项环境变量。

配置环境变量

这一步需要配置四个变量，分别是rustup和cargo安装的路径，以及加速器地址。打开设置 -> 高级系统设置 -> 环境变量，在用户变量中设置如下四个环境变量

# 安装路径，cargo类似于pypi，rustup类似于rust安装器
CARGO_HOME=D:\devtools\rust\cargo
RUSTUP_HOME=D:\devtools\rust\rustup

配置字节加速器，不然慢的要死

1 2	RUSTUP_DIST_SERVER="https://mirrors.ustc.edu.cn/rust-static" RUSTUP_UPDATE_ROOT="https://mirrors.ustc.edu.cn/rust-static/rustup"

1 2	RUSTUP_DIST_SERVER="https://mirrors.tuna.tsinghua.edu.cn/rustup" RUSTUP_UPDATE_ROOT="https://mirrors.tuna.tsinghua.edu.cn/rustup/rustup"

1 2	RUSTUP_DIST_SERVER="https://rsproxy.cn" RUSTUP_UPDATE_ROOT="https://rsproxy.cn/rustup"

安装

双击rustup-init.exe，会给你三个选项， Proceed with standard installation，输入1，然后安装即可。期间可能会弹出下载vs buildtools的界面。因为我以前就安装了，所以基本上都是在命令行中完成安装。

配置源

安装完成后，还需要配置crates-io源。创建配置文件： ~/.cargo/config.toml，然后填入如下内容：

[source.crates-io]
replace-with = 'ustc'

[source.ustc]
registry = "sparse+https://mirrors.ustc.edu.cn/crates.io-index/"

[registries.ustc]
index = "sparse+https://mirrors.ustc.edu.cn/crates.io-index/"

[source.crates-io]
replace-with = 'tuna'

[source.tuna]
registry = "sparse+https://mirrors.tuna.tsinghua.edu.cn/rust-lang/crates.io-index/"

[registries.tuna]
# 注意：确保这里的 URL 与上面的完全一致，且包含完整的稀疏协议前缀
index = "sparse+https://mirrors.tuna.tsinghua.edu.cn/rust-lang/crates.io-index/"

[source.crates-io]
replace-with = 'rsproxy-sparse'
[source.rsproxy]
registry = "https://rsproxy.cn/crates.io-index"
[source.rsproxy-sparse]
registry = "sparse+https://rsproxy.cn/index/"
[registries.rsproxy]
index = "https://rsproxy.cn/crates.io-index"
[net]
git-fetch-with-cli = true

添加完成后，测试

1	cargo search serde --registry ustc（tuna）

放弃nvm改换fnm

2026-03-21T02:00:00.000Z

今天用Claude调试以前的前端项目时，我需要使用nodejs14，按照往常的习惯直接使用nvm install 14，并且切换过去即可。但这次出问题了，我是用nvm use 14，虽然显示切换成功了，但使用node -v依旧显示的时nodejs 24的版本。后续折腾一番环境变量，终于可以切换了，但安装nodejs 14的时候又出幺蛾子了（实测nodejs 18就没问题），npm死活装不上，虽然可以通过手动下载等方式将其配置好，但也略嫌麻烦，于是就萌生了更换工具的想法。

对于Nodejs的版本管理工具，还有另外一个使用Rust实现的fnm。具体请查看Schniz/fnm: 🚀 Fast and simple Node.js version manager, built in Rust。我目前使用scoop来管理这些开发软件，所以安装也是极其方便。（别忘了先卸载nvm）

1	scoop install fnm

安装完成后，其命令几乎和nvm一样一样的。

# 安装node
fnm install 24
fnm install 14
# 切换版本
fnm use 14
# 查看安装了那些
fnm list
# 设置为默认版本
fnm default 24
# 卸载
fnm uninstall 18
# 查看当前使用的
fnm current
# 设置别名
fnm alias 14.21.3 project_name
# 使用别名
fnm use project_name
# 删除别名
fnm unalias project_name

和nvm替换全局不同，fnm仅仅对当前session有效。

所以，安装完成后，一般会有一段提示，让你再powershell的$PROFILE末尾配置如下：

# 配置 fnm 环境变量
fnm env --use-on-cd | Out-String | Invoke-Expression

# 如果是bash/zsh
eval "$(fnm env --use-on-cd)"

这个命令的作用就是进入目录后，如果当前目录存在.node-version（或者.nvmrc），并且里面是版本号时，就会自动切换到这个node版本，简直是健忘症的福音啊。所以我在每个前端的项目中，都创建了这个文件，并且指定版本：

# 在前端项目的根目录，请千万注意，不要把文件名搞成.node_version，我因为这个问题和AI讨论了一下午，AI都开始怀疑是PWS的问题了。
nvim .node-version
# 填入一个版本号，例如：
14

这样，打开不同的前端项目就会自动的切换到指定版本。

它的检测顺序是：

.node-version文件
.nvmrc文件
package.json中的engines.node字段（需启用--resolve-engines）

当然，也可以零时使用某个版本来执行命令，并且不会影响已经使用其他版本运行的项目。

1	fnm exec --using=14 node index.js

这是 fnm 和 nvm-windows 最大的技术区别：

nvm：通过修改系统的全局 Path 和创建硬链接来工作，容易被其他软件抢占优先级。
fnm：当你执行 fnm use 时，它只在当前的 PowerShell 会话（窗口）里临时修改 Path。
意义：这意味着你可以在窗口 A 开着 Node 14 跑老代码，窗口 B 开着 Node 24 跑新代码，互不干扰。

使用wsl安装Linux系统

2026-03-19T06:00:00.000Z

中午无聊，打算装两个Linux玩玩，我选择了Fedora42和Arch，这两个系统在WSL中式支持的，但默认安装在C盘，还得再导出导入一次才能换到其他盘，那何必多此一举，直接导入到其他盘即可。下面介绍下本次安装的过程。

系统包准备

Fedora42 ，Fedroa42 下载地址
ArchLinux，ArchLinux下载地址

打开Fedora下载地址，Fedora官方支持WSL的镜像，所以只需要下载Fedora-WSL-Base-42-1.1.x86_64.tar.xz即可。

打开ArchLinux下载地址，Arch官方没有WSL的镜像，我们下载archlinux-bootstrap-x86_64.tar.zst，然后在任意一个Linux中使用zstd命令将其转换为tar包。以Ubuntu为例

1
2
3

sudo apt install zstd
# 解压 zst 并打包为 tar
zstd -d archlinux-bootstrap-x86_64.tar.zst

ArchLinux默认会比其他发行版多一层目录root.x86_64，所以这个包还需要再处理下才行，不能直接导入。

# 创建临时目录
mkdir temp_arch
# 解压到该目录
sudo tar -xvf archlinux-bootstrap-x86_64.tar -C temp_arch
# 重新打包
cd temp_arch/root.x86_64
sudo tar -cvf ../../arch_fixed.tar .

# 清理临时文件
cd ../..
rm -rf temp_arch

# 将其拷贝到Window硬盘中
cp arch_fixed.tar /mnt/e/Downloads

导入Linux系统

分别创建两个目录E:\WSL\Fedora42和E:\WSL\Arch，在PowerShell中执行如下：

1
2
3

mkdir e:\WSL\Fedora42

mkdir e:\WSL\Arch

导入系统

# 导入Fedora42
wsl --import Fedora42 E:\WSL\Fedora42 E:\Downloads\Fedora-WSL-Base-42-1.1.x86_64.tar.xz

# 导入ArchLinux
wsl --import Arch E:\WSL\Arch E:\Downloads\arch_fixed.tar

启动系统

使用wsl命令启动这两个系统，后面的参数就是wsl系统的名称，也就是上一步--import后面的那个名字。

1
2
3

wsl -d Fedora42

wsl -d Arch

默认是root启动，还需要再次配置。

配置WSL系统

接着就是对系统的初始化配置了

配置Fedora42

1.安装基础工具

1	dnf install -y sudo passwd ncurses findutils

2.创建普通用户

1 2	useradd -m -G wheel yourusername passwd yourusername

3.配置wsl默认使用新建的用户登录

cat <<EOF > /etc/wsl.conf
[boot]
systemd=true
[user]
default=yourusername 
[network]
generateHosts = true
generateResolvConf = true
EOF

4.检查dnf状态

1	dnf --version

5.设置源

1
2
3

sudo sed -e 's|^metalink=|#metalink=|g' \
         -e 's|^#baseurl=http://download.example/pub/fedora/linux|baseurl=https://mirrors.tuna.tsinghua.edu.cn/fedora|g' \
         -i.bak /etc/yum.repos.d/fedora*.repo

6.更新缓存

1	dnf makecache

7.设置并发下载

1	echo "max_parallel_downloads=10" \| tee -a /etc/dnf/dnf.conf

8.关闭防火墙

1 2	systemctl stop firewalld systemctl disable firewalld

9.安装字体

1	dnf install -y google-noto-fonts-common

如果把它当centos使用，可以安装开发工具包

1 2	dnf groupinstall "Development Tools" -y && \ dnf install -y golang java-latest-openjdk-devel nodejs git neofetch htop

为了避免新创建的用户无法使用sudo命令，可以用root执行visudo。找到下面的配置

1	%wheel ALL=(ALL) ALL

确认是没备注是的，它可以允许所有属于wheel组的用户执行任何命令。

然后退出Fedroa42，执行wsl --shutdown，再次打开就可以使用刚才配置的用户登陆了。

10.安装fastfetch

1
2
3

sudo dnf install -y fastfetch
# 如果你想每次登录都显示，那就加进去。
echo "fastfetch" >> ~/.bashrc

过程中可能会遇到一个错误No valid source (baseurl, mirrorlist or metalink) found for repository "fedora-cisco-openh264"

这个需要编辑/etc/yum.repos.d/fedora-cisco-openh264.repo

1	sudo vi /etc/yum.repos.d/fedora-cisco-openh264.repo

将里面的 enable=1全部修改为enable=0，然后保存退出

配置Arch

大致和Fedroa42类似，但也有特殊的地方。注意，此时登陆的用户是root

1.初始化pacman-key

1
2
3

pacman-key --init
pacman-key --populate archlinux
pacman -Syu

2.配置源

1	echo "Server = https://mirrors.tuna.tsinghua.edu.cn/archlinux/\$repo/os/\$arch" \| tee /etc/pacman.d/mirrorlist

然后再次执行

1 2	pacman-key --init pacman-key --populate archlinux

3.安装基础工具包

archlinux，默认连vi、sudo都没装

1	pacman -S base-devel git vim go

4.创建用户

1 2	useradd -m -G wheel yourusername passwd yourusername

注意：archlinux的wheel组不能直接执行sudo。

5.配置wsl

cat <<EOF > /etc/wsl.conf
[boot]
systemd=true
[user]
default=yourusername 
EOF

6.配置sudo

使用当前用户root，执行visudo，找到%wheel ALL=(ALL:ALL) ALL，将前面的#删掉。

如果忘记执行这一步就重启使用新用户登录，就会提示yourusername is not in the sudoers file.可以在powershell中执行wsl -u root -d Arch，使用root用户登录，然后用root用户修改即可。

7.确认id

1	id -u yourusername

8.设置语言

vi /etc/locale.gen

# 将下面的注释放开
en_US.UTF-8 UTF-8
zh_CN.UTF-8 UTF-8

编译语言包

1	locale-gen

设置全局生效

1	echo "LANG=en_US.UTF-8" > /etc/locale.conf # 多年经验，还是英文好点

9.安装其他工具包

ArchLinux是高度定制化的，啥都要自己装

pacman -S base-devel sudo git wget curl bash-completion net-tools iputils

# 显示系统信息
pacman -S fastfetch

然后退出系统，再重新登录，就是刚才新建的用户了。

配置PowerShell及配色

一般Windows会自动识别，然后自动创建PowerShell的配置，但也是有延迟的，我都是配置完了才识别出来。由于我已经配好了Debian和Ubuntu，那就直接复制就行，然后改一下名称、图标、启动命令。

按ctrl+,打开设置，找到左侧菜单中的配置文件，点击+ 添加新配置文件，然后选择复制，复制一个你配置好的即可。

复制后，点击刚才复制的配置，修改一下。

系统默认会识别出来的，其中Fedroa系统会有自己的图标，ArchLinux没有，使用的默认WSL的图标。再命令行那里，系统识别出来的是C:\WINDOWS\system32\wsl.exe --distribution-id {897ed9c5-dc17-4a23-a17a-45719d59c52b} --cd ~，但其实我更推荐使用-d 系统名称，这样即使删掉在创建，只要名字一样，这个配置就会一直有用。注意这个名字是 --import 后面的这个名字。

不同系统都会有自己独特的配色，例如Ubuntu有个茄子配色，Fedroa是蓝色的，suse是绿色的，下面分享一下我得配色。在PowerShell中，按下快捷键Ctrl + Shift + ,打开Windows Terminal 的 settings.json，在 "schemes" 数组中添加：

{
    "background": "#002B36",
    "black": "#073642",
    "blue": "#268BD2",
    "brightBlack": "#002B36",
    "brightBlue": "#839496",
    "brightCyan": "#93A1A1",
    "brightGreen": "#586E75",
    "brightPurple": "#6C71C4",
    "brightRed": "#CB4B16",
    "brightWhite": "#FDF6E3",
    "brightYellow": "#657B83",
    "cursorColor": "#D33682",
    "cyan": "#2AA198",
    "foreground": "#839496",
    "green": "#859900",
    "name": "Debian-Official",
    "purple": "#D33682",
    "red": "#DC322F",
    "selectionBackground": "#073642",
    "white": "#EEE8D5",
    "yellow": "#B58900"
},
{
    "background": "#0B1D35",
    "black": "#000000",
    "blue": "#294172",
    "brightBlack": "#676767",
    "brightBlue": "#31609A",
    "brightCyan": "#51A2DA",
    "brightGreen": "#49A62A",
    "brightPurple": "#A181BC",
    "brightRed": "#F66151",
    "brightWhite": "#FFFFFF",
    "brightYellow": "#D6BAAD",
    "cursorColor": "#51A2DA",
    "cyan": "#226A9C",
    "foreground": "#D1D1D1",
    "green": "#3E7B28",
    "name": "Fedora-DeepBlue",
    "purple": "#75507B",
    "red": "#C01C28",
    "selectionBackground": "#1B3456",
    "white": "#D1D1D1",
    "yellow": "#B58900"
},
{
    "background": "#300A24",
    "black": "#2E3436",
    "blue": "#3465A4",
    "brightBlack": "#555753",
    "brightBlue": "#729FCF",
    "brightCyan": "#34E2E2",
    "brightGreen": "#8AE234",
    "brightPurple": "#AD7FA8",
    "brightRed": "#EF2929",
    "brightWhite": "#EEEEEC",
    "brightYellow": "#FCE94F",
    "cursorColor": "#FFFFFF",
    "cyan": "#06989A",
    "foreground": "#FFFFFF",
    "green": "#4E9A06",
    "name": "Ubuntu-Official",
    "purple": "#75507B",
    "red": "#CC0000",
    "selectionBackground": "#B6B6B6",
    "white": "#D3D7CF",
    "yellow": "#C4A000"
},
{
    "name": "Arch-Carbon",
    "background": "#121212",
    "black": "#1C1C1C",
    "blue": "#5FAFD7",
    "cyan": "#5FAF87",
    "foreground": "#D0D0D0",
    "green": "#87AF87",
    "purple": "#AF87AF",
    "red": "#AF5F5F",
    "white": "#E4E4E4",
    "yellow": "#D7AF5F",
    "cursorColor": "#1793D1"
}

这四个配色，下面就以Fedroa为例看下效果，在PowerShell中，按快捷键Ctrl + ,，打开设置，找到Fedora42的配置文件，在其他设置->外观中选择刚才添加的配置名称Fedora-DeepBlue，然后再次登录查看效果。

后续再给每个系统安装个oh-my-zsh美化下就好了。

使用Rclone备份数据到CloudFlare R2

2026-03-18T12:00:00.000Z

接上一篇，将能迁移的服务都迁移到PostgreSQL后，再配置上自动备份脚本，基本上就可以高枕无忧了，本来想备份到阿里云OSS的，想了想本站几乎是ALL IN Cloudflare，那就直接备份到CloudFlare R2吧，正好也快一点。下面就记录下备份的方法。

创建CloudFlare R2桶

在面板首页->存储和数据库 -> R2对象存储中，创建一个桶，我起的名字就是backup。

创建完成后发，返回桶列表，点击右下角的Account Deatails下面的Manage，按钮，创建一个Token。

1、权限必须是管理员读和写，选对象读和写执行rclone命令会报权限错误。

2、因为1，所以最好将客户端IP限制一下，反正VPS都是静态的IP地址，不然要是被泄露了那就完犊子了~

创建好后，给你三个信息，分别是访问密钥 ID（access_key_id）、机密访问密钥（secret_access_key）、为 S3 客户端使用管辖权地特定的终结点(endpoint)。暂时记录下来，下一步要用。

安装Rclone

要备份到CloudFlare R2，那就需要Rclone，执行下面的命令安装即可。

1	apt install rclone

安装完成后，执行rclone config就可以配置了，不过控制台看着乱糟糟的，我直接选创建配置文件的方式了。

1	touch ~/.config/rclone/rclone.conf

然后在里面填写如下信息：

[r2-remote]
type = s3
provider = Cloudflare
access_key_id = <你的访问密钥>
secret_access_key = <你的机密访问密钥>
# 注意，不要带桶名称
endpoint = https://.r2.cloudflarestorage.com
no_check_bucket = true

配置完成后，执行如下命令进行测试：

# 执行
rclone listremotes
# 输出 
r2-remote:

# 执行
rclone lsd r2-remote: -vv
# 输出
# 你自己的桶，其中需要包含刚才创建的

配置脚本

PostgreSQL

在/data/script/中创建pgsql-to-r2.sh文件，内容如下：

#!/bin/bash

# --- 配置区 ---
CONTAINER_NAME="postgresql"
DB_USER="postgres"
BACKUP_DIR="/data/backups/pgsql"
DATE=$(date +%Y%m%d_%H%M%S)
FILE_NAME="pg_all_backup_$DATE.sql.gz"
R2_BUCKET="r2-remote:backup" # rclone 配置名:桶名(backup就是刚才创建的桶)
RETENTION_DAYS=7

# --- 执行备份 ---
mkdir -p $BACKUP_DIR

echo "开始导出 ..."
docker exec -t $CONTAINER_NAME pg_dumpall -c -U $DB_USER | gzip > $BACKUP_DIR/$FILE_NAME

# --- 上传到 R2 ---
echo "正在上传 $FILE_NAME 到 Cloudflare R2..."
rclone copy $BACKUP_DIR/$FILE_NAME $R2_BUCKET/pgsql_daily/

# --- 清理旧数据 ---
echo "清理 $RETENTION_DAYS 天前的本地备份..."
find $BACKUP_DIR -mtime +$RETENTION_DAYS -exec rm {} \;

# --- 可选：清理 R2 上的旧备份 (需要 R2 支持 lifecycle 或用 rclone delete) ---
# rclone delete $R2_BUCKET --min-age ${RETENTION_DAYS}d --dry-run

echo "备份任务完成！"

测试

1	bash pgsql-to-r2.sh

MySQL

在/data/script/中创建mysql-to-r2.sh文件，内容如下：

#!/bin/bash

# --- 1. 配置区 ---
CONTAINER_NAME="db"  # 你的 MySQL 容器名
DB_USER="root"
DB_PASSWORD="password"  
BACKUP_DIR="/data/backups/mysql"
DATE=$(date +%Y%m%d_%H%M)
R2_REMOTE="r2-remote:backup" 
RETENTION_DAYS=7

# 需要备份的数据库列表
DATABASES=("db1" "db2")

# --- 2. 准备工作 ---
mkdir -p $BACKUP_DIR
echo "[$DATE] 开始执行 MySQL 分库备份..."

# --- 3. 循环备份 ---
for DB in "${DATABASES[@]}"; do
    FILE_NAME="${DB}_${DATE}.sql.gz"
    echo "正在备份 MySQL 数据库: $DB..."
    
    # 使用 mysqldump 并直接 gzip 压缩
    # --single-transaction: 保证备份期间不锁表（针对 InnoDB）
    # --routines: 备份存储过程和函数
    docker exec $CONTAINER_NAME mysqldump -u$DB_USER -p$DB_PASSWORD \
        --single-transaction --routines --databases $DB | gzip > $BACKUP_DIR/$FILE_NAME
    
    if [ ${PIPESTATUS[0]} -eq 0 ]; then
        echo "上传 $FILE_NAME 到 R2..."
        rclone copy $BACKUP_DIR/$FILE_NAME $R2_REMOTE/mysql_daily/
    else
        echo "错误: $DB 备份失败！"
    fi
done

# --- 4. 清理 ---
find $BACKUP_DIR -mtime +$RETENTION_DAYS -exec rm {} \;
echo "MySQL 备份任务完成。"

执行测试

1	bash mysql-to-r2.sh

配置定时计划

1	cronteb -e

填写如下内容：

# 凌晨 02:00 备份 PostgreSQL
0 2 * * * /bin/bash /data/script/pgsql-to-r2.sh >> /var/log/pg_backup.log 2>&1

# 凌晨 03:00 备份 MySQL
0 3 * * * /bin/bash /data/script/mysql-to-r2.sh >> /var/log/mysql_backup.log 2>&1

配置对象生命周期规则

数据库文件比较小，乐意放几天放几天。我的习惯，30天肯定至少要访问一次的，所以就30天了。

升级umami-mysql到v3-postgresql

2026-03-18T03:00:00.000Z

今天抽空，将自己维护的服务都升级了一下，看了下umami从v3开始就不再支持MySQL，而我目前是用MySql版本的，本着用新不用旧、能早升级早升级的理念，那就只能升级加迁移数据库了，下面分享下过程。

导出MySql的数据

直接在宿主机执行

1 2	docker exec -i db mysqldump --no-create-info --default-character-set=utf8mb4 --quick --skip-add-locks \ -u root -p umamidb > /tmp/mydbdump.sql

根据自己习惯来。

定义环境变量

在docker-compose.yaml同级目录下，创建init-db目录，里面创建一个文件init.sql。内容如下：

-- Umami的数据库初始化脚本
CREATE USER umamiuser WITH PASSWORD 'password';
ALTER USER umamiuser CREATEDB;
CREATE DATABASE umamidb OWNER umamiuser;

-- Waline 的数据库初始化脚本
CREATE USER waline_user WITH PASSWORD 'password';
ALTER USER waline_user CREATEDB;
CREATE DATABASE waline_db OWNER waline_user;

在docker-compose.yaml同级目录下，编辑.env文件（没有就创建）

MYSQL_ROOT_PASSWORD=password
MYSQL_USER=username
MYSQL_PASSWORD=password

# PG
POSTGRES_PASSWORD=password
POSTGRES_USER=postgres
POSTGRES_UMAMI_PWD=password
POSTGRES_WALINE_PWD=password
# SMTP
SMTP_PWD=password

# umami
UMAMI_APP_SECRET=NiMZovEXm2dYdSfHb47sLcljvjFnPesxxxxxxxxxxxx
UMAMI_DATABASE_URL=postgresql://umamiuser:password@db-pg:5432/umamidb

# waline
WL_JWT_TOKEN=31HHvaaXFJ984pLc2iCxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
WL_AKISMET_KEY=a93dxxxxxxxxxxxxxx
WL_PG_USER=waline_user
WL_PG_DB=waline_db
WL_TURNSTILE_KEY=0x4AAxxxxxxxxxxxxxxxxxx
WL_TURNSTILE_SECRET=0x4AAAxxxxxxxxxxxxxxxxxxxxxx

执行docker compose config，确认下配置是否生效

修改docker-compose.yaml

在docker-compose.yaml中新增postgresql，并将原来的umami替换为postgresql版本。

services:
  db:
    image: mysql:8.4
    container_name: db
    restart: unless-stopped
    env_file: .env
    volumes:
      - dbdata:/var/lib/mysql
    healthcheck:
      test: ["CMD", "mysqladmin", "ping", "-h", "localhost", "-u", "hc_user", "--password=yourpassword"]
      interval: 5s
      timeout: 5s
      retries: 10
      start_period: 10s # 给 MySQL 10秒的宽限期执行初始化
    networks:
      - app-network
  db-pg:
    image: postgres:17-alpine
    container_name: postgresql
    restart: unless-stopped
    environment:
      POSTGRES_USER: postgres
      POSTGRES_PASSWORD: $POSTGRES_PASSWORD
      POSTGRES_DB: postgres
    volumes:
      - pg-data:/var/lib/postgresql/data
      - ./init-db:/docker-entrypoint-initdb.d
    healthcheck:
      test: ["CMD-SHELL", "pg_isready -U postgres -d postgres"]
      interval: 5s
      timeout: 5s
      retries: 5
    networks:
      - app-network

  wordpress:
    depends_on:
      - db
    image: wordpress:6.8.3-php8.4-fpm-alpine
    container_name: wordpress
    restart: unless-stopped
    env_file: .env
    environment:
      - WORDPRESS_DB_HOST=db:3306
      - WORDPRESS_DB_USER=$MYSQL_USER
      - WORDPRESS_DB_PASSWORD=$MYSQL_PASSWORD
      - WORDPRESS_DB_NAME=wordpress
    volumes:
      - wordpress:/var/www/html
      - ./php-config/custom.ini:/usr/local/etc/php/conf.d/custom.ini
    networks:
      - app-network

  vps:
    depends_on:
      - db
    image: wordpress:6.8.3-php8.4-fpm-alpine
    container_name: wp-vps
    restart: unless-stopped
    env_file: .env
    environment:
      - WORDPRESS_DB_HOST=db:3306
      - WORDPRESS_DB_USER=wp-vps
      - WORDPRESS_DB_PASSWORD=$MYSQL_PASSWORD
      - WORDPRESS_DB_NAME=wp_vps
    volumes:
      - wp-vps:/var/www/html
      - ./php-config/custom.ini:/usr/local/etc/php/conf.d/custom.ini
    networks:
      - app-network

  webserver:
    depends_on:
      - wordpress
      - vps
      - umami
      - waline
    image: nginx:1.28.0-alpine
    container_name: webserver
    restart: unless-stopped
    ports:
      - "80:80"
      - "443:443"
    volumes:
      - wordpress:/var/www/html
      - wp-vps:/var/www/wp-vps
      - umami-data:/var/www/umami
      - waline-data:/var/www/waline
      - ./nginx-conf:/etc/nginx/conf.d
      - certbot-etc:/etc/letsencrypt
    networks:
      - app-network

  umami:
    depends_on:
      db-pg:
        condition: service_healthy
    image: ghcr.io/umami-software/umami:postgresql-latest
    container_name: umami
    restart: unless-stopped
    expose:
      - '3000'
    environment:
      DATABASE_URL: ${UMAMI_DATABASE_URL}
      DATABASE_TYPE: postgresql
      APP_SECRET: ${UMAMI_APP_SECRET}
    networks:
      - app-network
  
  waline:
    image: lizheming/waline:latest
    container_name: waline
    restart: always
    expose:
      - "8360"
    volumes:
      - waline-data:/app/data
    environment:
      TZ: 'Asia/Shanghai'
      # 数据库设置
      PG_HOST: 'db-pg'
      PG_PORT: '5432'
      PG_DB: '${WL_PG_DB}'
      PG_USER: '${WL_PG_USER}'
      PG_PASSWORD: '${POSTGRES_WALINE_PWD}'
      SITE_NAME: '码农笔记'
      SITE_URL: 'https://tech.tvzr.com'
      SECURE_DOMAINS: 'tech.tvzr.com,waline.tvzr.com'
      AUTHOR_EMAIL: 'me@tvzr.com'
      IPQPS: 20
      JWT_TOKEN: '${WL_JWT_TOKEN}'
      LEVELS: '0,10,20,50,100,200'
      AKISMET_KEY: '${WL_AKISMET_KEY}'
      #TURNSTILE_KEY: '${WL_TURNSTILE_KEY}'
      #TURNSTILE_SECRET: '${WL_TURNSTILE_SECRET}'
      SMTP_HOST: 'mail.tvzr.com'
      SMTP_PORT: '465'
      SMTP_USER: 'no.reply@tvzr.com'
      SMTP_PASS: '${SMTP_PWD}'
      SMTP_SECURE: 'true'
      SENDER_NAME: '码农笔记'
    depends_on:
      db-pg:
        condition: service_healthy
    networks:
      - app-network

  certbot:
    depends_on:
      - webserver
    image: certbot/certbot
    container_name: certbot
    volumes:
      - certbot-etc:/etc/letsencrypt
      - wordpress:/var/www/html
      - wp-vps:/var/www/wp-vps
      - umami-data:/var/www/umami
      - waline-data:/var/www/waline
    command: >
      certonly --webroot 
      --non-interactive 
      --expand
      -w /var/www/html -d tvzr.com 
      -w /var/www/wp-vps -d vps.tvzr.com 
      --email iat@outlook.com 
      --agree-tos 
      --no-eff-email 
      --force-renewal

volumes:
  certbot-etc:
  wordpress:
  dbdata:
  wp-vps:
  umami-data:
  waline-data:
  pg-data:

networks:
  app-network:
    driver: bridge

重新启动docker compose

在docker-compose.yml目录，执行

# 停止
docker compose down

# 启动
docker compose up -d
# 此时会自动拉取最新的镜像

启动时，umami会自动检测到URL变更，并且自动初始化所需要的表。

可以通过docker logs -f umami查看日志，如果日志中出现如下，即代表初始化运行完成：

All migrations have been successfully applied.

✓ Database is up to date.

> umami@3.0.3 update-tracker /app
> node scripts/update-tracker.js


> umami@3.0.3 start-server /app
> node server.js

   ▲ Next.js 15.5.9
   - Local:        http://localhost:3000
   - Network:      http://0.0.0.0:3000

 ✓ Starting...
 ✓ Ready in 1235m

转换mysql导出的表

mysql导出的表不能直接给postgresql使用，可以参考官网的方案进行处理。将MySQL迁移到PostgreSQL

用双引号替换反勾号，使其兼容PostgreSQL。

1	sed -i 's/`/"/g' mydbdump.sql

清空postgresql的数据

如果直接导入，会提示如下错误：

INSERT 0 13
INSERT 0 201
INSERT 0 1
INSERT 0 2
ERROR:  duplicate key value violates unique constraint "user_pkey"
DETAIL:  Key (user_id)=(41e2b680-648e-4b09-bcd7-3e2b10c06264) already exists.
INSERT 0 1
INSERT 0 38

看日志是里面的主键重复，因为初始化的时候会创建一条数据，我们需要先清空表数据。执行下面的语句

1 2	docker exec -i psql -U umamiuser -d umamidb -c "TRUNCATE TABLE \"user\", \"session\", \"website\", \"team\", \"team_user\", \"_prisma_migrations\" CASCADE;" TRUNCATE TABLE

导入数据到postgresql

1	docker exec -i postgresql psql -U umamiuser -d umamidb < /tmp/mydbdump.sql

此时就可以正常导入数据了。

INSERT 0 13
INSERT 0 201
INSERT 0 1
INSERT 0 2
INSERT 0 2
INSERT 0 1
INSERT 0 386

升级完成

到这里就升级完成了，整个过程还是比较简单和顺利的。对比之前，我就需要多运行一个postgresql容器，不过也没有占用多少资源。

CONTAINER ID   NAME         CPU %     MEM USAGE / LIMIT    MEM %     NET I/O           BLOCK I/O         PIDS 
520d2037e3b8   webserver    0.00%     9.168MiB / 3.83GiB   0.23%     12.6MB / 14.3MB   9.34MB / 4.1kB    4 
1857b85d681c   umami        0.00%     229.4MiB / 3.83GiB   5.85%     1.15MB / 2.09MB   41.5MB / 16.4kB   44 
4c2f0afb1926   waline       0.00%     169MiB / 3.83GiB     4.31%     33.2kB / 14.3kB   67.1MB / 4.1kB    18 
99783b642219   postgresql   0.02%     33.93MiB / 3.83GiB   0.87%     202kB / 120kB     7.67MB / 88.4MB   7 
f35027f6d422   db           1.26%     460MiB / 3.83GiB     11.73%    8.06MB / 119MB    941MB / 163MB     47

ServicePointManager不支持具有socks5方案的代理

2026-03-17T04:00:00.000Z

最近将大部分的开发工具都由WinGet替换为scoop了，一切配置妥当后今天发现给GitHub提交代码时，需要重新验证账号，但通过浏览器认证后一直提示一个错误：fatal: ServicePointManager 不支持具有 socks5 方案的代理，我配置代理一般都是http_proxy，因为它兼容性更好，但此时出现的错误又的确是socks5的问题，想来是多年前配置的了，一直使用也没啥问题，后来我删除了credential中的github账号信息，又出现了这个问题。

解决方案

出现这个问题也比较容易解决，只需要查看下git config，看下都是哪里配置了socks5协议的代理。

1	git config --global --list

输出如下：

1 2	http.https://github.com.proxy=socks5://127.0.0.1:1080 http.https://github.com.proxy=socks5://127.0.0.1:1080

将其覆盖一下即可，我本地监听端口是1080，一般默认的是7890，根据自己实际情况修改。

1
2
3

git config --global http.proxy 'http://127.0.0.1:1080'
git config --global https.proxy 'http://127.0.0.1:1080'
git config --global http.https://github.com.proxy 'http://127.0.0.1:1080'

GitHub账号配置

我本地是配置了ssh-key的，不过也有大量的https://的github项目，懒得一一修改了。直接在GitHub点击头像 -> settings -> Developer settings（最下面） -> Personal access tokens -> Tokens(classic)中，点击右上脚的Generate new token按钮，选择Generate new token(classic)，创建新的Token，输出2FA密码后，权限只需要全选repo即可，有效期就一年吧。将生成的token作为GitHub的密码填入即可。

Username for 'https://github.com': xxx    
Password for 'https://xxx@github.com': 
Enumerating objects: 5, done.
Counting objects: 100% (5/5), done.
Delta compression using up to 20 threads

Git其他配置优化

开启安全验证

因为以前公司的Git仓库都是自己签发的证书，所以我关闭了http.sslVerify，现在都是使用GitHub，索性就全部打开吧。

1 2	# 开启全局安全验证 git config --global http.sslVerify true

当然，以后可能还会使用局域网内部的git服务，那就到时候根据地址单独配置即可。

1
2
3

# 给内网地址关闭安全验证
git config --global http."https://10.254.32.11/".sslVerify false
git config --global http."http://10.40.60.22/".sslVerify false

美化log输出

你现在的 git log 应该是默认的黑白列表。既然用了 pwsh (PowerShell Core) 和图标字体，可以加一个酷炫的多彩 Graph 视图。

添加一个别名 git lg：

1	git config --global alias.lg "log --color --graph --pretty=format:'%Cred%h%Creset -%C(yellow)%d%Creset %s %Cgreen(%cr) %C(bold blue)<%an>%Creset' --abbrev-commit"

性能和格式

# 1. 性能起飞：开启 fsmonitor
git config --global core.fsmonitor true

# 2. 路径支持
git config --global gui.encoding utf-8

# 3. 换行符处理（Windows 必备，防止拉取代码后全是修改）
git config --global core.autocrlf true

# 4. 开启更智能的合并策略
git config --global pull.rebase true

Windows Scoop工具常见错误及处理方式

2026-03-16T04:54:53.000Z

最近也是将大量的软件管理从WinGet切换到scoop，WinGet总是出现一些幽灵链接，虽然可以通过注册表扫描等方式将其修复，个人还是很反感注册表。索性将能用scoop管理的也都用scoop管理，不过在使用过程中，还是遇到了一点点问题，也是比较容易解决。

由于连接方在一段时间后没有正确答复或连接的主机没有反应，连接尝试失败。

这个问题应该也比较容易遇到，本质上就是万恶的GFW，导致某些资源无法连接（S3、google cloud等），这里需要来一手代理即可。

1	scoop config proxy 127.0.0.1:1080

如果想取消，则执行下面的命令

1	scoop config rm proxy

Couldn’t find manifest for ‘xxx’

安装miniconda时会出现这个错误是因为 miniconda3 不在 Scoop 的 Main（核心）软件库中，它被收录在专门存放编程相关工具的 Extras 软件库里。只需要添加一下即可。

1
2
3

scoop bucket add extras
// 然后重新安装
scoop install miniconda3

Token might be misconfigured

很久以前就安装了scoop，但是那个时候只用来管理字体，所以也是很久没正经用过了。为了更新字体的版本，出现了如下这个错误

JetBrainsMono-NF: 2.1.0 -> 3.4.0

Updating one outdated app:

Updating 'JetBrainsMono-NF' (2.1.0 -> 3.4.0)

Downloading new version

WARN  Token might be misconfigured.

OperationStopped: C:\Users\xxx\scoop\apps\scoop\current\lib\download.ps1:84

Line 

  84           throw $e

               ~~~~~~~~

      Response status code does not indicate success: 401 (Unauthorized).

看样子是github token过期了，后来申请了新的token，通过如下方式配置后，发现还是不行：

1	scoop config github_token <你的Token内容>

搜索一番后，发现以前配置的似乎是gh_token ，于是将其删除后问题解决。当时也忘记了为啥要配置这个了。

1	scoop config rm gh_token

后面遇到了，再更新~

给Debian服务器上的OpenClaw安装浏览器

2026-03-13T08:17:31.000Z

通过前文配置后OpenClaw后，如果需要运行一些自动化任务、抓取数据等需求还需要通过浏览器来实现。但是默认debian是没有安装的浏览器的，本篇介绍下如何给Debian安装浏览器，并且配置到OpenClaw中。

下载Chrome浏览器

对于Debian/Ubuntu发行版

1	wget https://dl.google.com/linux/direct/google-chrome-stable_current_amd64.deb

对于CentOS/RHEL发行版

1	wget https://dl.google.com/linux/direct/google-chrome-stable_current_x86_64.rpm

一般deb和rpm包就覆盖了国内大部分用户的发行版。这个地址是可以直接连接的。

安装浏览器和字体

对于Debian/Ubuntu发行版

1	sudo apt install -y ./google-chrome-stable_current_amd64.deb

对于CentOS/RHEL发行版

1
2
3

sudo yum install -y liberation-fonts
sudo yum install -y xdg-utils
sudo yum localinstall -y ./google-chrome-stable_current_x86_64.rpm

安装Google Noto Sans CJK（思源黑体）的字体文件，为了避免浏览器字体确实无法显示，需要单独安装字体

// debian/ubuntu
sudo apt install -y fonts-noto-cjk
// CentOS/RHEL
sudo yum install -y google-noto-sans-cjk-fonts

安装完成后，验证浏览器版本

1
2
3

google-chrome --version

Google Chrome 146.0.7680.75

配置OpenClaw

使用独立浏览器

1	openclaw config set browser.defaultProfile "openclaw"

使用Headless模式（服务器上没显示器~）

1	openclaw config set browser.headless true

禁用沙盒模式

避免因权限安全机制无法启动

1	openclaw config set browser.noSandbox true

设置 Chrome 可执行文件路径

1	openclaw config set browser.executablePath "$(which google-chrome)"

重启 openclaw gateway

1	openclaw gateway restart

为 openclaw 打开浏览器

1	openclaw browser start

执行命令后，会有如下内容打印：

1	🦞 browser [openclaw] running: true

没注意看，也可以通过如下命令检查

1	openclaw browser status

使用QQ Bot测试一下

让其截图一下试试

还能修正一下错别字~

Debian安装OpenClaw

2026-03-06T05:42:22.000Z

环境安装

以Debian为例，配置好SSH-KEY（本机 -> 服务器免密码登录），提前注册号阿里云百炼模型、Kimi模型、DeepSeek模型、bigmodel(GLM)等模型的账号，该实名实名，该充值充值（Kimi充值才能解速）。

安装nvm

sudo apt update 
sudo apt upgrade 
// 安装依赖
sudo apt install build-essential libssl-dev 
// 安装nvm
curl -o- https://raw.githubusercontent.com/nvm-sh/nvm/master/install.sh  bash 
// 重新打开session即可。
// 安装nodejs 24
nvm install 24
// 切换到nvm
nve use 24

安装git

1	sudo apt install git -y

安装OpenClaw

本篇使用npm的方式安装

如果你的服务器没有配置ssh-key到github，那么你还需要配置一下，将ssh替换为https

1 2	git config --global url."https://github.com/".insteadOf ssh://git@github.com/ git config --global url."https://".insteadOf git://

然后再进行安装

1
2
3

npm install -g openclaw@latest

openclaw onboard --install-daemon

对比其他一键安装的方式，个人更偏向这种方式，对于新手小白，建议使用一键安装脚本

// 脚本负责节点检测、安装和引导
curl -fsSL https://openclaw.ai/install.sh  bash
//或者 只安装二进制
curl -fsSL https://openclaw.ai/install.sh  bash -s -- --no-onboard

配置OpenClaw

安全加固免责申明。

在上一步中，执行了openclaw onboard --install-daemon 命令后，会打开如下所示的内容：

这里通过方向键，选择Yes，回车。

Onboarding mode（引导模式）

这里选择QuickStart即可。

Model/auth Provider （模型验证）

内置的暂时不需要，我们选择Custom Provider 。

此时，会让你输入API Base URL,我们以阿里云百炼模型Qwen为例。

填入阿里云百炼模型URL，选择API Key验证，填写百炼模型的API Key，然后选择OpenAI-compatible，然后输入模型，目前免费体验的模型有qweb3.5-plus（100Wtoken）,当然还有其他的这里只选择一个即可，后面的再添加就是了。

Select channel（选择哪个平台的机器人）

因为提前创建了飞书、钉钉的机器人，这里就选择飞书，如果没有任何机器人可以选择Skip for now（后续还可以再次添加和修改）。

选择使用自带的Feishu，然后填写相关信息

Web search

这个建议使用Kimi的吧，去Moonshot AI 开放平台 - Kimi K2.5 大模型 API 服务创建一个Key，填写进去即可。其他的就随便。

此时就安装配置完成了。

自定义配置

后面就可以通古WebUI、修改配置文件、命令等方式进行自定义配置了。

1	openclaw configure --section models

选择Local，然后一直到模型，继续选择Custom Provider，接着填写新模型

通过隧道在本地访问

默认OpenClaw只绑定127.0.0.1，也非常不建议大家为了方便去反向代理暴露在公网。通常我们使用SSH 隧道连接到这台服务器上，然后在本地打开。

1	ssh -i C:\Users\xxx\.ssh\vps-server -L 18790:127.0.0.1:18789 root@服务器IP地址

-i C:\Users\xxx\.ssh\vps-server，表示我是用本地名为vps-server密钥登陆。没配置SSH-KEY登录服务器的同学可以使用密码。
-L 绑定端口。

登陆时需要一个token，或者你使用密码也行（需要自己修改配置）

Token，在你重启gateway时就可以看到

接入QQ

打开QQ开放平台，官方页面会有个OpenClaw快捷开通的链接，点击，创建机器人即可。

按照文档接入即可。