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

这不会比if/else更好，需要施放但有效。仅供参考:

基准基准三元-8 100000000 18.8 ns/op

BenchmarkAbsIfElse-8 2000000000 0.27 ns/op

如果你所有的分支都产生了副作用，或者计算成本很高，下面是一个语义保留的重构:

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

通常没有开销(内联)，最重要的是，不会因为只使用一次的辅助函数而使名称空间混乱(这会影响可读性和维护)。生活的例子

注意，如果你天真地应用Gustavo的方法:

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

你会得到一个有着不同行为的程序;在val <= 0的情况下，程序将输出一个非正值，而它不应该!(类似地，如果反转分支，就会不必要地调用缓慢的函数，从而引入开销。)

没有括号，map三元很容易读:

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

正如其他人所注意到的，golang没有三元运算符或任何等价的运算符。这是一个经过深思熟虑的决定，旨在提高可读性。

这最近让我遇到了一个场景，以一种非常有效的方式构建位掩码，在习惯地编写时变得很难阅读，或者在封装为函数时非常低效，或者两者兼有，因为代码产生分支:

package lib

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

生产:

        text    "".maskIfTrue(SB), NOSPLIT|ABIInternal, $0-24
        funcdata        $0, gclocals·33cdeccccebe80329f1fdbee7f5874cb(SB)
        funcdata        $1, 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    $0, "".~r2+24(SP)
        ret

我从中学到的是多利用一点围棋;在函数中使用一个命名的结果(result int)为我节省了在函数中声明它的一行(你可以用capture做同样的事情)，但是编译器也识别这个习惯用法(只分配一个值IF)，并在可能的情况下将其替换为条件指令。

func zeroOrOne(predicate bool) (result int) {
  if predicate {
    result = 1
  }
  return
}

产生无分支的结果:

    movblzx "".predicate+8(SP), AX
    movq    AX, "".result+16(SP)
    ret

然后自由内联。

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
}

生产https://go.godbolt.org/z/eKbK17

    movq    "".v1+8(SP), AX
    cmpq    AX, $1
    seteq   AL
    xorps   X0, X0
    movss   "".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 "".v1+20(SP), CX
    shlq    $5, CX
    orq     AX, CX
    movq    CX, "".result+24(SP)
    ret

正如所指出的(希望这并不令人意外)，使用if+else确实是在Go中执行条件语句的惯用方式。

除了完整的var+if+else代码块之外，这种拼写也经常被使用:

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

如果你有一段重复的代码，比如int value = a <= b ?A: b，你可以创建一个函数来保存它:

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

...

value := min(a, b)

编译器将内联这些简单的函数，所以它更快，更清楚，更简短。

假设你有以下三元表达式(C语言):

int a = test ? 1 : 2;

在Go中惯用的方法是简单地使用if块:

var a int

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

但是，这可能不符合您的要求。在我的例子中，我需要一个代码生成模板的内联表达式。

我使用了一个立即求值的匿名函数:

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

这确保了两个分支都不会被计算。