Operator Ternary di Golang: Kenapa Go Tidak Punya dan Penggantinya

Go tidak punya operator ternary. Tidak ada cond ? a : b. Pengganti yang idiomatis adalah pernyataan if:

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

Deklarasikan variabel dengan nilai default, lalu ubah nilainya di dalam if. Kalau kedua cabang sama-sama butuh perhitungan, pakai if/else:

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

Kenapa Go tidak memasukkannya

FAQ Go menjawab ini secara langsung: para perancangnya terlalu sering melihat operator ?: dipakai untuk membuat ekspresi yang rumit dan sulit dipahami, lalu memutuskan bahwa if/else, walaupun lebih panjang, jelas lebih mudah dibaca. Sebuah bahasa cukup punya satu konstruksi alur kontrol bersyarat.

Dalam praktiknya, ketiadaan operator ini hanya menambah dua atau tiga baris setiap kali dipakai, dan menghilangkan seluruh jenis ekspresi bersarang seperti a ? b ? c : d : e.

Return lebih awal sebagai gantinya

Di dalam fungsi, bentuk yang paling rapi sering kali tidak butuh variabel sama sekali:

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

Memindahkan kondisi ke dalam fungsi kecil yang punya nama sering menjadi jawaban terbaik: tempat pemanggilannya terbaca seperti ternary yang kamu inginkan, dan nama fungsinya menjelaskan arti kondisi itu.

Nilai default dengan cmp.Or (Go 1.22)

Ternary yang paling umum di bahasa lain adalah "pakai nilai ini, atau nilai cadangan kalau kosong": name ? name : "anonymous", atau name || "anonymous" di JavaScript. Go 1.22 menambahkan cmp.Or tepat untuk ini. Fungsi ini mengembalikan argumen pertama yang bukan zero value dari tipenya:

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

Fungsi ini menganggap zero value sebagai "tidak ada", jadi ia tidak bisa membedakan "port sengaja bernilai 0" dari "port belum diisi". Kalau nol adalah nilai yang sah, pakai pointer, bool terpisah, atau if yang eksplisit.

Helper If yang generic, dan jebakannya

Dengan generic (Go 1.18), kamu bisa menulis fungsi yang terlihat seperti ternary:

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

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

Fungsi ini bekerja untuk nilai sederhana, dan sebagian codebase memakainya. Tetapi ini bukan operator ternary, dan perbedaannya penting. Go mengevaluasi semua argumen sebelum memanggil fungsi, jadi a dan b selalu dihitung:

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

Panggilan pertama menghitung "a" sekaligus "b", dan panggilan kedua panic dengan nil pointer dereference, walaupun kondisinya false. Ternary sungguhan hanya mengevaluasi sisi yang dipilih. Jadi:

• Jangan pernah memakai helper seperti ini kalau salah satu sisinya melakukan dereference pada pointer, mengakses indeks slice, atau membaca entri map yang mungkin tidak ada.
• Jangan pernah memakainya kalau salah satu sisinya mahal atau punya efek samping.
• Untuk nilai yang murah dan aman, helper ini bisa dipakai, tetapi banyak reviewer Go tetap akan meminta if biasa.

Kamu bisa membuat cabangnya dievaluasi belakangan dengan mengirim fungsi, If(ok, func() string { return a }, func() string { return b }), tetapi pada titik itu pernyataan if justru lebih pendek.

Trik lain, dan kenapa sebaiknya dihindari

Lookup map. map[bool]string{true: "yes", false: "no"}[ok] memang bisa, tetapi membangun map dan menghitung hash setiap kali dievaluasi, serta mengevaluasi kedua nilainya. Ini sekadar keanehan, bukan idiom.

Fungsi yang langsung dipanggil. Fungsi anonim yang dipanggil di tempat memberimu sebuah ekspresi:

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

Cara ini memang mengevaluasi secara belakangan, dan sesekali membantu di dalam composite literal yang tidak bisa diisi pernyataan. Hampir setiap saat, menghitung nilainya ke dalam variabel tepat sebelum literal itu lebih jelas.

Memilih pengganti

Usulan untuk menambahkan ekspresi bersyarat rutin muncul di issue tracker Go dan sejauh ini selalu ditolak. Tulis saja if-nya.

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