C的三元运算符的惯用Go等效项是什么？

#1 楼

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

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

...

value := min(a, b)

#2 楼

#3 楼

int a = test ? 1 : 2;

var a int

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

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

#4 楼

c := map[bool]int{true: 1, false: 0} [5 > 4]

#5 楼

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

#6 楼

type If bool

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

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

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

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

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

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

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

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

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

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

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

#7 楼

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

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

#8 楼

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

#9 楼

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

hello
hello world
hello world
hello
bye

#10 楼

package lib

func maskIfTrue(mask uint64, predicate bool) uint64 {
  if predicate {
    return mask
  }
  return 0
}

        text    "".maskIfTrue(SB), NOSPLIT|ABIInternal, 
func zeroOrOne(predicate bool) (result int) {
  if predicate {
    result = 1
  }
  return
}
-24
        funcdata        
    movblzx "".predicate+8(SP), AX
    movq    AX, "".result+16(SP)
    ret
, gclocals·33cdeccccebe80329f1fdbee7f5874cb(SB)
        funcdata        , gclocals·33cdeccccebe80329f1fdbee7f5874cb(SB)
        movblzx "".predicate+16(SP), AX
        testb   AL, AL
        jeq     maskIfTrue_pc20
        movq    "".mask+8(SP), AX
        movq    AX, "".~r2+24(SP)
        ret
maskIfTrue_pc20:
        movq    
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) << Property1Bit
    result |= zeroOrOne(v1.Property2 < 0.0) << Property2Bit
    result |= zeroOrOne(v1.Property3) << Property3Bit
    return
}
, "".~r2+24(SP)
        ret

    movq    "".v1+8(SP), AX
    cmpq    AX, 
    seteq   AL
    xorps   X0, X0
    movss   "".v1+16(SP), X1
    ucomiss X1, X0
    sethi   CL
    movblzx AL, AX
    shlq    , AX
    movblzx CL, CX
    shlq    , CX
    orq     CX, AX
    movblzx "".v1+20(SP), CX
    shlq    , CX
    orq     AX, CX
    movq    CX, "".result+24(SP)
    ret