在go中，使用panic来抛出一个错误并将程序停止。

一般有主动panic和被动panic两种情况。

对于主动panic，可以是当一个程序启动时如果需要的依赖程序没有启动就将这个启动停掉，比如没有开etcd或mysql等，例如：

func main() {
    ismysql := false; // 模拟mysql未启动的场景
    if !ismysql {
        panic("mysql 未启动")
    }
}

运行之后会得到如下结果：

panic: mysql 未启动

goroutine 1 [running]:
main.main()
        C:/gostudy/20250704/exe1/exe1.go:6 +0x25
exit status 2

对于被动panic的情况，如果不想要让程序退出可以使用recover来接受这个panic，之后可以选择打印或者做其他处理，并且程序是保持运行的。例如：

var mp map[string]string

func A() {
    defer func() {
        r := recover()
        fmt.Println("捕获到panic", r)
    }()
    mp["heky"] = "heky" // 在不用make或者初值初始化的情况下程序会报panic
}

func main() {
    A()
    fmt.Println("程序继续运行，未退出")
}

运行之后会得到如下结果：

捕获到panic assignment to entry in nil map
程序继续运行，未退出

这里需要注意的是如果要使用recover来捕获panic，recover必须在一个defer后面跟着的匿名函数中，并且这个recover必须在panic之前（因为在panic之后就是不可达的）。

假如说有一个需求就是每次访问一个函数之后都会获得一个变量递增之后的值，并且可以随时将这个变量的值清零。

如果想要做到前半部分的需求，我们可以使用全局变量。例如

var idx int

func getidx() int {
    idx += 1
    return idx
}

func main() {
    for range 5 {
        fmt.Println(getidx())
    }
}

之后想要完成第二个需求也可以通过将idx赋值为0来实现。

除了全局变量之外，还可以使用go函数闭包的特性来实现。例如：

func getidx() func() int {
    idx := 0
    return func() int {
        idx += 1
        return idx
    }
}

func main() {
    id := getidx()
    for range 5 {
        fmt.Println(id())
    }
}

此时假如想要将值清零可以重新调用getidx，获取一个新的函数的句柄，然后调用新获取的函数的句柄。例如：

func main() {
    // ... 省略上面内容
    id2 := getidx()
    for range 3 {
        fmt.Println(id2())
    }
}

运行之后的结果应该如下所示：

1
2
3
4
5
1
2
3

通过上面的例子可以看出和使用全局变量的方式相比，函数闭包的实现可以不依赖于一个专门的变量，这对于后面有多个线程同时需要使用到idx时可以避免发生堵塞和竞争。

在go中定义一个函数之后，对于形参的长度是可以变换的。通常对于可以变化长度的形参后面加上三个点 ... ，并且此时这个参数就变为了一个切片，例如：

func add(items ...int) (sum int) {
    for _, v := range items {
        sum += v;
    }
    return
}

对于这个函数来说，实现了将多个传入的int类型的参数进行相加的功能。

我们可以这样来使用

sum := add(1, 2, 3)
println(sum)

在这个例子中add函数传入了三个参数，那么 items 此时等价于 [1,2,3]

通过调试也可以看出这一点