Como fazer uma declaração if else de uma linha?

Posso escrever uma instrução if-else simples com atribuição de variável em go (golang) como faria em php? Por exemplo:

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

Atualmente tenho que usar o seguinte:

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

Desculpe, não consigo lembrar o nome desta instrução de controle e não consegui encontrar a informação no site ou através de pesquisa do google. : /

Como os comentários mencionados, Go não oferece suporte a um liners ternário. A forma mais curta que consigo pensar é esta:

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

Mas, por favor, não faça isso, não vale a pena e só vai confundir as pessoas que leem seu código.

Costumo usar o seguinte:

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

basicamente o mesmo que @Not_a_Golfer, mas usando inferência de tipo .

Como os outros mencionados, Gonão oferece suporte a one-liners ternários. No entanto, escrevi uma função de utilidade que pode ajudá-lo a conseguir o que deseja.

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

Aqui estão alguns casos de teste para mostrar como você pode usá-lo

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

Para me divertir, escrevi funções utilitárias mais úteis, como:

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

Se quiser usar algum deles, você pode encontrá-los aqui https://github.com/shomali11/util

Obrigado por apontar para a resposta correta.

Acabei de verificar o FAQ Golang (duh) e afirma claramente, isso não está disponível no idioma:

O Go tem a operadora?:?

Não existe forma ternária em Go. Você pode usar o seguinte para obter o mesmo resultado:

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

informações adicionais encontradas que podem ser de interesse sobre o assunto:

• Código Rosetta para estruturas condicionais em Go
• Operador ternário em experimento Go deste cara

Uma forma possível de fazer isso em apenas uma linha, usando um mapa, simples Estou verificando se a > bse é trueque eu estou atribuindo cao acontráriob

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

No entanto, isso parece incrível, mas em alguns casos pode NÃO ser a solução perfeita por causa da ordem de avaliação. Por exemplo, se estou verificando se um objeto não nilobteve alguma propriedade dele, observe o seguinte trecho de código que, panicno caso 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}

Porque o mapa será criado e construído primeiro, antes de avaliar a condição, então, nesse caso myObj = nil, simplesmente entrarei em pânico.

Sem esquecer de mencionar que você ainda pode fazer as condições em apenas uma linha simples, verifique o seguinte:

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

Use a função lambda em vez do operador ternário

Exemplo 1

para dar o máximo int

package main

func main() {

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

Exemplo 2

Suponha que você tenha essa must(err error)função para tratar erros e queira usá-la quando uma condição não for atendida. (desfrute em 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)
}

Às vezes, tento usar a função anônima para conseguir definir e atribuir acontecem na mesma linha. como abaixo:

a, b = 4, 8

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

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

Uma construção muito semelhante está disponível no idioma

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

*

ie

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

Você pode usar um fecho para isso:

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

A única queixa que tenho com a sintaxe de fechamento em Go é que não há alias para a função de retorno zero do parâmetro zero padrão, então seria muito mais agradável (pense em como você declara literais de mapa, matriz e fatia com apenas um nome de tipo).

Ou mesmo a versão mais curta, como um comentador acabou de sugerir:

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

Você ainda precisaria usar um encerramento se precisasse fornecer parâmetros para as funções. Isso poderia ser evitado no caso de passar métodos em vez de apenas funções, eu acho, onde os parâmetros são a estrutura associada aos métodos.