Quel est l'équivalent Go idiomatique de l'opérateur ternaire de C?

En C / C ++ (et dans de nombreux langages de cette famille), un idiome commun pour déclarer et initialiser une variable en fonction d'une condition utilise l'opérateur conditionnel ternaire:

int index = val > 0 ? val : -val

Go n'a pas l'opérateur conditionnel. Quelle est la façon la plus idiomatique d'implémenter le même morceau de code que ci-dessus? Je suis arrivé à la solution suivante, mais elle semble assez verbeuse

var index int

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

Y a-t-il quelque chose de mieux?

Comme souligné (et sans surprise, espérons-le), l'utilisation if+elseest en effet la façon idiomatique de faire des conditions dans Go.

En plus du var+if+elsebloc de code complet , cette orthographe est également souvent utilisée:

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

et si vous avez un bloc de code suffisamment répétitif, comme l'équivalent de int value = a <= b ? a : b, vous pouvez créer une fonction pour le contenir:

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

...

value := min(a, b)

Le compilateur insérera ces fonctions simples, il est donc rapide, plus clair et plus court.

No Go n'a pas d'opérateur ternaire, en utilisant la syntaxe if / else est la manière idiomatique.

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

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

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

La raison ?:est absente de Go est que les concepteurs du langage avaient vu l'opération utilisée trop souvent pour créer des expressions d'une complexité impénétrable. La if-elseforme, bien que plus longue, est incontestablement plus claire. Un langage n'a besoin que d'une seule construction de flux de contrôle conditionnel.

- Foire aux questions (FAQ) - Le langage de programmation Go

Supposons que vous ayez l'expression ternaire suivante (en C):

int a = test ? 1 : 2;

L'approche idiomatique dans Go serait d'utiliser simplement un ifbloc:

var a int

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

Cependant, cela pourrait ne pas correspondre à vos besoins. Dans mon cas, j'avais besoin d'une expression en ligne pour un modèle de génération de code.

J'ai utilisé une fonction anonyme immédiatement évaluée:

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

Cela garantit que les deux branches ne sont pas également évaluées.

La carte ternaire est facile à lire sans parenthèses:

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

Cela ne surclassera pas si / else et nécessite un cast mais fonctionne. Pour info:

BenchmarkAbsTernary-8 100000000 18.8 ns / op

BenchmarkAbsIfElse-8 2000000000 0,27 ns / op

Si toutes vos branches produisent des effets secondaires ou sont coûteuses en calcul, ce qui suit serait une refactorisation sémantiquement préservée :

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

sans surcharge (en ligne) et, surtout, sans encombrer votre espace de noms avec des fonctions d'assistance qui ne sont utilisées qu'une seule fois (ce qui nuit à la lisibilité et à la maintenance). Exemple en direct

Notez si vous deviez appliquer naïvement l'approche de Gustavo :

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

vous obtiendriez un programme avec un comportement différent ; au cas où le val <= 0programme imprimerait une valeur non positive alors qu'il ne devrait pas! (De façon analogue, si vous inversiez les branches, vous introduiriez une surcharge en appelant une fonction lente inutilement.)

Avant-propos: Sans prétendre que if elsec'est la voie à suivre, nous pouvons toujours jouer avec et trouver du plaisir dans les constructions basées sur le langage.

La Ifconstruction suivante est disponible dans ma github.com/icza/goxbibliothèque avec beaucoup d'autres méthodes, étant le builtinx.Iftype.

Go permet d'attacher des méthodes à tous les types définis par l'utilisateur , y compris les types primitifs tels que bool. Nous pouvons créer un type personnalisé ayant boolcomme type sous-jacent , puis avec une conversion de type simple à la condition, nous avons accès à ses méthodes. Méthodes qui reçoivent et sélectionnent les opérandes.

Quelque chose comme ça:

type If bool

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

Comment pouvons-nous l'utiliser?

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

Par exemple un ternaire faisant max():

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

Un ternaire faisant abs():

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

Cela a l'air cool, c'est simple, élégant et efficace (il est également éligible pour l'inline ).

Un inconvénient par rapport à un "vrai" opérateur ternaire: il évalue toujours tous les opérandes.

Pour obtenir une évaluation différée et uniquement si nécessaire, la seule option consiste à utiliser des fonctions (soit des fonctions ou méthodes déclarées , soit des littéraux de fonction ), qui ne sont appelées que lorsque / si nécessaire:

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

Utilisation: Supposons que nous avons ces fonctions pour calculer aet b:

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

Ensuite:

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

Par exemple, la condition étant l'année en cours> 2020:

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

Si nous voulons utiliser des littéraux de fonction:

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

Remarque finale: si vous aviez des fonctions avec des signatures différentes, vous ne pourriez pas les utiliser ici. Dans ce cas, vous pouvez utiliser un littéral de fonction avec une signature correspondante pour les rendre toujours applicables.

Par exemple, si calca()et calcb()aurait également des paramètres (en plus de la valeur de retour):

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

Voici comment vous pouvez les utiliser:

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

Essayez ces exemples sur le Go Playground .

La réponse d'Eold est intéressante et créative, peut-être même intelligente.

Cependant, il serait recommandé de faire à la place:

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

Oui, ils se compilent tous les deux essentiellement vers le même assembly, mais ce code est beaucoup plus lisible que d'appeler une fonction anonyme juste pour renvoyer une valeur qui aurait pu être écrite dans la variable en premier lieu.

Fondamentalement, un code simple et clair est meilleur qu'un code créatif.

De plus, tout code utilisant un littéral de carte n'est pas une bonne idée, car les cartes ne sont pas du tout légères dans Go. Depuis Go 1.3, l'ordre d'itération aléatoire pour les petites cartes est garanti, et pour l'appliquer, il est devenu un peu moins efficace en termes de mémoire pour les petites cartes.

Par conséquent, la création et la suppression de nombreuses petites cartes prennent à la fois de l'espace et du temps. J'avais un morceau de code qui utilisait une petite carte (deux ou trois clés, probablement, mais le cas d'utilisation courant n'était qu'une entrée) Mais le code était lent. Nous parlons d'au moins 3 ordres de grandeur plus lentement que le même code réécrit pour utiliser une clé à double tranche [index] => data [index] map. Et c'était probablement plus. Comme certaines opérations qui prenaient auparavant quelques minutes à exécuter, ont commencé à se terminer en millisecondes. \

Les doublures, bien que rejetées par les créateurs, ont leur place.

Celui-ci résout le problème de l'évaluation paresseuse en vous laissant, éventuellement, passer des fonctions à évaluer si nécessaire:

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

Production

hello
hello world
hello world
hello
bye

• Les fonctions passées doivent retourner un interface{}pour satisfaire l'opération de transtypage interne.
• Selon le contexte, vous pouvez choisir de convertir la sortie en un type spécifique.
• Si vous souhaitez renvoyer une fonction à partir de cela, vous devrez l'encapsuler comme indiqué avec c.

La solution autonome ici est également agréable, mais pourrait être moins claire pour certaines utilisations.