Wie mache ich einzeilige wenn sonst Aussage?

Kann ich eine einfache if-else-Anweisung mit variabler Zuweisung in go (golang) schreiben, wie ich es in PHP tun würde? Beispielsweise:

$var = ( $a > $b )? $a: $b;

Derzeit muss ich folgendes verwenden:

var c int
if a > b {
    c = a
} else {
    c = b
}

Entschuldigung, ich kann mich nicht an den Namen erinnern, wenn diese Steueranweisung und ich die Informationen nicht vor Ort oder über die Google-Suche finden konnten. : /

Wie in den Kommentaren erwähnt, unterstützt Go keine ternären Einzeiler. Die kürzeste Form, die ich mir vorstellen kann, ist folgende:

var c int
if c = b; a > b {
    c = a
}

Aber bitte tun Sie das nicht, es lohnt sich nicht und wird nur Leute verwirren, die Ihren Code lesen.

Ich benutze oft Folgendes:

c := b
if a > b {
    c = a
}

Im Grunde das gleiche wie bei @ Not_a_Golfer, jedoch mit Typinferenz .

Wie die anderen erwähnt, Gounterstützt keine ternären Einzeiler. Ich habe jedoch eine Dienstprogrammfunktion geschrieben, mit der Sie das erreichen können, was Sie möchten.

// IfThenElse evaluates a condition, if true returns the first parameter otherwise the second
func IfThenElse(condition bool, a interface{}, b interface{}) interface{} {
    if condition {
        return a
    }
    return b
}

Hier sind einige Testfälle, um zu zeigen, wie Sie es verwenden können

func TestIfThenElse(t *testing.T) {
    assert.Equal(t, IfThenElse(1 == 1, "Yes", false), "Yes")
    assert.Equal(t, IfThenElse(1 != 1, nil, 1), 1)
    assert.Equal(t, IfThenElse(1 < 2, nil, "No"), nil)
}

Zum Spaß habe ich weitere nützliche Dienstprogrammfunktionen geschrieben, wie zum Beispiel:

IfThen(1 == 1, "Yes") // "Yes"
IfThen(1 != 1, "Woo") // nil
IfThen(1 < 2, "Less") // "Less"

IfThenElse(1 == 1, "Yes", false) // "Yes"
IfThenElse(1 != 1, nil, 1)       // 1
IfThenElse(1 < 2, nil, "No")     // nil

DefaultIfNil(nil, nil)  // nil
DefaultIfNil(nil, "")   // ""
DefaultIfNil("A", "B")  // "A"
DefaultIfNil(true, "B") // true
DefaultIfNil(1, false)  // 1

FirstNonNil(nil, nil)                // nil
FirstNonNil(nil, "")                 // ""
FirstNonNil("A", "B")                // "A"
FirstNonNil(true, "B")               // true
FirstNonNil(1, false)                // 1
FirstNonNil(nil, nil, nil, 10)       // 10
FirstNonNil(nil, nil, nil, nil, nil) // nil
FirstNonNil()                        // nil

Wenn Sie eines davon verwenden möchten, finden Sie es hier https://github.com/shomali11/util

Vielen Dank für den Hinweis auf die richtige Antwort.

Ich habe gerade die Golang-FAQ (duh) überprüft und es heißt eindeutig, dass dies nicht in der Sprache verfügbar ist:

Hat Go den Operator ?:?

Es gibt keine ternäre Form in Go. Sie können Folgendes verwenden, um das gleiche Ergebnis zu erzielen:

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

Zusätzliche Informationen, die zu diesem Thema von Interesse sein könnten:

• Rosetta-Code für bedingte Strukturen in Go
• Ternary Operator in Go experimentiert von diesem Typen

Eine Möglichkeit , dies zu tun in nur eine Zeile durch eine Karte verwenden, einfach ich bin Überprüfung , ob , a > bwenn es trueich bin Zuweisung czu asonstb

c := map[bool]int{true: a, false: b}[a > b]

Dies sieht zwar erstaunlich aus, ist jedoch in einigen Fällen aufgrund der Bewertungsreihenfolge möglicherweise NICHT die perfekte Lösung. Wenn ich zum Beispiel überprüfe, ob ein Objekt keine nilEigenschaft daraus erhält, sehen Sie sich das folgende Code-Snippet an, das panicim Falle vonmyObj equals nil

type MyStruct struct {
   field1 string
   field2 string 
}

var myObj *MyStruct
myObj = nil 

myField := map[bool]string{true: myObj.field1, false: "empty!"}[myObj != nil}

Da die Karte zuerst erstellt und erstellt wird, bevor der Zustand bewertet wird, kommt es in diesem Fall myObj = nileinfach zu einer Panik.

Um nicht zu vergessen zu erwähnen, dass Sie die Bedingungen immer noch in nur einer einfachen Zeile ausführen können, überprüfen Sie Folgendes:

var c int
...
if a > b { c = a } else { c = b}

Verwenden Sie die Lambda-Funktion anstelle des ternären Operators

Beispiel 1

um die max int zu geben

package main

func main() {

    println( func(a,b int) int {if a>b {return a} else {return b} }(1,2) )
}

Beispiel 2

Angenommen, Sie haben diese must(err error)Funktion zur Behandlung von Fehlern und möchten sie verwenden, wenn eine Bedingung nicht erfüllt ist. (viel Spaß unter https://play.golang.com/p/COXyo0qIslP )

package main

import (
    "errors"
    "log"
    "os"
)

// must is a little helper to handle errors. If passed error != nil, it simply panics.
func must(err error) {
    if err != nil {
        log.Println(err)
        panic(err)
    }
}

func main() {

    tmpDir := os.TempDir()
    // Make sure os.TempDir didn't return empty string
    // reusing my favourite `must` helper
    // Isn't that kinda creepy now though?
    must(func() error {
        var err error
        if len(tmpDir) > 0 {
            err = nil
        } else {
            err = errors.New("os.TempDir is empty")
        }
        return err
    }()) // Don't forget that empty parentheses to invoke the lambda.
    println("We happy with", tmpDir)
}

Manchmal versuche ich, eine anonyme Funktion zu verwenden, um das Definieren und Zuweisen in derselben Zeile zu erreichen. Wie unten:

a, b = 4, 8

c := func() int {
    if a >b {
      return a
    } 
    return b
  } ()

https://play.golang.org/p/rMjqytMYeQ0

Eine sehr ähnliche Konstruktion ist in der Sprache verfügbar

**if <statement>; <evaluation> {
   [statements ...]
} else {
   [statements ...]
}*

* *

dh

if path,err := os.Executable(); err != nil {
   log.Println(err)
} else {
   log.Println(path)
}

Sie können hierfür einen Verschluss verwenden:

func doif(b bool, f1, f2 func()) {
    switch{
    case b:
        f1()
    case !b:   
        f2()
    }
}

func dothis() { fmt.Println("Condition is true") }

func dothat() { fmt.Println("Condition is false") }

func main () {
    condition := true
    doif(condition, func() { dothis() }, func() { dothat() })
}

Der einzige Kritikpunkt, den ich an der Abschlusssyntax in Go habe, ist, dass es keinen Alias ​​für die Standard-Nullparameter-Rückgabefunktion gibt. Dann wäre es viel schöner (denken Sie daran, wie Sie Map-, Array- und Slice-Literale mit nur einem Typnamen deklarieren).

Oder sogar die kürzere Version, wie ein Kommentator gerade vorgeschlagen hat:

func doif(b bool, f1, f2 func()) {
    switch{
    case b:
        f1()
    case !b:   
        f2()
    }
}

func dothis() { fmt.Println("Condition is true") }

func dothat() { fmt.Println("Condition is false") }

func main () {
    condition := true
    doif(condition, dothis, dothat)
}

Sie müssten immer noch einen Abschluss verwenden, wenn Sie den Funktionen Parameter zuweisen müssten. Dies könnte vermieden werden, wenn Methoden übergeben werden und nicht nur Funktionen, von denen ich denke, dass die Parameter die mit den Methoden verknüpfte Struktur sind.