如何优雅地检查三个值的相等性？

Question

假设我有值为a、b和c，我想找出它们是否相等。如果我这样做：

if a == b == c{...}

然后我收到一个编译错误

invalid operation: a == b == c (mismatched types bool and TypeOfABandC)

这很明显，因为它解析为：

(a == b) == c

而 (a == b) 是一个布尔值。

当然，我可以执行：

if a == b && a == c {...}

不过，这看起来并不太美观，感觉很混乱。还有其他的方法吗？

- timthelion

---

你可以创建一个静态类，接受可变参数并返回布尔值。 - Joseph Evans

最后一个例子有什么令人困惑的？它明确地展示了正在发生的事情，你仍然可以省略 b == c 的及物比较。 - JimB

Answer 1

需要注意的一点：

你最后提出的解决方案是比较三个值是否相等的最短，最清晰和最高效的方式：

if a == b && a == c {
    fmt.Println("Clearest: all 3 are equal")
}

或者（根据您的喜好）：

if a == b && b == c {
    fmt.Println("Clearest: all 3 are equal")
}

接下来的内容只是在玩弄语言规范和语言的功能，展示我觉得有趣和有创意的东西。它们并不试图提供更优秀的解决方案。

---

请在Go Playground上尝试以下所有示例。这些示例基于比较的术语和结果进行构建，这些术语和结果在规范：比较运算符中定义。

总体说明：在以下示例中，我使用了类型interface{}，它适用于您的值（a、b和c）的任何类型，但如果您知道它们的类型为int，则可以使用该特定类型（这将提高效率并缩短示例的长度）。

使用map作为集合

if len(map[interface{}]int{a: 0, b: 0, c: 0}) == 1 {
    fmt.Println("Map set: all 3 are equal")
}

有效地，我们将所有可比较的值放入一个map中作为键，如果它们都相等，那么在映射中只会有一对键值对，因此映射的“长度”为1。这里映射的值类型并不起任何作用，它可以是任何东西。我使用int，因为这会导致最短的组合字面量（定义了map的值）。

这种解决方案非常灵活，您可以使用任意数量的值来测试它们是否都相等，而不仅仅是3个。

使用数组

数组是可比较的（与切片不同）：

if [2]interface{}{a, b} == [2]interface{}{b, c} {
    fmt.Println("Arrays: all 3 are equal")
}

如果相应元素相等，数组比较的结果将为true，即a == b和b == c。

请注意，您也可以对任意数量的值应用此方法。当有5个值时，它看起来像这样：

if [4]interface{}{a, b, c, d} == [4]interface{}{b, c, d, e} {
    fmt.Println("Arrays: all 5 are equal")
}

有一个棘手的map

if map[interface{}]bool{a: b == c}[b] {
    fmt.Println("Tricky map: all 3 are equal")
}

这个复合字面量将会把比较结果 b == c 分配给键 a。我们查询与键 b 关联的值。如果 a == b，索引表达式的结果将是 b == c 的结果，也就是说，所有 3 个值是否相等。如果 a != b，那么值类型的零值将是结果，对于 bool 类型来说，它将正确地告诉我们所有 3 个值都不相等。

使用匿名的 struct

struct 值也是可比较的，因此:

if struct{ a, b interface{} }{a, b} == struct{ a, b interface{} }{b, c} {
    fmt.Println("Anon structs: all 3 are equal")
}

使用（命名的）struct

如果我们事先定义一个简单的 struct：

type P struct{ a, b interface{} }

比较将会更加紧凑：

if (P{a, b} == P{b, c}) {
    fmt.Println("Structs: all 3 are equal")
}

（请注意，if语句的表达式必须放在括号中以避免解析二义性 - 否则会导致编译时错误！）

使用切片

切片是不可比较的，因此我们需要从reflect.DeepEqual()中借用一些帮助：

if reflect.DeepEqual([]interface{}{a, b}, []interface{}{b, c}) {
    fmt.Println("Slices: all 3 are equal")
}

使用辅助函数

func AllEquals(v ...interface{}) bool {
    if len(v) > 1 {
        a := v[0]
        for _, s := range v {
            if a != s {
                return false
            }
        }
    }
    return true
}

并且使用它：

if AllEquals(a, b, c) {
    fmt.Println("Helper function: all 3 are equal")
}

这个解决方案也很灵活，您可以使用任意数量的值调用 AllEquals()。

请注意，如果我们愿意在这里调用 reflect.DeepEqual()，我们可以使 AllEquals() 函数更加简洁：

func AllEquals2(v ...interface{}) bool {
    if len(v) < 2 {
        return true
    }
    return reflect.DeepEqual(v[:len(v)-1], v[1:])
}

- icza

---

谢谢您的回答。我将坚持使用a == b && b == c。然而，你那个巧妙的映射方法非常聪明 ;) - timthelion