Was ist das idiomatische Go-Äquivalent des ternären Operators von C?

In C / C ++ (und vielen Sprachen dieser Familie) verwendet ein allgemeines Idiom zum Deklarieren und Initialisieren einer Variablen in Abhängigkeit von einer Bedingung den ternären Bedingungsoperator:

int index = val > 0 ? val : -val

Go hat keinen bedingten Operator. Was ist die idiomatischste Methode, um denselben Code wie oben zu implementieren? Ich bin zu der folgenden Lösung gekommen, aber sie scheint ziemlich ausführlich zu sein

var index int

if val > 0 {
    index = val
} else {
    index = -val
}

Gibt es etwas besseres?

Wie bereits erwähnt (und hoffentlich nicht überraschend), if+elseist die Verwendung in der Tat die idiomatische Methode , um in Go Bedingungen zu erfüllen.

Zusätzlich zum vollständigen var+if+elseCodeblock wird diese Schreibweise jedoch häufig verwendet:

index := val
if val <= 0 {
    index = -val
}

Wenn Sie einen Codeblock haben, der sich wiederholt, z. B. das Äquivalent von int value = a <= b ? a : b, können Sie eine Funktion erstellen, um ihn zu speichern:

func min(a, b int) int {
    if a <= b {
        return a
    }
    return b
}

...

value := min(a, b)

Der Compiler integriert solche einfachen Funktionen, sodass sie schnell, klarer und kürzer sind.

No Go hat keinen ternären Operator. Die Verwendung der if / else-Syntax ist die idiomatische Methode.

Warum hat Go nicht den Operator ?:?

In Go gibt es keine ternäre Testoperation. Sie können Folgendes verwenden, um das gleiche Ergebnis zu erzielen:

if expr {
    n = trueVal
} else {
    n = falseVal
}

Der Grund ?:, der in Go fehlt, ist, dass die Designer der Sprache die Operation zu oft verwendet hatten, um undurchdringlich komplexe Ausdrücke zu erstellen. Die if-elseForm ist zwar länger, aber zweifellos klarer. Eine Sprache benötigt nur ein bedingtes Kontrollflusskonstrukt.

- Häufig gestellte Fragen (FAQ) - Die Programmiersprache Go

Angenommen, Sie haben den folgenden ternären Ausdruck (in C):

int a = test ? 1 : 2;

Der idiomatische Ansatz in Go wäre, einfach einen ifBlock zu verwenden:

var a int

if test {
  a = 1
} else {
  a = 2
}

Dies entspricht jedoch möglicherweise nicht Ihren Anforderungen. In meinem Fall benötigte ich einen Inline-Ausdruck für eine Codegenerierungsvorlage.

Ich habe eine sofort ausgewertete anonyme Funktion verwendet:

a := func() int { if test { return 1 } else { return 2 } }()

Dies stellt sicher, dass nicht beide Zweige ebenfalls ausgewertet werden.

Die ternäre Karte ist ohne Klammern leicht zu lesen:

c := map[bool]int{true: 1, false: 0} [5 > 4]

func Ternary(statement bool, a, b interface{}) interface{} {
    if statement {
        return a
    }
    return b
}

func Abs(n int) int {
    return Ternary(n >= 0, n, -n).(int)
}

Dies wird nicht übertreffen, wenn / sonst und erfordert Besetzung, funktioniert aber. Zu Ihrer Information:

BenchmarkAbsTernary-8 100000000 18,8 ns / op

BenchmarkAbsIfElse-8 2000000000 0,27 ns / op

Wenn alle Ihre Filialen Nebenwirkungen haben oder rechenintensiv sind, wäre das Folgende ein semantisch konservierendes Refactoring:

index := func() int {
    if val > 0 {
        return printPositiveAndReturn(val)
    } else {
        return slowlyReturn(-val)  // or slowlyNegate(val)
    }
}();  # exactly one branch will be evaluated

Normalerweise ohne Overhead (inline) und vor allem ohne Ihren Namespace mit Hilfsfunktionen zu überladen, die nur einmal verwendet werden (was die Lesbarkeit und Wartung beeinträchtigt). Live-Beispiel

Beachten Sie, wenn Sie Gustavos Ansatz naiv anwenden sollten :

    index := printPositiveAndReturn(val);
    if val <= 0 {
        index = slowlyReturn(-val);  // or slowlyNegate(val)
    }

Sie würden ein Programm mit einem anderen Verhalten erhalten ; falls das val <= 0Programm einen nicht positiven Wert drucken würde, während dies nicht der Fall sein sollte! (Analog dazu würden Sie, wenn Sie die Zweige umkehren, Overhead einführen, indem Sie unnötig eine langsame Funktion aufrufen.)

Vorwort: Ohne zu argumentieren, dass dies if elseder richtige Weg ist, können wir immer noch mit sprachfähigen Konstrukten spielen und Freude daran haben.

Das folgende IfKonstrukt ist in meiner github.com/icza/goxBibliothek mit vielen anderen Methoden verfügbar , nämlich dem builtinx.IfTyp.

Mit Go können Methoden an benutzerdefinierte Typen angehängt werden , einschließlich primitiver Typen wie z bool. Wir können einen benutzerdefinierten Typ mit booldem zugrunde liegenden Typ erstellen und dann mit einer einfachen Typkonvertierung für die Bedingung auf seine Methoden zugreifen. Methoden, die Operanden empfangen und aus diesen auswählen.

Etwas wie das:

type If bool

func (c If) Int(a, b int) int {
    if c {
        return a
    }
    return b
}

Wie können wir es benutzen?

i := If(condition).Int(val1, val2)  // Short variable declaration, i is of type int
     |-----------|  \
   type conversion   \---method call

Zum Beispiel ein ternäres Tun max():

i := If(a > b).Int(a, b)

Ein ternäres Tun abs():

i := If(a >= 0).Int(a, -a)

Das sieht cool aus, ist einfach, elegant und effizient (es ist auch zum Inlining geeignet ).

Ein Nachteil im Vergleich zu einem "echten" ternären Operator: Er wertet immer alle Operanden aus.

Um eine verzögerte Auswertung zu erreichen, besteht die einzige Möglichkeit darin, Funktionen (entweder deklarierte Funktionen oder Methoden oder Funktionsliterale ) zu verwenden, die nur bei Bedarf aufgerufen werden:

func (c If) Fint(fa, fb func() int) int {
    if c {
        return fa()
    }
    return fb()
}

Verwenden Sie es: Nehmen wir an, wir haben diese Funktionen zu berechnen aund b:

func calca() int { return 3 }
func calcb() int { return 4 }

Dann:

i := If(someCondition).Fint(calca, calcb)

Zum Beispiel ist die Bedingung aktuelles Jahr> 2020:

i := If(time.Now().Year() > 2020).Fint(calca, calcb)

Wenn wir Funktionsliterale verwenden möchten:

i := If(time.Now().Year() > 2020).Fint(
    func() int { return 3 },
    func() int { return 4 },
)

Schlussbemerkung: Wenn Sie Funktionen mit unterschiedlichen Signaturen hätten, könnten Sie diese hier nicht verwenden. In diesem Fall können Sie ein Funktionsliteral mit übereinstimmender Signatur verwenden, um sie weiterhin anwendbar zu machen.

Zum Beispiel, wenn calca()und calcb()neben dem Rückgabewert auch Parameter vorhanden wären:

func calca2(x int) int { return 3 }
func calcb2(x int) int { return 4 }

So könnten Sie sie verwenden:

i := If(time.Now().Year() > 2020).Fint(
    func() int { return calca2(0) },
    func() int { return calcb2(0) },
)

Probieren Sie diese Beispiele auf dem Go Playground aus .

Eolds Antwort ist interessant und kreativ, vielleicht sogar klug.

Es wird jedoch empfohlen, stattdessen Folgendes zu tun:

var index int
if val > 0 {
    index = printPositiveAndReturn(val)
} else {
    index = slowlyReturn(-val)  // or slowlyNegate(val)
}

Ja, beide werden im Wesentlichen auf dieselbe Assembly kompiliert. Dieser Code ist jedoch viel besser lesbar als das Aufrufen einer anonymen Funktion, nur um einen Wert zurückzugeben, der überhaupt in die Variable geschrieben werden könnte.

Grundsätzlich ist einfacher und klarer Code besser als kreativer Code.

Darüber hinaus ist jeder Code, der ein Kartenliteral verwendet, keine gute Idee, da Karten in Go überhaupt nicht leichtgewichtig sind. Seit Go 1.3 ist die zufällige Iterationsreihenfolge für kleine Karten garantiert, und um dies zu erzwingen, ist die Speicherkapazität für kleine Karten erheblich geringer.

Das Erstellen und Entfernen zahlreicher kleiner Karten ist daher sowohl platz- als auch zeitaufwändig. Ich hatte einen Code, der eine kleine Karte verwendete (zwei oder drei Schlüssel sind wahrscheinlich, aber der übliche Anwendungsfall war nur ein Eintrag). Aber der Code war hundeschwach. Wir sprechen von mindestens 3 Größenordnungen langsamer als derselbe Code, der neu geschrieben wurde, um eine Dual-Slice-Key-Karte [index] => data [index] zu verwenden. Und wahrscheinlich war mehr. Einige Vorgänge, deren Ausführung zuvor einige Minuten dauerte, wurden in Millisekunden abgeschlossen. \

Einzeiler haben ihren Platz, obwohl sie von den Machern gemieden werden.

Dieser löst das Problem der verzögerten Bewertung, indem Sie optional Funktionen übergeben können, die bei Bedarf ausgewertet werden sollen:

func FullTernary(e bool, a, b interface{}) interface{} {
    if e {
        if reflect.TypeOf(a).Kind() == reflect.Func {
            return a.(func() interface{})()
        }
        return a
    }
    if reflect.TypeOf(b).Kind() == reflect.Func {
        return b.(func() interface{})()
    }
    return b
}

func demo() {
    a := "hello"
    b := func() interface{} { return a + " world" }
    c := func() interface{} { return func() string { return "bye" } }
    fmt.Println(FullTernary(true, a, b).(string)) // cast shown, but not required
    fmt.Println(FullTernary(false, a, b))
    fmt.Println(FullTernary(true, b, a))
    fmt.Println(FullTernary(false, b, a))
    fmt.Println(FullTernary(true, c, nil).(func() string)())
}

Ausgabe

hello
hello world
hello world
hello
bye

• Übergebene Funktionen müssen ein zurückgeben interface{}, um die interne Cast-Operation zu erfüllen.
• Je nach Kontext können Sie die Ausgabe in einen bestimmten Typ umwandeln.
• Wenn Sie eine Funktion von dieser zurückgeben möchten, müssen Sie sie wie gezeigt umbrechen c.

Die eigenständige Lösung hier ist ebenfalls nett, könnte aber für einige Anwendungen weniger klar sein.