go - 在 Golang 中扩展常量

Question

这是我的要求:我有 2 组常量。我想形成第三组，它只是上述两组的并集。我该如何实现？

type CompOp byte

const (
    EQUAL CompOp = iota
    NOT_EQUAL
)

type LogOp byte

const (
    AND LogOp = iota
    OR
)

我想要第三套，说运算符(operator)

type Op {CompOp, LogOp}

或

var Op = CompOp + LogOp

但是以上2种方式都不行。我如何达到这个要求？

以上内容对我很重要，我正在努力实现这一目标:

type logExpr struct { 
    expr Expression
    op LogOp 
}  

type compExpr struct { 
    expr Expression
    op CompOp 
} 

type filterExpr struct { 
    expr Expression
    op Op 
}

Answer 1

CompOp 和 LogOp 不是同一类型的集合。它们不能以这种方式组合。如果可以，它们无论如何都会发生冲突，因为 EQUAL 和 AND 都是 0(因为它们是 block 中的第一个 iota) .您将需要另一种设计。

最常见的设计是将所有运算符组合到一个const block 中，然后提供类似IsCompare() 或IsLogic()< 的函数 以在必要时区分它们。请参阅 os.IsExist() 和 os.IsPermission() 作为模板。

这是我可能实现的一种方法。它浪费了一些最小值/最大值，但它使代码非常易于阅读和更新。

Playground

const (
    // Comparison operators
    minComparison Op = iota
    EQUAL
    NOT_EQUAL
    maxComparison

    // Logic operators
    minLogic
    AND
    OR
    maxLogic
)

func IsComparsion(op Op) bool {
    return op >= minComparison && op <= maxComparison
}

func IsLogic(op Op) bool {
    return op >= minLogic && op <= maxLogic
}

---

但是您可以将不同类型的操作视为类型吗？是的，你可以，也许它会更适合你。例如，考虑 ( playground ):

type Op interface {
    isOp()
}

type CompOp byte

const (
    EQUAL CompOp = iota
    NOT_EQUAL
)

func (op CompOp) isOp() {}

type LogOp byte

const (
    AND LogOp = iota
    OR
)

func (op LogOp) isOp() {}

func doOpThingBasedOnValue(op Op) {
    switch op {
    case EQUAL:
        println("passed equal")
    case AND:
        println("passed and")
    }
}

func doOpThingBasedOnType(op Op) {
    switch op.(type) {
    case CompOp:
        println("passed a comp")
    case LogOp:
        println("passed a logic")
    }
}

所以也许这更接近您的想法。请注意，尽管 AND 和 EQUAL 都是“0”，但作为一个接口(interface)，它们是可区分的，因此我们可以根据需要打开它们。这样做很酷。