Comprobando la igualdad de tres valores elegantemente

mientras que el enfoque tradicional con a == b == c da como resultado un error de sintaxis, hay métodos alternativos para determinar si tres valores son iguales.

usando un claro y en exceso Enfoque

La solución más simple sigue siendo:

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

esta solución es sencilla y eficiente, haciendo comparaciones por par. Al usar un mapa con las teclas de interfaz {}, podemos verificar si todos los valores son iguales comparando la longitud del mapa con 1:

if len (map [interfaz {}] int {a: 0, b: 0, c: 0}) == 1 { fmt.println ("todos los 3 son iguales") }

con matrices:

Las matrices son comparables, lo que nos permite comparar múltiples elementos de una vez:

if [2] interfaz {} {A, b} == [2] interfaz} {b, c}}}}}}}}}}} fmt.println ("todos los 3 son iguales") }

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

usando un mapa difícil:

podemos indexar un mapa con un clave que resulte en el valor de comparación:

[&]

if Map [interface {}] bool {a: b == c} [b] { fmt.println ("todos los 3 son iguales") }

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

Las estructuras también son comparables, por lo que podemos crear una estructura anónima con los valores y compararlos:

if struct {a, b interfaz {}} {A, b} } {b, c} { fmt.println ("todos los 3 son iguales") }

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

para comparar las cortes, utilizamos la función refleje. fmt.println ("todos los 3 son iguales") }

usando una función Helper:

if struct{ a, b interface{} }{a, b} == struct{ a, b interface{} }{b, c} {
    fmt.Println("All 3 are equal")
}

func Allequals (v ... Interface {}) bool { Si len (v)> 1 { A: = V [0] para _, s: = rango V { Si a! = S { devolver falso } } } Devolver verdadero }