if else di Golang: Sintaks, Init Statement, dan if err != nil

if di Go tidak memakai tanda kurung di sekitar kondisi, selalu butuh kurung kurawal, dan bisa diawali pernyataan pendek yang mendeklarasikan variabel dengan scope khusus untuk if tersebut.

package main

import "fmt"

func grade(score int) string {
	var g string
	if score >= 90 {
		g = "A"
	} else if score >= 80 {
		g = "B"
	} else if score >= 70 {
		g = "C"
	} else {
		g = "F"
	}
	return g
}

func main() {
	for _, s := range []int{95, 83, 70, 42} {
		fmt.Println(s, grade(s))
	}
}

Kondisi diperiksa dari atas, dan cabang pertama yang bernilai true yang dijalankan. else if dan else bersifat opsional.

Aturan sintaks

Tiga aturan berbeda dari C, Java, dan JavaScript:

1. Tanpa tanda kurung di sekitar kondisi. if (x > 5) tetap bisa dikompilasi, tapi gofmt akan menghapus tanda kurungnya.
2. Kurung kurawal wajib, bahkan untuk satu pernyataan. Tidak ada bentuk tanpa kurawal seperti if x > 5 return.
3. else ditulis di baris yang sama dengan kurung kurawal penutup. Go menyisipkan titik koma setelah } di akhir baris, jadi kode ini gagal:

if x > 5 {
	fmt.Println("big")
}
else {
	fmt.Println("small")
}

syntax error: unexpected keyword else, expected }

Tulis } else { dalam satu baris.

Kondisinya harus bertipe bool. Go tidak menganggap 0, "", atau nil sebagai false, jadi if count {} dan if name {} tidak bisa dikompilasi. Bandingkan secara eksplisit: if count > 0, if name != "", if user != nil.

Gabungkan kondisi dengan && (dan), || (atau), dan ! (bukan). && dan || sama-sama melakukan short-circuit, sehingga pemeriksaan nil menjadi aman:

if user != nil && user.IsAdmin() {
	// user.IsAdmin() is only called when user is not nil
}

if dengan init statement

if bisa menjalankan satu pernyataan pendek sebelum kondisi, dipisahkan dengan titik koma. Variabel yang dideklarasikan di situ terlihat di setiap cabang if tersebut, dan tidak di mana pun setelahnya:

package main

import (
	"fmt"
	"strconv"
)

func main() {
	inputs := []string{"42", "-7", "abc"}

	for _, in := range inputs {
		if n, err := strconv.Atoi(in); err != nil {
			fmt.Printf("%q is not a number\n", in)
		} else if n < 0 {
			fmt.Printf("%d is negative\n", n)
		} else {
			fmt.Printf("%d doubled is %d\n", n, n*2)
		}
		// n and err do not exist here
	}

	stock := map[string]int{"apples": 3}
	if qty, ok := stock["apples"]; ok {
		fmt.Println("apples in stock:", qty)
	}
	if _, ok := stock["pears"]; !ok {
		fmt.Println("no pears")
	}
}

Pola ini menjaga variabel berumur pendek agar tidak masuk ke scope di sekitarnya. Kamu akan sering melihatnya pada pencarian map (v, ok := m[k]), type assertion (s, ok := v.(string)), dan error.

Sisi lainnya: kalau kamu butuh nilainya setelah if, deklarasikan sebelumnya. Kesalahan yang umum adalah menaruh hasil di init statement lalu mencoba memakainya di bawah.

Idiom if err != nil

Fungsi yang bisa gagal mengembalikan error di posisi terakhir. Periksa segera, tangani atau kembalikan, lalu lanjutkan jalur normal tanpa indentasi:

package main

import (
	"errors"
	"fmt"
	"strconv"
)

func parseAge(s string) (int, error) {
	n, err := strconv.Atoi(s)
	if err != nil {
		return 0, fmt.Errorf("age %q: %w", s, err)
	}
	if n < 0 || n > 150 {
		return 0, errors.New("age out of range")
	}
	return n, nil
}

func main() {
	for _, s := range []string{"34", "x", "200"} {
		age, err := parseAge(s)
		if err != nil {
			fmt.Println("error:", err)
			continue
		}
		fmt.Println("age:", age)
	}
}

Perhatikan bahwa tidak ada else setelah if err != nil { return ... }. Gaya Go adalah menangani error, melakukan return, dan membiarkan alur normal tetap di margin kiri. Halaman tentang penanganan error membahas wrapping dan pemeriksaan tipe error.

Return lebih awal sebagai ganti percabangan bersarang

Blok if yang bersarang terlalu dalam sulit dibaca. Balik kondisinya dan lakukan return lebih awal; setiap pemeriksaan lalu terbaca sebagai penjaga (guard):

// Nested
func canCheckout(u *User, cart *Cart) bool {
	if u != nil {
		if u.Verified {
			if len(cart.Items) > 0 {
				return true
			}
		}
	}
	return false
}

// Guards
func canCheckout(u *User, cart *Cart) bool {
	if u == nil || !u.Verified {
		return false
	}
	if len(cart.Items) == 0 {
		return false
	}
	return true
}

Programmer Go menyebut ini menjaga happy path tetap rata kiri. Linter seperti revive menandai else setelah blok yang diakhiri return, karena else itu menambah indentasi tanpa guna.

if/else vs switch

Rantai else if panjang yang menguji satu nilai terhadap beberapa kasus lebih enak dibaca sebagai switch. switch tanpa ekspresi bisa menggantikan rantai if/else if dengan kondisi apa pun:

switch {
case score >= 90:
	return "A"
case score >= 80:
	return "B"
default:
	return "F"
}

Pakai if untuk satu atau dua cabang, dan switch begitu ada tiga cabang atau lebih.

Tidak ada operator ternary

Go tidak punya cond ? a : b. Lakukan assignment dengan if:

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

Halaman tentang operator ternary menjelaskan alasannya dan menunjukkan alternatifnya.

Kesalahan umum

• Shadowing dengan :=. if x, err := f(); err == nil { ... } mendeklarasikan x baru yang hanya berlaku untuk if itu. x di luar tidak ikut diperbarui.
• Assignment di dalam kondisi. if x = 5 {} adalah compile error (cannot use assignment x = 5 as value), bukan bug diam-diam seperti di C. Pakai ==.
• Membandingkan float dengan ==. if total == 0.3 gagal untuk nilai hasil perhitungan. Bandingkan dengan toleransi.
• Memeriksa error yang salah. Setelah a, err := f() dan b, err := g(), pastikan setiap if err != nil berada tepat setelah pemanggilannya.

if x > 10 {
	fmt.Println("big")
} else if x > 5 {
	fmt.Println("medium")
} else {
	fmt.Println("small")
}