Comment faire une déclaration if else sur une seule ligne?

Puis-je écrire une simple instruction if-else avec une affectation de variable dans go (golang) comme je le ferais en php? Par exemple:

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

Actuellement, je dois utiliser ce qui suit:

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

Désolé, je ne me souviens pas du nom si cette instruction de contrôle et je n'ai pas pu trouver les informations sur le site ou via la recherche Google. : /

Comme les commentaires l'ont mentionné, Go ne prend pas en charge les doublures ternaires. La forme la plus courte à laquelle je puisse penser est la suivante:

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

Mais s'il vous plaît ne faites pas cela, cela n'en vaut pas la peine et ne fera que dérouter les personnes qui liront votre code.

J'utilise souvent ce qui suit:

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

fondamentalement la même chose que @ Not_a_Golfer mais en utilisant l' inférence de type .

Comme les autres l'ont mentionné, Gone prend pas en charge les monoplaces ternaires. Cependant, j'ai écrit une fonction utilitaire qui pourrait vous aider à réaliser ce que vous voulez.

// 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
}

Voici quelques cas de test pour montrer comment vous pouvez l'utiliser

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)
}

Pour le plaisir, j'ai écrit des fonctions utilitaires plus utiles telles que:

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

Si vous souhaitez utiliser l'un de ceux-ci, vous pouvez les trouver ici https://github.com/shomali11/util

Merci d'avoir indiqué la bonne réponse.

Je viens de consulter la FAQ de Golang (duh) et il est clairement indiqué que ce n'est pas disponible dans la langue:

Go a-t-il l'opérateur?:?

Il n'y a pas de forme ternaire dans Go. Vous pouvez utiliser les éléments suivants pour obtenir le même résultat:

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

informations supplémentaires trouvées qui pourraient être intéressantes sur le sujet:

• Code Rosetta pour les structures conditionnelles dans Go
• Opérateur ternaire dans l'expérience Go de ce type

Une façon possible de le faire en une seule ligne en utilisant une carte, simple je vérifie si a > bsi elle est truej'assigne cà aautreb

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

Cependant, cela semble incroyable, mais dans certains cas, ce n'est peut-être PAS la solution parfaite en raison de l'ordre d'évaluation. Par exemple, si je vérifie si un objet n'en nilobtient pas une propriété, regardez l'extrait de code suivant qui le fera panicen cas demyObj 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}

Parce que la carte sera créée et construite avant d'évaluer la condition, dans ce cas, myObj = nilcela paniquera simplement.

Sans oublier de mentionner que vous pouvez toujours faire les conditions en une seule ligne simple, vérifiez les points suivants:

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

Utiliser la fonction lambda au lieu de l'opérateur ternaire

Exemple 1

pour donner le max int

package main

func main() {

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

Exemple 2

Supposons que vous ayez cette must(err error)fonction pour gérer les erreurs et que vous souhaitiez l'utiliser lorsqu'une condition n'est pas remplie. (profitez-en sur 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)
}

Parfois, j'essaie d'utiliser la fonction anonyme pour que la définition et l'attribution se produisent sur la même ligne. comme ci-dessous:

a, b = 4, 8

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

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

Une construction très similaire est disponible dans la langue

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

*

c'est à dire

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

Vous pouvez utiliser une fermeture pour cela:

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() })
}

Le seul reproche que j'ai avec la syntaxe de fermeture dans Go est qu'il n'y a pas d'alias pour la fonction de retour zéro paramètre zéro par défaut, alors ce serait beaucoup plus agréable (pensez à la façon dont vous déclarez les littéraux de carte, de tableau et de tranche avec juste un nom de type).

Ou même la version plus courte, comme un commentateur vient de le suggérer:

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)
}

Vous auriez toujours besoin d'utiliser une fermeture si vous deviez donner des paramètres aux fonctions. Cela pourrait être évité dans le cas du passage de méthodes plutôt que de simples fonctions, je pense, où les paramètres sont la structure associée aux méthodes.