Sintaks Go untuk pendatang

Go sengaja dibuat kecil: 25 kata kunci, satu bentuk perulangan, tanpa exception, tanpa pewarisan. Materi ini memetakan yang berbeda dari bahasa lain, bukan mengajari cara memprogram.

Bentuk kode yang akan kamu tulis

package katalog

import (
	"errors"
	"fmt"
	"strings"
)

// Diekspor: huruf pertama besar. Bisa dipakai paket lain.
type Produk struct {
	ID    int64
	Nama  string
	Harga int64 // rupiah, dalam satuan terkecil — jangan pernah float untuk uang
}

// errStokHabis huruf kecil: hanya terlihat di dalam paket ini.
var errStokHabis = errors.New("stok habis")

// Method dengan receiver bernilai. Tipe pengembalian ditulis setelah parameter.
func (p Produk) Label() string {
	return fmt.Sprintf("%s (Rp%d)", p.Nama, p.Harga)
}

// Dua nilai kembalian — pola paling khas di Go.
func Cari(daftar []Produk, kata string) (Produk, error) {
	for _, p := range daftar {
		if strings.Contains(strings.ToLower(p.Nama), strings.ToLower(kata)) {
			return p, nil
		}
	}
	return Produk{}, fmt.Errorf("cari %q: %w", kata, errStokHabis)
}

Lima hal yang menyandung pendatang

Deklarasi: := versus var

x := 42                    // hanya di dalam fungsi; tipe disimpulkan (int)
var y int                  // nilai nol: 0
var z = "halo"             // tipe disimpulkan (string)
const Batas = 100          // konstanta, boleh di level paket

var (                      // blok, untuk deklarasi paket
	nama   string
	aktif  bool
	daftar []string
)

Tidak ada nilai "belum diisi" di Go. Setiap variabel yang dideklarasikan langsung punya nilai nol: 0 untuk angka, "" untuk string, false untuk bool, dan nil untuk pointer, slice, map, channel, fungsi, dan interface. Ini yang membuat var buf bytes.Buffer langsung bisa dipakai tanpa konstruktor.

var err error
if kondisi {
	hasil, err := hitung()   // ← err BARU, yang di luar tetap nil
	_ = hasil
}
// err di sini masih nil, apa pun yang terjadi di dalam if

Satu kata untuk semua perulangan

for i := 0; i < 10; i++ { }          // gaya C

for sisa > 0 { }                      // gaya while

for { break }                         // gaya loop tak terbatas

for i, huruf := range "halo" { }      // range: indeks + rune

for i, p := range daftar { }          // slice: indeks + salinan elemen

for kunci, nilai := range peta { }    // map: URUTANNYA ACAK, disengaja

for range 5 { }                       // Go 1.22+: ulang 5 kali, tanpa variabel

Fungsi: banyak nilai kembalian

func bagi(a, b int) (int, error) {
	if b == 0 {
		return 0, errors.New("pembagi nol")
	}
	return a / b, nil
}

hasil, err := bagi(10, 2)
if err != nil {
	return err          // pola yang akan kamu tulis ribuan kali
}

_, err = bagi(10, 0)    // "_" membuang nilai secara eksplisit

Tanda _ (blank identifier) adalah cara Go memaksamu menyatakan bahwa kamu sengaja mengabaikan sesuatu. Karena variabel tak terpakai adalah error kompilasi, tidak ada jalan untuk "kelupaan" — pengabaian selalu terlihat di diff.

defer: pembersihan yang tidak bisa lupa

func salin(dari, ke string) error {
	src, err := os.Open(dari)
	if err != nil {
		return err
	}
	defer src.Close()   // dijalankan saat fungsi keluar, lewat jalur mana pun

	dst, err := os.Create(ke)
	if err != nil {
		return err      // src.Close() tetap terpanggil
	}
	defer dst.Close()

	_, err = io.Copy(dst, src)
	return err
}

defer menjalankan panggilan saat fungsi selesai — bukan saat blok selesai. Beberapa defer dijalankan dengan urutan terbalik (tumpukan). Ini padanan Go untuk finally, dan ia jauh lebih sulit dilupakan karena ditulis tepat di sebelah baris yang membuka sumber dayanya.

Yang tidak ada di Go, dan penggantinya