Operador ternário em Golang: por que Go não tem e o que usar

Go não tem operador ternário. Não existe cond ? a : b. O substituto idiomático é uma instrução if:

package main

import "fmt"

func main() {
	for _, n := range []int{3, 8} {
		// In C or JavaScript: parity = n % 2 == 0 ? "even" : "odd";
		parity := "odd"
		if n%2 == 0 {
			parity = "even"
		}
		fmt.Println(n, parity)
	}
}

Declare a variável com o valor padrão e depois mude-o no if. Quando os dois ramos precisam de trabalho, use if/else:

var fee int
if member {
	fee = 0
} else {
	fee = computeFee(order)
}

Por que Go deixou isso de fora

O FAQ do Go responde diretamente: os criadores tinham visto o operador ?: ser usado vezes demais para criar expressões impenetráveis de tão complexas, e decidiram que o if/else, embora mais longo, é inquestionavelmente mais claro. Uma linguagem precisa de uma só construção de controle de fluxo condicional.

Na prática, a falta do operador custa duas ou três linhas por uso e elimina toda uma categoria de expressões aninhadas como a ? b ? c : d : e.

Retornar cedo no lugar

Dentro de uma função, a forma mais limpa muitas vezes dispensa a variável:

package main

import "fmt"

func plural(n int, word string) string {
	if n == 1 {
		return word
	}
	return word + "s"
}

func main() {
	fmt.Println(1, plural(1, "file"))
	fmt.Println(3, plural(3, "file"))
}

Levar a condição para uma pequena função com nome costuma ser a melhor resposta: o ponto de chamada fica parecido com o ternário que você queria, e o nome da função documenta o que a condição significa.

Valores padrão com cmp.Or (Go 1.22)

O ternário mais comum em outras linguagens é "use este valor, ou um substituto se estiver vazio": name ? name : "anonymous", ou name || "anonymous" em JavaScript. O Go 1.22 trouxe o cmp.Or exatamente para isso. Ele devolve o primeiro argumento que não é o valor zero do seu tipo:

package main

import (
	"cmp"
	"fmt"
)

func main() {
	name := ""
	fmt.Println(cmp.Or(name, "anonymous"))

	name = "Ana"
	fmt.Println(cmp.Or(name, "anonymous"))

	port := 0
	fmt.Println(cmp.Or(port, 8080))

	// several fallbacks, first non-zero wins
	envValue, configValue := "", "eu-west-1"
	fmt.Println(cmp.Or(envValue, configValue, "us-east-1"))
}

Ele trata o valor zero como "ausente", então não diferencia "a porta é 0 de propósito" de "a porta não foi definida". Quando zero é um valor válido, use um ponteiro, um bool separado ou um if explícito.

Um helper If genérico, e a sua armadilha

Com generics (Go 1.18), você pode escrever uma função que parece um ternário:

func If[T any](cond bool, a, b T) T {
	if cond {
		return a
	}
	return b
}

status := If(ok, "pass", "fail")

Funciona para valores simples, e alguns projetos usam. Mas ela não é um operador ternário, e a diferença importa. O Go avalia todos os argumentos antes de chamar uma função, então a e b são sempre calculados:

package main

import "fmt"

func If[T any](cond bool, a, b T) T {
	if cond {
		return a
	}
	return b
}

func expensive(label string) string {
	fmt.Println("  computing", label)
	return label
}

type User struct{ Name string }

func main() {
	fmt.Println("If(true, ...):")
	v := If(true, expensive("a"), expensive("b"))
	fmt.Println("  result:", v)

	var u *User // nil
	defer func() {
		if r := recover(); r != nil {
			fmt.Println("panic:", r)
		}
	}()
	name := If(u != nil, u.Name, "guest") // u.Name is evaluated even though u is nil
	fmt.Println(name)
}

A primeira chamada calcula tanto "a" quanto "b", e a segunda causa panic de desreferência de ponteiro nil, mesmo com a condição falsa. Um ternário de verdade avaliaria só o lado escolhido. Então:

• Nunca use um helper assim quando um dos lados desreferencia um ponteiro, indexa um slice ou lê uma entrada de map que pode não existir.
• Nunca o use quando um dos lados for caro ou tiver efeitos colaterais.
• Para valores baratos e seguros funciona, mas muitos revisores de código Go ainda vão pedir o if simples.

Você pode tornar os ramos preguiçosos passando funções, If(ok, func() string { return a }, func() string { return b }), mas a essa altura a instrução if é mais curta.

Outros truques, e por que evitá-los

Busca em map. map[bool]string{true: "yes", false: "no"}[ok] funciona, monta um map e calcula hashes a cada avaliação, e avalia os dois valores. É uma curiosidade, não um idioma.

Função invocada na hora. Uma função anônima chamada no próprio lugar dá uma expressão:

label := func() string {
	if n > 0 {
		return "positive"
	}
	return "non-positive"
}()

Essa sim avalia de forma preguiçosa, e às vezes ajuda dentro de um literal composto, onde não cabe uma instrução. Na maioria das vezes, calcular o valor em uma variável logo antes do literal é mais claro.

Escolhendo um substituto

Propostas para acrescentar uma expressão condicional aparecem com frequência no issue tracker do Go e até agora foram recusadas. Escreva o if.

label := "odd"
if n%2 == 0 {
	label = "even"
}