iota#

iota，特殊常量，可以认为是一个可以被编译器修改的常量。 iota 在 const关键字出现时将被重置为 0(const 内部的第一行之前)，const 中每新增一行常量声明将使 iota 计数一次(iota 可理解为 const 语句块中的行索引)。

func main() {
    const (
            a = iota   //0
            b          //1
            c          //2
            d = "ha"   //独立值，iota += 1
            e          //"ha"   iota += 1
            f = 100    //iota +=1
            g          //100  iota +=1
            h = iota   //7,恢复计数
            i          //8
    )
    fmt.Println(a,b,c,d,e,f,g,h,i)
}

插一嘴，go下的类型转换与cpp的结构不同，belike:int(something) go并不支持隐式类型转换

空接口#

用来实现泛型数据处理

package main

import "fmt"

func printValue(val interface{}) {
        fmt.Printf("Value: %v, Type: %T\n", val, val)
}

func main() {
        printValue(42)         // int
        printValue("hello")    // string
        printValue(3.14)       // float64
        printValue([]int{1, 2}) // slice
}

类型断言#

类型断言（Type Assertion）是一种用于将接口类型的值转换为具体类型的操作

value, ok := interfaceValue.(Type)

• interfaceValue 是一个接口类型的变量。
• Type 是你想要断言的目标类型。
• value 是断言后的具体类型的值（如果断言成功）。
• ok 是一个布尔值，表示断言是否成功.

这样用：

func main (){
    var i interface{} = "Hello"
    if s, ok := i.(string); ok {
        fmt.Println("Value is a string:", s)
    } else {
        fmt.Println("Value is not a string")
    }
}

搭配 switch实现不同数据类型的不同操作

func printType(val interface{}) {  
        switch v := val.(type) {  
        case int:  
                fmt.Println("Integer:", v)  
        case string:  
                fmt.Println("String:", v)  
        case float64:  
                fmt.Println("Float:", v)  
        default:  
                fmt.Println("Unknown type")  
        }  
}

errors.Is#

在 Go 语言中，errors.Is 函数用于判断一个错误链中是否包含某个特定的错误。它通常用于检查一个被包装过的错误是否包含某个基础错误

基本用法：

func Is(err, target error) bool

其中 err是被检查的错误，target error是检测的目标错误

• 如果 target 为 nil，则直接比较 err 是否也为 nil.
• 如果 err 和 target 都是可比较的，并且它们相等，则返回 true.
• 如果 err 实现了 Is 方法，并且调用 err.Is(target) 返回 true，则返回 true.
• 否则，递归调用 Unwrap 方法来获取 err 的下一层错误，并继续检查

使用例（什么绿幕素材靶场

package main
import (
    "fmt"
    "errors"
)

var BaseErr = errors.New("the underlying base error")

func main() {
    err1 := fmt.Errorf("wrap base: %w", BaseErr)
    err2 := fmt.Errorf("wrap err1: %w", err1)//这里err2包含了err1,err1包含了BaseErr
  
    if errors.Is(err2, BaseErr) {
        fmt.Println("err2 contains BaseErr")
    } else {
        fmt.Println("err2 does not contain BaseErr")
    }
}

errors.As#

errors.As 函数用于从一个错误链中提取指定类型的错误。它的作用是判断包装的错误链中是否存在某个特定类型的错误，并将第一个符合该类型的错误赋值给目标变量

func As(err error, target any) bool

err 是需要检查的错误;target 是一个指向目标类型的指针，用于接收匹配到的错误。

• errors.As 会递归地检查 err 错误链中的每一层错误.
• 如果找到一个错误的类型与 target 的类型匹配，则将该错误赋值给 target 并返回 true.
• 如果 err 实现了 As 方法，则调用该方法进行处理 使用例

package main
import (
    "errors"
    "fmt"
)

type TypicalErr struct {
    e string
}

func (t TypicalErr) Error() string {
    return t.e
}

func main() {
    err := TypicalErr{"typical error"}
    err1 := fmt.Errorf("wrap err: %w", err)
    err2 := fmt.Errorf("wrap err1: %w", err1)
  
    var e TypicalErr
    if errors.As(err2, &e) {
        fmt.Println("TypicalErr is on the chain of err2")
        fmt.Println(err == e) // true
    } else {
        fmt.Println("TypicalErr is not on the chain of err2")
    }
}

Goroutines#

• Go 中的并发执行单位，类似于轻量级的线程。
• Goroutine 的调度由 Go 运行时管理，用户无需手动分配线程。
• 使用 go 关键字启动 Goroutine。
• Goroutine 是非阻塞的，可以高效地运行成千上万个 Goroutine。 创建一个Goroutines的语法：

go myFunction()

channels#

• Go 中用于在 Goroutine 之间通信的机制。
• 支持同步和数据共享，避免了显式的锁机制。
• 使用 chan 关键字创建，通过 <- 操作符发送和接收数据。没有 ->只有 <-

使用例

package main

import (
    "fmt"
)

func main() {
    // 创建一个无缓冲的 Channel，类型为 int
    ch := make(chan int)
  
    // 开启一个 goroutine，将数据发送到 Channel 中
    go func() {
        ch <- 42 // 发送数据
    }()
  
    // 从 Channel 中接收数据
    value := <-ch
    fmt.Println("Received:", value)
}

创建Channel时可以指定缓冲区大小：

ch := make(chan int,100)

缓冲用例

package main

import "fmt"

func main() {
    // 这里我们定义了一个可以存储整数类型的带缓冲通道
    // 缓冲区大小为2
    ch := make(chan int, 2)

    // 因为 ch 是带缓冲的通道，我们可以同时发送两个数据
    // 而不用立刻需要去同步读取数据
    ch <- 1
    ch <- 2

    // 获取这两个数据
    fmt.Println(<-ch)
    fmt.Println(<-ch)
}

select#

select 语句使得一个 goroutine 可以等待多个通信操作。select 会阻塞，直到其中的某个 case 可以继续执行：

package main

import "fmt"

func fibonacci(c, quit chan int) {
    x, y := 0, 1
    for {
        select {
        case c <- x:
            x, y = y, x+y
        case <-quit:
            fmt.Println("quit")
            return
        }
    }
}

func main() {
    c := make(chan int)
    quit := make(chan int)

    go func() {
        for i := 0; i < 10; i++ {
            fmt.Println(<-c)
        }
        quit <- 0
    }()
    fibonacci(c, quit)
}

WaitGroup#

sync.WaitGroup 是 Go 语言 sync 包中提供的一个同步原语，用于等待一组并发操作的完成。它通常用于确保在所有启动的 Goroutine 完成它们的任务之前，主 Goroutine 不会提前退出。WaitGroup 通过计数器来实现这一功能，计数器的值表示需要等待的 Goroutine 数量。

主要方法：

• Add(delta int)：将计数器的值增加 delta。通常在启动 Goroutine 之前调用，传入的 delta 为 Goroutine 的数量.
• Done()：将计数器的值减少 1。通常在 Goroutine 完成其任务后调用.
• Wait()：阻塞调用者，直到计数器的值为 0。通常在主 Goroutine 中调用，用于等待所有 Goroutine 完成.

用例：

package main

import (
    "fmt"
    "sync"
    "time"
)

func worker(id int, wg *sync.WaitGroup) {
    defer wg.Done() // 确保在函数结束时调用 Done
  
    fmt.Printf("Worker %d starting\n", id)
    time.Sleep(time.Second) // 模拟耗时操作
    fmt.Printf("Worker %d done\n", id)
}

func main() {
    var wg sync.WaitGroup
  
    // 启动 3 个 Goroutine
    for i := 1; i <= 3; i++ {
        wg.Add(1) // 每启动一个 Goroutine，计数器加 1
        go worker(i, &wg)
    }
  
    // 等待所有 Goroutine 完成
    wg.Wait()
    fmt.Println("All workers done")
}