Qual è l'equivalente Go idiomatico dell'operatore ternario di C?

In C / C ++ (e molte lingue di quella famiglia), un linguaggio comune per dichiarare e inizializzare una variabile a seconda di una condizione usa l'operatore condizionale ternario:

int index = val > 0 ? val : -val

Go non ha l'operatore condizionale. Qual è il modo più idiomatico per implementare lo stesso codice di cui sopra? Sono arrivato alla seguente soluzione, ma sembra abbastanza prolisso

var index int

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

C'è qualcosa di meglio?

Come sottolineato (e speriamo non sorprende), l'uso if+elseè davvero il modo idiomatico di fare condizionali in Go.

Oltre al var+if+elseblocco completo del codice, tuttavia, questa ortografia viene spesso utilizzata anche:

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

e se hai un blocco di codice abbastanza ripetitivo, come l'equivalente di int value = a <= b ? a : b, puoi creare una funzione per tenerlo:

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

...

value := min(a, b)

Il compilatore incorporerà funzioni così semplici, quindi è veloce, più chiaro e più breve.

No Go non ha un operatore ternario, usando la sintassi if / else è il modo idiomatico.

Perché Go non ha l'operatore?:?

Non ci sono operazioni di test ternari in Go. È possibile utilizzare quanto segue per ottenere lo stesso risultato:

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

Il motivo ?:è assente da Go è che i progettisti del linguaggio avevano visto l'operazione usata troppo spesso per creare espressioni impenetrabili complesse. La if-elseforma, sebbene più lunga, è senza dubbio più chiara. Una lingua richiede solo un costrutto del flusso di controllo condizionale.

- Domande frequenti (FAQ) - Il linguaggio di programmazione Go

Supponiamo di avere la seguente espressione ternaria (in C):

int a = test ? 1 : 2;

L'approccio idiomatico in Go sarebbe semplicemente usare un ifblocco:

var a int

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

Tuttavia, potrebbe non essere adatto alle tue esigenze. Nel mio caso, avevo bisogno di un'espressione incorporata per un modello di generazione del codice.

Ho usato una funzione anonima immediatamente valutata:

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

Ciò garantisce che anche i due rami non vengano valutati.

La mappa ternaria è di facile lettura senza parentesi:

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

Questo non supererà se / else e richiede cast ma funziona. FYI:

BenchmarkAbsTernary-8 100000000 18,8 ns / op

BenchmarkAbsIfElse-8 2000000000 0,27 ns / op

Se tutti i tuoi rami producono effetti collaterali o sono computazionalmente costosi , un refactoring semanticamente conservante sarebbe il seguente :

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

normalmente senza sovraccarico (inline) e, soprattutto, senza ingombrare il tuo spazio dei nomi con funzioni di supporto che vengono utilizzate una sola volta (che ostacola la leggibilità e la manutenzione). Esempio live

Nota se dovessi applicare ingenuamente l'approccio di Gustavo :

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

otterresti un programma con un comportamento diverso ; nel caso in cui il val <= 0programma stampasse un valore non positivo mentre non dovrebbe! (Analogamente, se invertissi i rami, avresti introdotto il sovraccarico chiamando inutilmente una funzione lenta.)

Premessa: Senza discutere che if elsesia la strada da percorrere, possiamo ancora giocare e trovare piacere nei costrutti abilitati al linguaggio.

Il seguente Ifcostrutto è disponibile nella mia github.com/icza/goxlibreria con molti altri metodi, essendo il builtinx.Iftipo.

Go consente di associare metodi a qualsiasi tipo definito dall'utente , inclusi tipi primitivi come bool. Possiamo creare un tipo personalizzato avente boolcome tipo sottostante , e quindi con una semplice conversione del tipo a condizione, abbiamo accesso ai suoi metodi. Metodi che ricevono e selezionano dagli operandi.

Qualcosa come questo:

type If bool

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

Come possiamo usarlo?

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

Ad esempio un ternario che fa max():

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

Un ternario che fa abs():

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

Sembra bello, semplice, elegante ed efficiente (è idoneo anche per l'allineamento ).

Un aspetto negativo rispetto a un "vero" operatore ternario: valuta sempre tutti gli operandi.

Per ottenere una valutazione differita e solo se necessaria, l'unica opzione è utilizzare le funzioni ( funzioni o metodi dichiarati o valori letterali delle funzioni ), che vengono chiamate solo quando / se necessario:

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

Usandolo: supponiamo di avere queste funzioni per calcolare ae b:

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

Poi:

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

Ad esempio, la condizione è l'anno corrente> 2020:

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

Se vogliamo usare i letterali delle funzioni:

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

Nota finale: se avessi funzioni con firme diverse, non potresti usarle qui. In tal caso è possibile utilizzare una funzione letterale con firma corrispondente per renderli ancora applicabili.

Ad esempio se calca()e calcb()avrebbe anche dei parametri (oltre al valore restituito):

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

Ecco come potresti usarli:

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

Prova questi esempi sul Go Playground .

la risposta di eold è interessante e creativa, forse persino intelligente.

Tuttavia, si consiglia invece di fare:

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

Sì, entrambi si compilano essenzialmente nello stesso assembly, tuttavia questo codice è molto più leggibile che chiamare una funzione anonima solo per restituire un valore che avrebbe potuto essere scritto nella variabile in primo luogo.

Fondamentalmente, il codice semplice e chiaro è meglio del codice creativo.

Inoltre, qualsiasi codice che utilizza una mappa letterale non è una buona idea, poiché le mappe non sono affatto leggere in Go. Da Go 1.3, l'ordine di iterazione casuale per le mappe di piccole dimensioni è garantito e, per far ciò, è diventato un po 'meno efficiente dal punto di vista della memoria per le mappe di piccole dimensioni.

Di conseguenza, la creazione e la rimozione di numerose piccole mappe richiede tempo e spazio. Avevo un pezzo di codice che utilizzava una piccola mappa (probabilmente due o tre chiavi, ma il caso d'uso comune era solo una voce) Ma il codice era lento. Stiamo parlando di almeno 3 ordini di grandezza più lenti rispetto allo stesso codice riscritto per utilizzare una chiave dual slice [index] => data [index] map. E probabilmente era di più. Poiché alcune operazioni che in precedenza richiedevano un paio di minuti per l'esecuzione, iniziarono a completarsi in millisecondi. \

I one-liner, sebbene evitati dai creatori, hanno il loro posto.

Questo risolve il problema della valutazione lenta consentendo, facoltativamente, di passare funzioni da valutare se necessario:

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

Produzione

hello
hello world
hello world
hello
bye

• Le funzioni passate devono restituire an interface{}per soddisfare l'operazione di cast interna.
• A seconda del contesto, è possibile scegliere di trasmettere l'output a un tipo specifico.
• Se si desidera restituire una funzione da questa, è necessario avvolgerla come mostrato c.

Anche la soluzione standalone qui è bella, ma potrebbe essere meno chiara per alcuni usi.