Go 学习笔记

if err := doSomething(); err != nil {
  // 处理错误
} else {
  // 正常处理
}
// err 在这里不可见

type (
  MyInt int              // 定义新类型 MyInt，底层类型为 int
  YourInt = int          // 给 int 类型取别名 YourInt
)

var (
  a int
  b string
  c bool
)

const (
  A = 1
  B        // B 的值为 1
  C = 2
  D        // D 的值为 2
)

const (
  A = iota           // A 的值为 0
  B                  // B 的值为 1
  _                  // 忽略该值，iota 递增到 2
  C, D = iota, iota  // C 和 D 的值均为 3
)

OuterLoop:
for i := 0; i < 3; i++ {
  for j := 0; j < 3; j++ {
    if i == 1 && j == 1 {
      continue OuterLoop // 跳出当前内层循环，进入下一次外层循环
    }
    if i == 2 && j == 2 {
      break OuterLoop // 跳出外层循环
    }
    fmt.Printf("i=%d, j=%d\n", i, j)
  }
}

// 使用有显示名称的返回值
func divide(a, b int) (quotient int, remainder int) {
  quotient = a / b
  remainder = a % b
  return // 直接返回命名的返回值，这里的 return 不能省略
}

// 使用无名称的返回值
func divide2(a, b int) (int, int) {
  return a / b, a % b
}

func sum(nums ...int) int {
  total := 0
  for _, num := range nums {
    total += num
  }
  return total
}
func main() {
  result1 := sum(1, 2, 3, 4)       // 传入多个 int 参数
  result2 := sum([]int{5, 6, 7}...) // 传入一个 []int 参数，注意要加上 ...
  // result3 := sum(1, 2, []int{3, 4}...) // 错误，不能同时传入多种形式的参数
  fmt.Println(result1) // 输出: 10
  fmt.Println(result2) // 输出: 18
}

var b []byte
b = append(b, "hello"...) // OK

import (
  fmt "fmt"      // 给包取别名 fmt
  . "math"       // 导入包中的所有标识符
  _ "net/http"   // 给包取别名 _，仅执行其 init 函数
)

a := 53_700        // 十进制
b := 0_700         // 0前缀表示八进制
c1 := 0x_aa_bb_cc
c2 := 0X_dd_ee_ff  // 0x或0X前缀表示十六进制
d1 := 0b_1000_0001
d2 := 0B_1000_0001 // 0b或0B前缀表示二进制
e := .15           // 浮点数，可以省略整数部分的0
f := 82.           // 浮点数，可以省略小数部分的0
g1 := 1.5e2        // 科学计数法表示
g2 := 1.5E3        // 科学计数法表示
h1 := 0x2.p10      // 十六进制浮点数
h2 := 0X1.Fp0      // 十六进制浮点数

ch1 := '\u4e2d'     // Unicode 字符字面量，表示中文“中”
ch2 := '\U00004e2d' // Unicode 字符字面量，表示中文“中”
ch3 := '\x27'       // 字符字面量，表示单引号字符 `'`
ch4 := '\047'       // 字符字面量，八进制表示的字符 `'`

s1 := "abc\n"                // 字符串字面量，包含转义字符
s2 := "\u4e2d\u6587"         // 字符串字面量，表示“中文”
s3 := "\U00004e2d\U00006587" // 字符串字面量，表示“中文”
s4 := `This is a raw string.
This is the second line.
This is the third line.
\n will not be interpreted.` // 原始字符串字面量

arr1 := [6]int { 0, 1, 2, 3, 4, 5 }
arr2 := [...]int { 0, 1, 2, 3, 4, 5 }
arr3 := [...]int { 5: 5 } // 数组字面量，长度均为 6

sp1 := []int { 0, 1, 2 } // 切片字面量

mp1 := map[string]int { "a": 1, "b": 2 } // map 字面量

arr := [5]int{0, 1, 2, 3, 4}
s1 := arr[1:4:5]              // 创建切片 s1，包含 arr[1], arr[2], arr[3]
fmt.Println(s1)               // 输出: [1 2 3]
fmt.Println(len(s1), cap(s1)) // 输出: 3 4
s1[0] = 10                    // 修改切片 s1
fmt.Println(arr)              // 输出: [0 10 2 3 4]，arr 也被修改了
s2 := append(s1, 20, 30)      // 切片 s1 发生扩容，创建了新的底层数组
s2[0] = 30
fmt.Println(arr) // 输出: [0 10 2 3 4]，arr 不受影响
fmt.Println(s2)  // 输出: [30 2 3 20 30]

m := make(map[string]int)
v, ok = m["key"] // 如果 "key" 不存在，v 为 0，ok 为 false
if !ok {
// 处理键不存在的情况
} else {
// 使用 v 进行后续操作
}

var s string = "Hello 世界"
var b []byte = []byte(s) // 字符串转换为字节切片
var r []rune = []rune(s) // 字符串转换为 rune 切片
s2 := string(b)          // 字节切片转换为字符串
s3 := string(r)          // rune 切片转换为字符串

var s string = "Hello 世界"
lengthInBytes := len(s)                    // 获取字符串的字节数
lengthInRunes := utf8.RuneCountInString(s) // 获取字符串的字符数
for i, r := range s {                      // 遍历字符串中的字符
  fmt.Printf("Character %d: %c\n", i, r)
  // i 是字符的起始字节索引，r 是对应的 rune 值
  // Character 5: 世
  // Character 8: 界
}
for i := 0; i < len(s); i++ {
  fmt.Printf("Byte %d: %x\n", i, s[i])      // 访问字符串中的字节
}

type Person struct {
  Name string
  Age  int
}

type Employee struct {
  Person  // 嵌入 Person 结构体
  ID      string
}

var emp Employee
emp.Name = "Alice"
emp.Age = 30  // 直接访问嵌入结构体的字段

type I interface {
  M1()
  M2()
}
type S struct{}
func (s S) M1() {
  println("M1 called")
}
func (s S) M2() {
  println("M2 called")
}
type T struct {
  I // T 中嵌入接口 I
}
func main() {
  t := T{
    I: S{}, // 为嵌入的接口字段赋值，否则会导致运行时错误
  }
  t.M1()
  t.M2()
}

// ...
func (t T) M1() {
  println("T's M1 called")
}
func main() {
  t := T{
    I: S{},
  }
  t.M1() // 调用 T 实现的 M1 方法
  t.M2() // 调用 S 实现的 M2 方法
}

type I1 interface {
  M()
  M1()
}
type I2 interface {
  M()
  M2()
}
type T struct {
  I1
  I2
}
func (t T) M() { println("T.M") } // 必须实现 M 方法，否则 t.M() 会导致编译错误
func main() {
  t := T{}
  t.M()
}

type T struct {
  // F T         // 错误，不能包含类型为 T 的字段
  F *T           // 正确，可以包含类型为 *T 的字段
  G []T          // 正确，可以包含类型为 []T 的字段
  H map[string]T // 正确，可以包含类型为 map[type]T 的字段
}

type T1 struct {
  t2 T2
}
type T2 struct {
  t1 T1  // 错误，不能递归定义
}

type Person struct {
  Name string
  Age  int
}
type Book struct {
  Title  string
  Author Person
}

p1 := Person{"Alice", 30}
b1 := Book{"Go Programming", Person{"Bob", 40}}

p2 := Person{Name: "Alice", Age: 30}
b2 := Book{Title: "Go Programming", Author: Person{Name: "Bob", Age: 40}}

func NewPerson(name string, age int) *Person {
  return &Person{Name: name, Age: age}
}
// or
// func NewPerson(name string, age int) Person {
//   return Person{Name: name, Age: age}
// }

p3 := NewPerson("Alice", 30) // p3 在这里是 *Person 类型

type Person struct {
  Name string
  Age  int
}
type PersonOption func(*Person)
func WithName(name string) PersonOption {
  return func(p *Person) {
    p.Name = name
  }
}
func WithAge(age int) PersonOption {
  return func(p *Person) {
    p.Age = age
  }
}
func NewPerson(opts ...PersonOption) *Person {
  p := &Person{
    Name: "Unknown",
    Age:  0, // 默认值
  }
  for _, opt := range opts {
    opt(p)
  }
  return p
}
p4 := NewPerson(WithName("Alice"), WithAge(30))

type MyInt int

var a MyInt = 10
b := 10
c := a + b // 隐式转换，MyInt 和 int 可以进行运算

type MyInt *int
// CE: invalid receiver type MyInt (MyInt is a pointer type)
func (r MyInt) IsNil() bool { return r == nil }

type MyReader io.Reader
// CE: invalid receiver type MyReader (MyReader is an interface type)
func (r MyReader) Read(p []byte) (n int, err error) {}

var a1 any
var a2 any = nil
var e1 error
var e2 error = nil

var i *int = nil
var m *MyError = nil
var a any = i
var e error = m

type Animal interface {
  Grow() string
}
type Dog struct {}
func (d *Dog) Grow() {
 // some code will change Dog instance
}

func main() {
  var a Animal
  d := Dog{}
  a = d
  a.Grow() // 假设这里可以通过编译，d 的状态也不会改变
}

a := 10
var x any = a
// WARN:
// 如果断言失败会引发 panic，所以推荐使用带 ok 变量的形式进行断言
v1 := x.(float64)
v2, ok2 := x.(int)    // ok2 为 true，v2 的值为 10
v3, ok3 := x.(string) // ok3 为 false，v3 的值为 string 类型的零值 ""

ch := make(chan int)       // 无缓冲 channel
chBuf := make(chan int, 5) // 有缓冲 channel，缓冲区大小为 5

n := <-ch     // 当 channel 关闭时，n 会被赋值为类型的零值
m, ok := <-ch // ok 为 false 表示 channel 已经关闭
for v := range ch {
  // 当 channel 关闭时，循环会自动结束
}

select {
case msg1 := <-ch1:
  fmt.Printf("Received message from ch1: %s\n", msg1)
case ch2 <- msg2:
  fmt.Printf("Sent message to ch2: %s\n", msg2)
default:
  fmt.Println("No channel is ready")
}

fun TrySend(ch chan<- int, value int) bool {
  select {
  case ch <- value:
    return true // 发送成功
  default:
    return false // channel 未准备好，发送失败
  }
}

func ReceiveWithTimeout(ch <-chan int, timeout time.Duration) (int, error) {
  select {
  case value := <-ch:
    return value, nil // 成功接收数据
  case <-time.After(timeout):
    return 0, errors.New("receive timeout") // 超时
  }
}

func PeriodicTask(interval time.Duration, stopCh <-chan struct{}) {
  ticker := time.NewTicker(interval)
  defer ticker.Stop()
  for {
    select {
    case <-ticker.C:
      // 执行周期任务
    case <-stopCh:
      return // 停止任务
    }
  }
}

ch := make(chan struct{})
go func() {
  // do some work
  ch <- struct{}
}()
select {
case <-ch:
  fmt.Println("任务完成！")
case <-time.After(2 * time.Second):
  fmt.Println("任务超时!")
}

var x interface{} = 10
switch v := x.(type) { // 只能接口类型可以使用 type switch
case int:
  fmt.Printf("x is int: %d\n", v)
case string:
  fmt.Printf("x is string: %s\n", v)
default:
  fmt.Printf("x is of unknown type\n")
}

type MyType[T any] struct {
  // T          // 错误，不能在泛型类型中内嵌泛型本身
}
// 错误，不能在泛型方法中接着定义泛型
func (m MyType[T]) MyMethod[U any]() {
}

func a1[I interface { int | int32 | ~int64 }](param I) {}
func a2[T int | int32 | ~int64](param T) {}

func safeFunction() {
  defer func() {
    if r := recover(); r != nil {
      fmt.Println("Recovered from panic:", r)
    }
  }()
  // 可能引发 panic 的代码
}

import "github.com/user/project/v2"

r := []int{0, 1, 2}
// CE: declared and not used: v
for _, v := range r {
  v = 0
}

var a = [5]int{1, 2, 3, 4, 5}
var r [5]int
for i, v := range a {
// for i, v := range &a {
// for i, v := range a[:] {
  if i == 0 {
    // 注意这里我们改的是还没有遍历到的数据
    a[1] = 12
    a[2] = 13
    // 不管是使用哪种形式的 for range
    // 对当前遍历对象的修改都不会作用到 v 上
    // 因为 v 已经是 a[0] 的拷贝了
    // a[0] = 10
  }
  r[i] = v
}
fmt.Println("r = ", r) // r = [1 2 3 4 5]
fmt.Println("a = ", a) // a = [1 12 13 4 5]

type Customer struct {
  ID      string
  Balance float64
}
type Store struct {
  Customers map[string]*Customer
}

func (s *Store) storeCustomers(customers []Customer) {
  for _, customer := range customers {
    // 在 go 1.22 之前需要这样写以避免问题，保证每次创建一个新的 customer 变量
    // customer := customer
    s.Customers[customer.ID] = &customer
  }
}

func main() {
  s := Store{Customers: make(map[string]*Customer)}
  s.storeCustomers([]Customer{
    {ID: "1", Balance: 10},
    {ID: "2", Balance: -10},
    {ID: "3", Balance: 0},
  })
  for i, v := range s.Customers {
    fmt.Printf("id=%s,customer=%+v\n", i, v)
  }
}

type T struct{}
func (t T) Get() {}
func (t *T) Set(value int) {}
var t T
t.Get()
t.Set(10)
// or
T.Get(t)
(*T).Set(&t, 10)

type T struct{}
func (t T) Get() {}
func (t *T) Set(value int) {}
var t T
getFunc := t.Get
setFunc := (&t).Set
getFunc()   // 等价于 t.Get()
setFunc(10) // 等价于 t.Set(10)

select {
case getAChannel() <- computeValue1():           // getAChannel() 和 computeValue1() 会被调用
case (getAStorageArray())[0] := <-getAChannel(): // getAStorageArray() 不会被调用，getAChannel() 会被调用
}

// 标明和 fmt 包在同一个包下
package fmt

var IsSpace = isSpace
var Parsenum = parsenum

func setup() func() {
  // 初始化工作
  return func() {
    // 清理工作
  }
}
func TestSomething(t *testing.T) {
  teardown := setup()
  defer teardown()
  // 测试代码
}

func setup() {
  // 初始化工作
}

func cleanup() {
  // 清理工作
}

func TestSomething(t *testing.T) {
  // 测试开始时调用
  t.Setup(setup)
  // 测试结束时调用
  t.Cleanup(cleanup)
  // 测试代码
}

// 其他的测试函数……

func pkgSetup() {
  // 包级别的初始化工作
}
func pkgCleanup() {
  // 包级别的清理工作
}
func TestMain(m *testing.M) {
  m.Setup(pkgSetup)
  m.Cleanup(pkgCleanup)
  // 初始化工作
  code := m.Run() // 运行所有测试
  // 清理工作
  os.Exit(code)
}

func testChild1(t *testing.T) {
  // 子测试用例 1 的代码
}
func testChild2(t *testing.T) {
  // 子测试用例 2 的代码
}
func TestParent(t *testing.T) {
  t.Run("Child_1", testchild1)
  t.Run("Child_2", testchild2)
}