Wie kann man die Gleichheit zwischen drei Werten in Go effizient prüfen?

Effiziente Möglichkeiten, die Gleichheit von drei Werten zu überprüfen

In Go kann der Vergleich mehrerer Variablen auf Gleichheit eine Herausforderung sein. Während der unkomplizierte Ansatz if a == b == c zu Kompilierungsfehlern führt, gibt es mehrere alternative Methoden, die elegante und effiziente Lösungen bieten.

Der klare und prägnante Ansatz

Der empfohlene und Der einfachste Weg, um festzustellen, ob drei Werte identisch sind, ist:

<code class="go">if a == b && a == c {
    fmt.Println("All 3 are equal")
}</code>

Diese Methode nutzt die Tatsache, dass Go beim Vergleich zweier Werte einen Booleschen Wert zurückgibt, um einen klaren und lesbaren Code zu gewährleisten.

Alternativen zum Experimentieren

Während die obige Lösung optimal ist, gibt es verschiedene kreative Optionen, die man zum Experimentieren erkunden könnte:

Karte als Set:

<code class="go">if len(map[interface{}]int{a: 0, b: 0, c: 0}) == 1 {
    fmt.Println("Via a map set: all 3 are equal")
}</code>

Das Konzept hinter dieser Methode besteht darin, die Werte als Schlüssel zu einer Karte hinzuzufügen. Wenn sie alle gleich sind, enthält die Karte nur einen Schlüssel, was zu einer Länge von 1 führt.

Arrays:

<code class="go">if [2]interface{}{a, b} == [2]interface{}{b, c} {
    fmt.Println("Via arrays: all 3 are equal")
}</code>

Arrays sind von Natur aus vergleichbar, sodass wir drei Werte mit == vergleichen können. Dieser Ansatz eignet sich jedoch nur zum Vergleich einer bestimmten Anzahl von Werten.

Tricky Map:

<code class="go">if map[interface{}]bool{a: b == c}[b] {
    fmt.Println("Via a tricky map: all 3 are equal")
}</code>

Diese Methode verwendet eine Karte, um das Ergebnis zuzuordnen b == c auf einen Schlüssel und greift dann auf den Wert zu, der demselben Schlüssel zugeordnet ist. Wenn a == b, wird das Ergebnis von b == c zurückgegeben, was Gleichheit anzeigt.

Anonyme Strukturen:

<code class="go">if struct{ a, b interface{} }{a, b} == struct{ a, b interface{} }{b, c} {
    fmt.Println("Via anonymous structs: all 3 are equal")
}</code>

Verschachtelte Strukturen sind vergleichbar, was uns erlaubt um drei Werte mit einer prägnanten Syntax zu vergleichen.

Slices:

<code class="go">if reflect.DeepEqual([]interface{}{a, b}, []interface{}{b, c}) {
    fmt.Println("Via slices: all 3 are equal")
}</code>

Während Slices selbst nicht vergleichbar sind, kann die Funktion „reflect.DeepEqual()“ ihre Gleichheit bestimmen , sodass wir ihre Inhalte vergleichen können.

Hilfsfunktion:

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

Diese wiederverwendbare Funktion vereinfacht den Vergleich mehrerer Werte, indem sie iterativ die Gleichheit prüft und ein boolesches Ergebnis zurückgibt . Es kann mit einer beliebigen Anzahl von Variablen verwendet werden.

Das obige ist der detaillierte Inhalt vonWie kann man die Gleichheit zwischen drei Werten in Go effizient prüfen?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!