Go 方法链和错误处理

Question

我想在 Go 中创建一个方法链接 API。在所有示例中，我都可以发现链式操作似乎总是会成功，这是我无法保证的。因此，我尝试扩展这些以添加错误返回值。

如果我这样做

package main

import "fmt"

type Chain struct {
}

func (v *Chain)funA() (*Chain, error ) {
    fmt.Println("A")
    return v, nil
}
func (v *Chain)funB() (*Chain, error) {
    fmt.Println("B")
    return v, nil
}
func (v *Chain)funC() (*Chain, error) {
    fmt.Println("C")
    return v, nil
}

func main() {
    fmt.Println("Hello, playground")
    c := Chain{}
    d, err := c.funA().funB().funC() // line 24
}

编译器告诉我chain-err-test.go:24: multiple-value c.funA() in single-value context 并且不会编译。有没有什么好办法可以让funcA、funcB、funcC报错并停止该链？

Answer 1

有没有什么好方法可以让funcA、funcB和funcC报错并停止该链？

很遗憾，不，您的问题没有好的解决方案。变通方法非常复杂（添加错误通道等），成本超过收益。

方法链接在 Go 中不是一个习惯用法（至少对于可能出错的方法来说不是）。这并不是因为方法链有什么特别的错误，而是返回错误而不是恐慌的习惯用法的结果。其他答案是解决方法，但没有一个是惯用的。

我能问一下，在 Go 中链接方法不是惯用的，因为我们在 Go 中返回错误的后果，还是更普遍地是多个方法返回的后果？

问得好，但这并不是因为 Go 支持多重返回。 Python 支持多个返回，Java 也可以通过 Tuple<T1, T2> 类；方法链在两种语言中都很常见。这些语言可以侥幸逃脱的原因是它们习惯性地通过异常来传达错误。异常会立即停止方法链并跳转到相关的异常处理程序。这是 Go 开发人员特别试图通过选择返回错误来避免的行为。

Answer 2

你可以这样尝试： https://play.golang.org/p/dVn_DGWt1p_H

package main

import (
    "errors"
    "fmt"
)

type Chain struct {
    err error
}

func (v *Chain) funA() *Chain {
    if v.err != nil {
        return v
    }
    fmt.Println("A")
    return v
}
func (v *Chain) funB() *Chain {
    if v.err != nil {
        return v
    }
    v.err = errors.New("error at funB")
    fmt.Println("B")
    return v
}
func (v *Chain) funC() *Chain {
    if v.err != nil {
        return v
    }
    fmt.Println("C")
    return v
}

func main() {
    c := Chain{}
    d := c.funA().funB().funC() 
    fmt.Println(d.err)
}

Answer 3

如果您可以控制代码并且函数签名相同，您可以编写如下内容：

func ChainCall(fns ...func() (*Chain, error)) (err error) {
    for _, fn := range fns {
        if _, err = fn(); err != nil {
            break
        }
    }
    return
}

playground

Answer 4

你可以通过收集一些函数来让你的链变得懒惰

package main

import (
    "fmt"
)

type (
    chainFunc func() error
    funcsChain struct {
        funcs []chainFunc
    }
)

func Chain() funcsChain {
    return funcsChain{}
}

func (chain funcsChain) Say(s string) funcsChain {
    f := func() error {
        fmt.Println(s)

        return nil
    }

    return funcsChain{append(chain.funcs, f)}
}


func (chain funcsChain) TryToSay(s string) funcsChain {
    f := func() error {
        return fmt.Errorf("don't speek golish")
    }

    return funcsChain{append(chain.funcs, f)}
}

func (chain funcsChain) Execute() (i int, err error) {
    for i, f := range chain.funcs {
        if err := f(); err != nil {
            return i, err
        }
    }

    return -1, nil
}

func main() {
    i, err := Chain().
        Say("Hello, playground").
        TryToSay("go cannot into chains").
        Execute()

    fmt.Printf("i: %d, err: %s", i, err)
}

Answer 5

这种方法怎么样：创建一个代表Chain 和error 的结构，并返回它而不是两个值。例如：

package main

import "fmt"

type Chain struct {
}

type ChainAndError struct {
    *Chain
    error
}

func (v *Chain)funA() ChainAndError {
    fmt.Println("A")
    return ChainAndError{v, nil}
}

func (v *Chain)funB() ChainAndError {
    fmt.Println("B")
    return ChainAndError{v, nil}
}

func (v *Chain)funC() ChainAndError {
    fmt.Println("C")
    return ChainAndError{v, nil}
}

func main() {
    fmt.Println("Hello, playground")
    c := Chain{}
    result := c.funA().funB().funC() // line 24
    fmt.Println(result.error)
}