Qual é o equivalente Go idiomático do operador ternário de C?

Em C / C ++ (e em muitos idiomas dessa família), um idioma comum para declarar e inicializar uma variável dependendo de uma condição usa o operador condicional ternário:

int index = val > 0 ? val : -val

Go não tem o operador condicional. Qual é a maneira mais idiomática de implementar o mesmo trecho de código acima? Cheguei à seguinte solução, mas parece bastante detalhada

var index int

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

Existe algo melhor?

Como apontado (e espero que não surpreenda), usar if+elseé realmente a maneira idiomática de fazer condicionais no Go.

Além do var+if+elsebloco de código completo , porém, essa ortografia também é usada com frequência:

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

e se você tiver um bloco de código que seja repetitivo o suficiente, como o equivalente a int value = a <= b ? a : b, poderá criar uma função para mantê-lo:

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

...

value := min(a, b)

O compilador incorporará funções simples, por isso é rápido, mais claro e mais curto.

O No Go não possui um operador ternário, usando a sintaxe if / else é a maneira idiomática.

Por que o Go não possui o operador?:?

Não há operação de teste ternário no Go. Você pode usar o seguinte para alcançar o mesmo resultado:

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

O motivo ?:é ausente de Go é que os designers da linguagem viram a operação ser usada com muita frequência para criar expressões impenetrávelmente complexas. A if-elseforma, embora mais longa, é inquestionavelmente mais clara. Uma linguagem precisa apenas de uma construção de fluxo de controle condicional.

- Perguntas freqüentes (FAQ) - The Go Programming Language

Suponha que você tenha a seguinte expressão ternária (em C):

int a = test ? 1 : 2;

A abordagem idiomática no Go seria simplesmente usar um ifbloco:

var a int

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

No entanto, isso pode não atender aos seus requisitos. No meu caso, eu precisava de uma expressão embutida para um modelo de geração de código.

Eu usei uma função anônima imediatamente avaliada:

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

Isso garante que as duas ramificações também não sejam avaliadas.

O ternário do mapa é fácil de ler sem parênteses:

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

Isso não terá um desempenho superior a if / else e requer conversão, mas funciona. PARA SUA INFORMAÇÃO:

BenchmarkAbsTernary-8 100000000 18,8 ns / op

BenchmarkAbsIfElse-8 2000000000 0,27 ns / op

Se todas as suas ramificações produzem efeitos colaterais ou são computacionalmente caras, o seguinte seria uma refatoração que preserva semanticamente :

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

normalmente sem sobrecarga (embutida) e, o mais importante, sem sobrecarregar seu espaço de nome com funções auxiliares que são usadas apenas uma vez (o que dificulta a legibilidade e a manutenção). Exemplo ao vivo

Observe se você deveria aplicar ingenuamente a abordagem de Gustavo :

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

você obteria um programa com um comportamento diferente ; caso o val <= 0programa imprima um valor não positivo enquanto não deveria! (Analogamente, se você revertesse as ramificações, introduziria sobrecarga chamando uma função lenta desnecessariamente.)

Prefácio: Sem argumentando queif else é o caminho a seguir, ainda podemos brincar e encontrar prazer em construções habilitadas para idiomas.

A Ifconstrução a seguir está disponível na minha github.com/icza/goxbiblioteca com muitos outros métodos, sendo o builtinx.Iftipo

Go permite anexar métodos a qualquer tipo definido pelo usuário , incluindo tipos primitivos como bool. Podemos criar um tipo personalizado tendo boolcomo tipo subjacente e, em seguida, com uma simples conversão de tipo na condição, teremos acesso a seus métodos. Métodos que recebem e selecionam dos operandos.

Algo assim:

type If bool

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

Como podemos usá-lo?

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

Por exemplo, um ato ternário max():

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

Um ato ternário abs():

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

Parece legal, é simples, elegante e eficiente (também é elegível para inlining ).

Uma desvantagem em comparação com um operador ternário "real": ele sempre avalia todos os operandos.

Para obter uma avaliação adiada e apenas se necessário, a única opção é usar funções ( funções ou métodos declarados ou literais de função ), que são chamados apenas quando / se necessário:

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

Usando-o: Vamos assumir que temos essas funções para calcular ae b:

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

Então:

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

Por exemplo, a condição sendo o ano atual> 2020:

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

Se queremos usar literais de função:

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

Nota final: se você tiver funções com diferentes assinaturas, não poderá usá-las aqui. Nesse caso, você pode usar uma função literal com assinatura correspondente para torná-las ainda aplicáveis.

Por exemplo, se calca()e calcb()também teria parâmetros (além do valor de retorno):

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

É assim que você pode usá-los:

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

Experimente estes exemplos no Go Playground .

A resposta de Eold é interessante e criativa, talvez até inteligente.

No entanto, seria recomendável fazer:

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

Sim, ambos são compilados essencialmente no mesmo assembly, no entanto, esse código é muito mais legível do que chamar uma função anônima apenas para retornar um valor que poderia ter sido gravado na variável em primeiro lugar.

Basicamente, código simples e claro é melhor que código criativo.

Além disso, qualquer código que use um literal de mapa não é uma boa ideia, porque os mapas não são leves no Go. Desde o Go 1.3, a ordem de iteração aleatória para mapas pequenos é garantida e, para impor isso, é um pouco menos eficiente em termos de memória para mapas pequenos.

Como resultado, fazer e remover vários pequenos mapas consome espaço e consome tempo. Eu tinha um pedaço de código que usava um mapa pequeno (provavelmente duas ou três chaves, mas o caso de uso comum era apenas uma entrada). Mas o código era lento. Estamos falando de pelo menos três ordens de magnitude mais lentas que o mesmo código reescrito para usar um mapa de chaves de índice duplo [index] => data [index]. E provavelmente era mais. Como algumas operações que estavam demorando alguns minutos para serem executadas, começaram a ser concluídas em milissegundos. \

As frases de linha, embora evitadas pelos criadores, têm seu lugar.

Este resolve o problema de avaliação lenta, permitindo que você, opcionalmente, passe as funções a serem avaliadas, se necessário:

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

Resultado

hello
hello world
hello world
hello
bye

• As funções transmitidas devem retornar um interface{}para satisfazer a operação de conversão interna.
• Dependendo do contexto, você pode optar por converter a saída para um tipo específico.
• Se você quisesse retornar uma função disso, seria necessário agrupá-la como mostrado em c.

A solução independente aqui também é boa, mas pode ser menos clara para alguns usos.