What is the idiomatic Go equivalent of C s ternary operator

Question

In C C    and many languages of that family   a common idiom to declare and initialize a variable depending on a condition uses the ternary conditional operator    int index   val  gt  0   val   -val   Go doesn t have the conditional operator  What is the most idiomatic way to implement the same piece of code as above   I came to the following solution  but it seems quite verbose  var index int  if val  gt  0       index   val   else       index   -val     Is there something better

User · Answer

Foreword  Without arguing that if else is the way to go  we can still play with and find pleasure in language-enabled constructs  The following If construct is available in my github com icza gox library with lots of other methods  being the gox If type   Go allows to attach methods to any user-defined types  including primitive types such as bool  We can create a custom type having bool as its underlying type  and then with a simple type conversion on the condition  we have access to its methods  Methods that receive and select from the operands  Something like this  type If bool  func  c If  Int a  b int  int       if c           return a           return b    How can we use it  i    If condition  Int val1  val2      Short variable declaration  i is of type int       -----------        type conversion    ---method call  For example a ternary doing max    i    If a  gt  b  Int a  b   A ternary doing abs    i    If a  gt   0  Int a  -a   This looks cool  it s simple  elegant  and efficient  it s also eligible for inlining   One downside compared to a  quot real quot  ternary operator  it always evaluates all operands  To achieve deferred and only-if-needed evaluation  the only option is to use functions  either declared functions or methods  or function literals   which are only called when   if needed  func  c If  Fint fa  fb func   int  int       if c           return fa             return fb      Using it  Let s assume we have these functions to calculate a and b  func calca   int   return 3   func calcb   int   return 4    Then  i    If someCondition  Fint calca  calcb   For example  the condition being current year  gt  2020  i    If time Now   Year    gt  2020  Fint calca  calcb   If we want to use function literals  i    If time Now   Year    gt  2020  Fint      func   int   return 3        func   int   return 4       Final note  if you would have functions with different signatures  you could not use them here  In that case you may use a function literal with matching signature to make them still applicable  For example if calca   and calcb   would have parameters too  besides the return value   func calca2 x int  int   return 3   func calcb2 x int  int   return 4    This is how you could use them  i    If time Now   Year    gt  2020  Fint      func   int   return calca2 0         func   int   return calcb2 0        Try these examples on the Go Playground

User · Answer

As pointed out  and hopefully unsurprisingly   using if else is indeed the idiomatic way to do conditionals in Go   In addition to the full blown var if else block of code  though  this spelling is also used often   index    val if val  lt   0       index   -val     and if you have a block of code that is repetitive enough  such as the equivalent of int value   a  lt   b   a   b  you can create a function to hold it   func min a  b int  int       if a  lt   b           return a           return b         value    min a  b    The compiler will inline such simple functions  so it s fast  more clear  and shorter

User · Answer

No Go doesn t have a ternary operator  using if else syntax is the idiomatic way   Why does Go not have the    operator  There is no ternary testing operation in Go  You may use the following to achieve the same result  if expr       n   trueVal   else       n   falseVal    The reason    is absent from Go is that the language s designers had seen the operation used too often to create impenetrably complex expressions  The if-else form  although longer  is unquestionably clearer  A language needs only one conditional control flow construct      Frequently Asked Questions  FAQ  - The Go Programming Language

User · Answer

The map ternary is easy to read without parentheses   c    map bool int true  1  false  0   5  gt  4

User · Answer

func Ternary statement bool  a  b interface    interface         if statement           return a           return b    func Abs n int  int       return Ternary n  gt   0  n  -n   int      This will not outperform if else and requires cast but works   FYI   BenchmarkAbsTernary-8 100000000 18 8 ns op  BenchmarkAbsIfElse-8 2000000000 0 27 ns op

User · Answer

As others have noted  golang does not have a ternary operator or any equivalent  This is a deliberate decision thought to intend readability  This recently lead me to a scenario constructing a bit-mask in a very efficient manner became hard to read when written idiomatically because it took up a lot of lines of screen  very inefficient when encapsulated as a function  or both  as the code produces branches  package lib  func maskIfTrue mask uint64  predicate bool  uint64     if predicate       return mask       return 0    producing          text     quot  quot  maskIfTrue SB   NOSPLIT ABIInternal   0-24         funcdata         0  gclocals  33cdeccccebe80329f1fdbee7f5874cb SB          funcdata         1  gclocals  33cdeccccebe80329f1fdbee7f5874cb SB          movblzx  quot  quot  predicate 16 SP   AX         testb   AL  AL         jeq     maskIfTrue pc20         movq     quot  quot  mask 8 SP   AX         movq    AX   quot  quot   r2 24 SP          ret maskIfTrue pc20          movq     0   quot  quot   r2 24 SP          ret  What I learned from this was to leverage a little more Go  using a named result in the function  result int  saves me a line declaring it in the function  and you can do the same with captures   but the compiler also recognizes this idiom  only assign a value IF  and replaces it - if possible - with a conditional instruction  func zeroOrOne predicate bool   result int      if predicate       result   1       return    producing a branch-free result      movblzx  quot  quot  predicate 8 SP   AX     movq    AX   quot  quot  result 16 SP      ret  which go then freely inlines  package lib  func zeroOrOne predicate bool   result int      if predicate       result   1       return    type Vendor1 struct       Property1 int     Property2 float32     Property3 bool       Vendor2 bit positions  const       Property1Bit   2     Property2Bit   3     Property3Bit   5    func Convert1To2 v1 Vendor1   result int        result    zeroOrOne v1 Property1    1   lt  lt  Property1Bit     result    zeroOrOne v1 Property2  lt  0 0   lt  lt  Property2Bit     result    zeroOrOne v1 Property3   lt  lt  Property3Bit     return    produces https   go godbolt org z eKbK17     movq     quot  quot  v1 8 SP   AX     cmpq    AX   1     seteq   AL     xorps   X0  X0     movss    quot  quot  v1 16 SP   X1     ucomiss X1  X0     sethi   CL     movblzx AL  AX     shlq     2  AX     movblzx CL  CX     shlq     3  CX     orq     CX  AX     movblzx  quot  quot  v1 20 SP   CX     shlq     5  CX     orq     AX  CX     movq    CX   quot  quot  result 24 SP      ret

User · Answer

If all your branches make side-effects or are computationally expensive the following would a semantically-preserving refactoring   index    func   int       if val  gt  0           return printPositiveAndReturn val        else           return slowlyReturn -val      or slowlyNegate val                exactly one branch will be evaluated   with normally no overhead  inlined  and  most importantly  without cluttering your namespace with a helper functions that are only used once  which hampers readability and maintenance   Live Example  Note if you were to naively apply Gustavo s approach       index    printPositiveAndReturn val       if val  lt   0           index   slowlyReturn -val       or slowlyNegate val          you d get a program with a different behavior  in case val  lt   0 program would print a non-positive value while it should not   Analogously  if you reversed the branches  you would introduce overhead by calling a slow function unnecessarily

User · Answer

Suppose you have the following ternary expression  in C    int a   test   1   2    The idiomatic approach in Go would be to simply use an if block   var a int  if test     a   1   else     a   2     However  that might not fit your requirements  In my case  I needed an inline expression for a code generation template    I used an immediately evaluated anonymous function   a    func   int   if test   return 1   else   return 2         This ensures that both branches are not evaluated as well

User · Answer

eold s answer is interesting and creative  perhaps even clever   However  it would be recommended to instead do   var index int if val  gt  0       index   printPositiveAndReturn val    else       index   slowlyReturn -val      or slowlyNegate val      Yes  they both compile down to essentially the same assembly  however this code is much more legible than calling an anonymous function just to return a value that could have been written to the variable in the first place   Basically  simple and clear code is better than creative code   Additionally  any code using a map literal is not a good idea  because maps are not lightweight at all in Go  Since Go 1 3  random iteration order for small maps is guaranteed  and to enforce this  it s gotten quite a bit less efficient memory-wise for small maps   As a result  making and removing numerous small maps is both space-consuming and time-consuming  I had a piece of code that used a small map  two or three keys  are likely  but common use case was only one entry  But the code was dog slow  We re talking at least 3 orders of magnitude slower than the same code rewritten to use a dual slice key index   data index  map  And likely was more  As some operations that were previously taking a couple of minutes to run  started completing in milliseconds

User · Answer

One-liners  though shunned by the creators  have their place   This one solves the lazy evaluation problem by letting you  optionally  pass functions to be evaluated if necessary   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         Output  hello hello world hello world hello bye    Functions passed in must return an interface   to satisfy the internal cast operation  Depending on the context  you might choose to cast the output to a specific type  If you wanted to return a function from this  you would need to wrap it as shown with c      The standalone solution here is also nice  but could be less clear for some uses

[go] What is the idiomatic Go equivalent of C's ternary operator?

Examples related to go

Examples related to ternary-operator

Examples related to conditional-operator