虽然在Golang中，在某些情况下进行方法改变并不是一个好的习惯，但如果你把你的方法连锁起来，那就很有用了。这背后的原因是不同的异常处理方式，在另一种编程语言中，在一个chan函数中出现异常时，它会抛出异常，其他方法不会被运行。在这篇文章中，我将展示我们如何在Golang中实现它。
假设我想有一个应用注册表，想动态地添加客户：

package main
// 堆代码 duidaima.com
import (
    "errors"
    "fmt"
    "log"
)

type(
    ClientA struct {}
    ClientB struct {}
    ClientC struct {}
)

type Registry struct {
    ca * ClientA
    cb * ClientB
    cc * ClientC
    err error
}

func(r * Registry) withClientA() * Registry {
    if r.err != nil {
        return r
    }
    fmt.Println("client A initialed")
    r.ca = & ClientA {}
    return r
}

func(r * Registry) withClientB() * Registry {
    if r.err != nil {
        return r
    }
    r.err = errors.New("error at initial client B")
    return r
}

func(r * Registry) withClientC() * Registry {
    if r.err != nil {
        return r
    }
    fmt.Println("client C initialed")
    r.cc = & ClientC {}
    return r
}

func main() {
    c: = Registry {}
    d: = c.withClientA().withClientB().withClientC()
    if d.err != nil {
        log.Fatalf("can not initial Clients due to %v", d.err)
    }
}

output:

client A initialed
2023/02/22 23:14:04 can not initial Clients due to error at initial client B

如果你运行它，你可以看到，由于ClientB初始化时的一个故意的错误，该方法链将被失败，错误将被缓存在注册表中。