优雅地减少函数中的多重条件检查

大家好，我们又见面了啊~本文《优雅地减少函数中的多重条件检查》的内容中将会涉及到等等。如果你正在学习Golang相关知识，欢迎关注我，以后会给大家带来更多Golang相关文章，希望我们能一起进步！下面就开始本文的正式内容~

多个函数中有多个条件检查

type va struct {
    a string
}

func (va *va) checka(s string) error {
    if s != va.a {
        return errors.new("invalid str ")
    }
    return nil
}

type vb struct {
    b int
}

func (vb *vb) checkb(i int) error {
    if i == vb.b {
        return errors.new("invalid int")
    }
    return nil
}

func funca(s string, i int) error {
    a := &va{a: "testa"}
    erra := a.checka(s)
    if erra != nil {
        return erra
    }

    b := &vb{b: 3}
    errb := b.checkb(i)
    if errb != nil {
        return errb
    }

    // more logic ...

    return nil
}

func funcb(sb string, v int32) error {
    a := &va{a: "testb"}
    erra := a.checka(sb)
    if erra != nil {
        return erra
    }

    // more logic ...

    return nil
}

func funcc(sc string, vv int) error {
    b := &vb{b: 3}
    errb := b.checkb(vv)
    if errb != nil {
        return errb
    }

    // more logic ...

    return nil
}

我们在函数 funca 中执行 checka 和 checkb ，并在函数 funcb 中执行 checka 。但是，仅在函数 funcc 中执行 checkb。有一个陷阱，当 checka 的返回值改变时，funca 和 funcb 都会改变。

我们要重构上面的代码。在 golang 中有什么优雅的方法可以做到这一点吗？

我们尝试过，将 checka 和 checkb 组合在一个函数 validatefunc 中，如下所示

type VALIDATE int

const (
    _ VALIDATE = 1 << iota
    VALIDATEA
    VALIDATEB
)

func ValidateFunc(vs, s string, vi, i int, validate VALIDATE) error {
    if validate&VALIDATEA == VALIDATEA {
        a := &VA{A: vs}
        errA := a.CheckA(s)
        if errA != nil {
            return errA
        }
    }
    if validate&VALIDATEB == VALIDATEB {
        b := &VB{B: vi}
        errB := b.CheckB(i)
        if errB != nil {
            return errB
        }
    }
    return nil
}

func FuncA(s string, i int) error {
    err := ValidateFunc("testa", s, 3, i, VALIDATEA|VALIDATEB)
    if err != nil {
        return err
    }

    // more logic ...

    return nil
}

正确答案

参考Option pattern，看起来代码会比以前简单一些。

type Validator struct {
    A VA
    B VB
}

type Validate func(v *Validator) error

func WithVA(s string) Validate {
    return func(v *Validator) error {
        if err := v.A.CheckA(s); err != nil {
            return err
        }
        return nil
    }
}

func WithVB(i int) Validate {
    return func(v *Validator) error {
        if err := v.B.CheckB(i); err != nil {
            return err
        }
        return nil
    }
}

func DoValidate(vs string, vi int, vals ...func(v *Validator) error) error {
    v := &Validator{A: VA{A: vs}, B: VB{B: vi}}

    for _, val := range vals {
        if err := val(v); err != nil {
            return err
        }
    }

    return nil
}

func FuncA(s string, i int) error {
    err := DoValidate("testa", 3, WithVA(s), WithVB(i))
    if err != nil {
        return err
    }

    // more logic ...

    return nil
}

今天关于《优雅地减少函数中的多重条件检查》的内容介绍就到此结束，如果有什么疑问或者建议，可以在golang学习网公众号下多多回复交流；文中若有不正之处，也希望回复留言以告知！