go学习

数组和切片定义对比

⏺ Go 中数组与切片的声明

字符串

// 数组（固定长度）
var a1 [3]string // 零值: [“”, “”, “”]
a2 := [3]string{“a”, “b”, “c”} // 字面量初始化
a3 := […]string{“x”, “y”, “z”} // 编译器推断长度

// 切片（动态长度）
var s1 []string // 零值: nil
s2 := []string{“a”, “b”, “c”} // 字面量初始化
s3 := make([]string, 3) // 长度 3，容量 3
s4 := make([]string, 0, 10) // 长度 0，容量 10

int

// 数组（固定长度）
var a1 [3]int // 零值: [0, 0, 0]
a2 := [3]int{1, 2, 3}
a3 := […]int{10, 20, 30}

// 切片（动态长度）
var s1 []int // 零值: nil
s2 := []int{1, 2, 3}
s3 := make([]int, 3)
s4 := make([]int, 0, 10)

核心区别

	数组 [N]T	切片 []T
长度	固定，编译时确定	可变，运行时增长
声明	[3]int — 带数字	[]int — 不带数字
零值	元素为类型零值	nil
赋值/传参	值拷贝（整个复制）	引用传递（共享底层数组）
能否 append	❌ 不行	✅ append(s, v)

总结：方括号里有东西（数字或 …）就是数组，空的 [] 才是切片

全局变量

var c, m []interface{}必须要使用var声明。

• 使用方式：var name Type 或 var name = value；不能用 var name Type{}（这是局部变量的短声明风格）
• []interface{}：Go 的”万能容器”，可存放任意类型，等价于[]any
• 使用示例：

// 方案1：用 = 赋值（推荐！）
var define_1 = []any{}

// 方案2：先声明，后在 init/main 中初始化
var define_1 []any // 零值初始化为 nil
func init() {
    define_1 = []any{} // 运行时初始化
}

• 推荐使用方法 1，该方法不存在空指针！

[]any

• []any是一个数据类型（不能单独作为值）

any 是 Go 1.18+ 中 interface{} 的别名（完全等价）

• 花括号 {} 创建结构体实例

切片字面量

• 切片字面量必须写成 []any{元素} 或 []any{}（空切片），即切片字面量必须包含 {}
• 可以使用切片自变量{}的数据类型包括：
  • 切片
  • 数组
  • Map
  • 结构体

// 切片
s := []int{}
s := []int{1, 2, 3}

// 数组
arr := [3]int{}
arr := [3]int{1, 2, 3}

// Map
m := map[string]int{}
m := map[string]int{"a": 1}

// 结构体
type Person struct {
    Name string
    Age  int
}
p := Person{}
p := Person{Name: "张三", Age: 20}

使用示例：

b := []any{}        // ✅ 空切片
b := []any{1, "two"} // ✅ 带元素的切片

语法规则：

场景	允许的语法	禁止的语法	原因
全局变量	var x = []T{}	var x []T{}	语法规则限制
	var x []T (零值)	x := []T{}	:= 不能在全局使用
局部变量	x := []T{}	var x []T{}	局部声明不支持此语法
	var x = []T{}	x := []T	缺少 {}
函数参数/返回值	func f(a []T)	func f(a []T{})	{} 只用于字面量

诀窍：

写切片，带花括号；
无 {}，必报错；
全局用=，局部用:=；
混合类型用 any！”

局部变量声明方式

方式	代码示例	说明	使用场景
方式1：var + 类型	var param dto.CreateProjectRequest	声明变量，自动初始化为零值	✅ 最常用，清晰明确
方式2：var + 类型 + 赋值	var param dto.CreateProjectRequest = dto.CreateProjectRequest{}	声明并显式初始化	需要明确初始化时
方式3：短变量声明	param := dto.CreateProjectRequest{}	简洁的声明+初始化	✅ 函数内部常用
方式4：var + 推断类型	var param = dto.CreateProjectRequest{}	自动推断类型	类型明显时

方式一构建的变量，每种类型都有默认的零值。

零值规则：

类型	零值	示例
整数（int, int64等）	0	var age int → age = 0
浮点数（float64等）	0.0	var price float64 → price = 0.0
字符串（string）	“” (空字符串)	var name string → name = ""
布尔值（bool）	false	var isActive bool → isActive = false
指针、切片、映射、通道、函数、接口	nil	var ptr *int → ptr = nil
结构体	所有字段都是零值	var param dto.CreateProjectRequest → 所有字段为零值

var res int
var arr []int

for 循环

Go 没有 while 关键字，全部用 for 搞定！

1️⃣ 经典三段式（类似 C/Java）

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

2️⃣ 只有条件（类似 while）

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

3️⃣ 无限循环（你代码的写法）

for {
    // 一直执行，直到 break 或 return
    if 某条件 {
        break
    }
}

4️⃣ range 遍历

nums := []int{1, 2, 3}
for index, value := range nums {
    fmt.Println(index, value)
}

---

写法	含义
for i := 0; i < n; i++	经典循环
for 条件	类似 while
for {}	无限循环，靠 break/return 退出
for range	遍历切片/map/字符串

append(c, m…)

• m…：展开操作符，把 m 切片拆成独立元素，加入到c中。
• append 之后不改变 c，返回一个新的对象

运行代码

方式一：go build - 编译生成可执行文件

// 编译
go build -o robot_train_platform main.go
// 运行
./robot_train_platform

📦 编译：将 main.go 及其依赖的所有 Go 代码编译成机器码
💾 生成文件：创建一个名为 robot_train_platform 的可执行文件
⚡ 可独立运行：生成的文件可以直接运行，不需要 Go 环境

方式二：go run - 临时编译并运行

go run main.go

🔄 临时编译：在临时目录编译代码
🚀 立即运行：编译完成后立即执行
🗑️ 自动清理：运行结束后自动删除临时文件
💡 开发友好：适合开发阶段快速测试

命名返回值

• 在函数返回值中确定变量名：(rsp any, err error)

在 Go 中，你可以给返回值命名，而不只是声明类型。这样做的效果是：

1. 自动声明变量：rsp 和 err 在函数体内被自动声明为局部变量。
2. 零值初始化：它们会被初始化为各自类型的零值。
   • rsp any → 零值是 nil
   • err error → 零值是 nil

func (s *RobotService) RegisterRobot(ctx context.Context, param dto.RegisterRobotReq) (rsp any, err error) {
	// panic恢复
	defer func() {
		if r := recover(); r != nil {
			stack := debug.Stack()
			ilog.CtxErrorf(ctx, "[RegisterRobot] panic: %v, stack: %s", r, string(stack))
			err = errors.New("panic occur")
		}
	}()

	ilog.CtxInfof(ctx, "[RegisterRobot] param: %s", tool.JsonifyIndent(param))

	uin := tool.UinStr(ctx)
	ownerUin := tool.OwnerUinStr(ctx)

	// 参数校验
	if err := s.validateRegisterParams(ctx, param, ownerUin); err != nil {
		return rsp, err
	}
	...
}

否则上面的代码要这样写：

// 写法2：普通返回值（需要手动声明）
func (s *RobotService) RegisterRobot(...) (any, error) {
    var rsp any  // 需要手动声明
    if err := someFunc(); err != nil {
        return rsp, err
    }
}

Go 语言的包函数命名规则

例如一个工具包 tool/uuid.go 实现如下：

package tool  // ← 声明这个文件属于 tool 包

import "github.com/google/uuid"

// UUID 函数是公开的（首字母大写）
func UUID() string {
    return uuid.New().String()
}

由于 UUID() 首字母大写了，所以可以被其他包引用使用，方法如下：tool.UUID()

Go 语言测试

测试要求：

规则	说明	示例
文件名	必须以 _test.go 结尾	param_test.go ✅ param.go ❌
包名	与被测试文件相同	package tool
函数名	必须以 Test 开头	TestValidateRegex ✅ validateRegex ❌
参数	必须是 *testing.T	func TestXxx(t *testing.T)

param_test.go 示例代码：

package tool

import (
	"fmt"
	"testing"
)

func TestValidateRegex(t *testing.T) {
	//pattern := "^[a-zA-Z0-9:_-]{1,48}$"
	str := "my-robot-01"
	//isValid := ValidateRegex(pattern, str)
	//fmt.Println(isValid)
	if !ValidateRegex("^[a-zA-Z0-9:_-]{1,48}$", str) {
		fmt.Println("invalid")
	}
}

使用方法：

cd ./logic/tool
go test -v -run TestValidateRegex

常见的 t *testing.T 输出：

方法	说明	示例
t.Error(args)	报告错误，但继续执行	t.Error("验证失败")
t.Errorf(format, args)	格式化报告错误	t.Errorf("期望 %v，得到 %v", expected, actual)
t.Fatal(args)	报告错误并立即停止测试	t.Fatal("严重错误")
t.Fatalf(format, args)	格式化报告错误并停止	t.Fatalf("无法连接数据库: %v", err)
t.Log(args)	记录日志（只在失败时显示）	t.Log("测试开始")
t.Logf(format, args)	格式化记录日志	t.Logf("测试数据: %+v", data)
t.Skip(args)	跳过测试	t.Skip("暂时跳过")
t.Parallel()	标记测试可以并行运行	t.Parallel()

fmt.Sprintf

数据格式化

// %d - 十进制整数
fmt.Sprintf("%d", 123)        // "123"

// %s - 字符串
fmt.Sprintf("%s", "hello")    // "hello"

// %v - 默认格式（任意类型）
fmt.Sprintf("%v", 123)        // "123"
fmt.Sprintf("%v", "hello")    // "hello"

// %+v - 带字段名的结构体
type User struct {
    Name string
    Age  int
}
user := User{Name: "Alice", Age: 30}
fmt.Sprintf("%+v", user)      // "{Name:Alice Age:30}"

// %#v - Go 语法表示
fmt.Sprintf("%#v", user)      // "main.User{Name:"Alice", Age:30}"

// %T - 类型
fmt.Sprintf("%T", 123)        // "int"
fmt.Sprintf("%T", "hello")    // "string"

// %t - 布尔值
fmt.Sprintf("%t", true)       // "true"

// %f - 浮点数
fmt.Sprintf("%.2f", 3.14159)  // "3.14"

// %p - 指针地址
ptr := &user
fmt.Sprintf("%p", ptr)        // "0xc0000a4000"

ctx

func ExampleContextValue() {
    // 创建根 context
    ctx := context.Background()
    
    // 添加第一个值
    ctx = context.WithValue(ctx, "key1", "value1")
    
    // 添加第二个值
    ctx = context.WithValue(ctx, "key2", "value2")
    
    // 添加第三个值
    ctx = context.WithValue(ctx, "key3", "value3")
    
    // 获取值
    fmt.Println(ctx.Value("key1"))  // "value1"
    fmt.Println(ctx.Value("key2"))  // "value2"
    fmt.Println(ctx.Value("key3"))  // "value3"
    fmt.Println(ctx.Value("key4"))  // <nil> (不存在)
}

完整代码

package main

import (
	"fmt"
)

// ✅ 正确：全局变量零值初始化（nil 切片）
var zes []any

// ✅ 正确：全局变量显式初始化（推荐！）
var initializedGlobal = []any{"global_item"}

func main() {
	// 1. 处理 nil 切片（zes 是 nil）
	fmt.Println("zes (nil 切片):", zes == nil) // true
	zes = []any{}
	// ✅ 安全：Go 允许对 nil 切片 append（但有风险！）
	fmt.Println("append 到 nil 切片:", append(zes, 1)) // [1]

	// 2. 局部变量初始化
	a := []any{1, 2, 3}        // ✅ 带元素
	b := []any{}               // ✅ 空切片
	fmt.Println("b (空切片):", b) // []

	// 3. interface{} 等价于 any
	c := []interface{}{1, 2, 3}
	m := []interface{}{}

	// 4. 修复格式化字符串错误：
	//    %v 后不能跟逗号，必须用 Printf 系列
	fmt.Printf("a 的值: %v, 类型: %T\n", a, a) // a 的值: [1 2 3], 类型: []interface {}
	fmt.Printf("c 的值: %v\n", c)            // c 的值: [1 2 3]
	fmt.Printf("m 长度: %d\n", len(m))       // m 长度: 0
	fmt.Printf("m 类型: %T\n", m)            // m 类型: []interface {}
}