Wie kann man die Wertgleichheit in Go elegant überprüfen?

Elegante Möglichkeiten zur Überprüfung der Wertegleichheit in Go

In Go erfordert der Vergleich der Gleichheit mehrerer Werte sorgfältige Überlegungen, um Kompilierungsfehler zu vermeiden. Während der einfache Ansatz if a == b == c zu einem Syntaxfehler führt, gibt es mehrere elegante Lösungen für dieses Problem.

1. Verbindung mit booleschen Operationen:

Die Verdichtung des Vergleichs mit dem &&-Operator bietet einen kompakten und lesbaren Ansatz:

<code class="go">if a == b && a == c {
    // All 3 values are equal
}</code>

2. Implementierung eines Kartensatzes:

Die Verwendung einer Karte als Satz kann die Eindeutigkeit von Werten effektiv bestimmen, da gleiche Werte zu einer Karte mit einem einzigen Schlüssel-Wert-Paar führen:

<code class="go">m := map[interface{}]int{a: 0, b: 0, c: 0}
if len(m) == 1 {
    // All 3 values are equal
}</code>

3. Array-Vergleichbarkeit:

Arrays in Go sind vergleichbar und bieten eine einfache Lösung:

<code class="go">arr1 := [2]interface{}{a, b}
arr2 := [2]interface{}{b, c}
if arr1 == arr2 {
    // All 3 values are equal
}</code>

4. Knifflige Karte:

Ein kreativer Ansatz besteht darin, eine Karte zu verwenden, um einen booleschen Wert basierend auf Gleichheit zuzuweisen und ihn dann mit einem anderen Schlüssel abzurufen:

<code class="go">m := map[interface{}]bool{a: b == c}
if m[b] {
    // All 3 values are equal
}</code>

5. Anonyme Strukturen:

Strukturen sind auch in Go vergleichbar, was prägnante Wertevergleiche ermöglicht:

<code class="go">s1 := struct{ a, b interface{} }{a, b}
s2 := struct{ a, b interface{} }{b, c}
if s1 == s2 {
    // All 3 values are equal
}</code>

6. (Benannte) Strukturen mit einer Hilfsfunktion:

Das Erstellen einer benutzerdefinierten Hilfsfunktion kann die Eleganz von Strukturvergleichen verbessern:

<code class="go">type P struct{ a, b interface{} }

func AllEquals(s P, t P) bool {
    return s == t
}

// Usage:
if AllEquals(P{a, b}, P{b, c}) {
    // All 3 values are equal
}</code>

7. Slices mit Reflect.DeepEqual():

Slices sind nicht vergleichbar und erfordern die Verwendung von Reflexion, um die Gleichheit zu bestimmen:

<code class="go">slice1 := []interface{}{a, b}
slice2 := []interface{}{b, c}
if reflect.DeepEqual(slice1, slice2) {
    // All 3 values are equal
}</code>

Diese Lösungen bieten verschiedene Methoden für einen eleganten Vergleich die Gleichheit von drei Werten, die auf unterschiedliche Vorlieben und Codestile eingehen.

Das obige ist der detaillierte Inhalt vonWie kann man die Wertgleichheit in Go elegant überprüfen?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!