Golang Ternary Operator: Why Go Has None and What to Use

Go has no ternary operator. There is no cond ? a : b. The idiomatic replacement is an if statement:

package main

import "fmt"

func main() {
	for _, n := range []int{3, 8} {
		// In C or JavaScript: parity = n % 2 == 0 ? "even" : "odd";
		parity := "odd"
		if n%2 == 0 {
			parity = "even"
		}
		fmt.Println(n, parity)
	}
}

Declare the variable with the default value, then change it in the if. When both branches need work, use if/else:

var fee int
if member {
	fee = 0
} else {
	fee = computeFee(order)
}

Why Go Left It Out

The Go FAQ answers this directly: the designers had seen the ?: operator used too often to create impenetrably complex expressions, and decided that if/else, while longer, is unquestionably clearer. A language needs only one conditional control flow construct.

In practice the missing operator costs two or three lines per use and removes a whole category of nested expressions like a ? b ? c : d : e.

Returning Early Instead

Inside a function, the cleanest form often skips the variable entirely:

package main

import "fmt"

func plural(n int, word string) string {
	if n == 1 {
		return word
	}
	return word + "s"
}

func main() {
	fmt.Println(1, plural(1, "file"))
	fmt.Println(3, plural(3, "file"))
}

Pulling the condition into a small named function is often the best answer: the call site reads like the ternary you wanted, and the function name documents what the condition means.

Default Values with cmp.Or (Go 1.22)

The most common ternary in other languages is "use this value, or a fallback if it is empty": name ? name : "anonymous", or name || "anonymous" in JavaScript. Go 1.22 added cmp.Or for exactly this. It returns the first argument that is not the zero value of its type:

package main

import (
	"cmp"
	"fmt"
)

func main() {
	name := ""
	fmt.Println(cmp.Or(name, "anonymous"))

	name = "Ana"
	fmt.Println(cmp.Or(name, "anonymous"))

	port := 0
	fmt.Println(cmp.Or(port, 8080))

	// several fallbacks, first non-zero wins
	envValue, configValue := "", "eu-west-1"
	fmt.Println(cmp.Or(envValue, configValue, "us-east-1"))
}

It treats the zero value as "missing", so it cannot tell "port is 0 on purpose" from "port was not set". When zero is a valid value, use a pointer, a separate bool, or an explicit if.

A Generic If Helper, and Its Trap

With generics (Go 1.18) you can write a function that looks like a ternary:

func If[T any](cond bool, a, b T) T {
	if cond {
		return a
	}
	return b
}

status := If(ok, "pass", "fail")

It works for simple values, and some codebases use it. But it is not a ternary operator, and the difference matters. Go evaluates all arguments before calling a function, so both a and b are always computed:

package main

import "fmt"

func If[T any](cond bool, a, b T) T {
	if cond {
		return a
	}
	return b
}

func expensive(label string) string {
	fmt.Println("  computing", label)
	return label
}

type User struct{ Name string }

func main() {
	fmt.Println("If(true, ...):")
	v := If(true, expensive("a"), expensive("b"))
	fmt.Println("  result:", v)

	var u *User // nil
	defer func() {
		if r := recover(); r != nil {
			fmt.Println("panic:", r)
		}
	}()
	name := If(u != nil, u.Name, "guest") // u.Name is evaluated even though u is nil
	fmt.Println(name)
}

The first call computes both "a" and "b", and the second panics with a nil pointer dereference, even though the condition is false. A real ternary would evaluate only the chosen side. So:

• Never use such a helper when one side dereferences a pointer, indexes a slice, or reads a map entry that may not exist.
• Never use it when one side is expensive or has side effects.
• For cheap, safe values it works, but many Go reviewers will still ask for the plain if.

You can make the branches lazy by passing functions, If(ok, func() string { return a }, func() string { return b }), but at that point the if statement is shorter.

Other Tricks, and Why to Avoid Them

Map lookup. map[bool]string{true: "yes", false: "no"}[ok] works, builds and hashes into a map on every evaluation, and evaluates both values. It is a curiosity, not an idiom.

Immediately invoked function. An anonymous function called in place gives you an expression:

label := func() string {
	if n > 0 {
		return "positive"
	}
	return "non-positive"
}()

This does evaluate lazily, and it occasionally helps inside a composite literal where a statement cannot go. Most of the time, computing the value in a variable just before the literal is clearer.

Choosing a Replacement

Proposals to add a conditional expression come up regularly on Go's issue tracker and have been declined so far. Write the if.

label := "odd"
if n%2 == 0 {
	label = "even"
}