Go Modern (1.21 - 1.26)

// 1. Kembalikan slice -- seluruh data harus muat di memori
func (t *Tree) Semua() []int { ... }

// 2. Channel -- lambat, dan bocor bila konsumen berhenti di tengah
func (t *Tree) Iterasi() <-chan int { ... }

// 3. Objek iterator -- verbose
it := t.Iterator()
for it.Next() { gunakan(it.Value()) }

package iter

type Seq[V any]      func(yield func(V) bool)
type Seq2[K, V any]  func(yield func(K, V) bool)

import "iter"

type Pohon struct {
    Nilai       int
    Kiri, Kanan *Pohon
}

// Penelusuran in-order sebagai iterator
func (p *Pohon) Semua() iter.Seq[int] {
    return func(yield func(int) bool) {
        p.telusuri(yield)
    }
}

func (p *Pohon) telusuri(yield func(int) bool) bool {
    if p == nil {
        return true
    }
    return p.Kiri.telusuri(yield) &&
           yield(p.Nilai) &&
           p.Kanan.telusuri(yield)
}

// Dipakai persis seperti mengiterasi slice:
for nilai := range pohon.Semua() {
    fmt.Println(nilai)
    if nilai > 100 {
        break     // iterator berhenti dengan rapi
    }
}

func BarisBerkas(nama string) iter.Seq2[string, error] {
    return func(yield func(string, error) bool) {
        f, err := os.Open(nama)
        if err != nil {
            yield("", err)
            return
        }
        defer f.Close()      // SELALU dipanggil, termasuk saat break

        pemindai := bufio.NewScanner(f)
        for pemindai.Scan() {
            if !yield(pemindai.Text(), nil) {
                return       // konsumen berhenti -- defer tetap jalan
            }
        }
        if err := pemindai.Err(); err != nil {
            yield("", err)
        }
    }
}

for baris, err := range BarisBerkas("data.txt") {
    if err != nil {
        log.Fatal(err)
    }
    fmt.Println(baris)
}

// Mengubah iterator "push" menjadi gaya "pull"
next, stop := iter.Pull(pohon.Semua())
defer stop()

for {
    nilai, ada := next()
    if !ada {
        break
    }
    fmt.Println(nilai)
}
// Berguna untuk menggabungkan dua iterator secara berselang-seling,
// yang mustahil dilakukan dengan gaya push biasa.

import "slices"

angka := []int{5, 2, 8, 1, 9}
slices.Sort(angka)                    // [1 2 5 8 9]

// Urut berdasarkan aturan sendiri
orang := []Orang{{"Budi", 30}, {"Ani", 25}}
slices.SortFunc(orang, func(a, b Orang) int {
    return cmp.Compare(a.Umur, b.Umur)
})

// Versi stabil: elemen yang sama mempertahankan urutan aslinya
slices.SortStableFunc(orang, func(a, b Orang) int {
    return strings.Compare(a.Nama, b.Nama)
})

slices.IsSorted(angka)                // true

slices.Contains(angka, 8)             // true
slices.Index(angka, 8)                // 3, atau -1 bila tidak ada

slices.IndexFunc(orang, func(o Orang) bool {
    return o.Umur > 28
})

// Pencarian biner -- HANYA pada slice yang sudah terurut
idx, ketemu := slices.BinarySearch(angka, 5)

a := []int{1, 2, 3}
b := []int{4, 5}

gabung := slices.Concat(a, b)         // [1 2 3 4 5]
salinan := slices.Clone(a)            // salinan dangkal
slices.Reverse(a)                     // [3 2 1]

// Buang elemen berurutan yang duplikat (perlu diurutkan dulu)
dedup := slices.Compact([]int{1, 1, 2, 2, 3})   // [1 2 3]

// Hapus indeks 1 sampai sebelum 3
sisa := slices.Delete([]int{1,2,3,4,5}, 1, 3)   // [1 4 5]

// Sisipkan di indeks 2
hasil := slices.Insert([]int{1,2,5}, 2, 3, 4)   // [1 2 3 4 5]

slices.Equal(a, b)                    // perbandingan elemen per elemen
slices.Max(angka)
slices.Min(angka)

// Mengiterasi dengan indeks sebagai iter.Seq2
for i, v := range slices.All(angka) { ... }

// Hanya nilainya
for v := range slices.Values(angka) { ... }

// Dari belakang
for i, v := range slices.Backward(angka) { ... }

// Mengumpulkan iterator kembali menjadi slice
hasil := slices.Collect(pohon.Semua())
terurut := slices.Sorted(pohon.Semua())

import "maps"

m := map[string]int{"a": 1, "b": 2, "c": 3}

// Mengembalikan ITERATOR, bukan slice
for k := range maps.Keys(m) { ... }
for v := range maps.Values(m) { ... }

// Ubah menjadi slice terurut -- pola yang sangat sering dipakai
kunci := slices.Sorted(maps.Keys(m))   // [a b c]

salinan := maps.Clone(m)
maps.Copy(tujuan, sumber)
maps.Equal(m1, m2)

// Hapus berdasarkan kondisi
maps.DeleteFunc(m, func(k string, v int) bool {
    return v < 2
})

import "cmp"

cmp.Compare(3, 5)          // -1
cmp.Less("a", "b")         // true

// Mengembalikan nilai bukan-kosong yang pertama
nama := cmp.Or(dariEnv, dariConfig, "bawaan")

// Pengurutan berjenjang: berdasarkan umur, lalu nama
slices.SortFunc(orang, func(a, b Orang) int {
    return cmp.Or(
        cmp.Compare(a.Umur, b.Umur),
        cmp.Compare(a.Nama, b.Nama),
    )
})

var wg sync.WaitGroup
var mu sync.Mutex
var errPertama error

for _, url := range daftarURL {
    wg.Add(1)
    go func(u string) {
        defer wg.Done()
        if err := ambil(u); err != nil {
            mu.Lock()
            if errPertama == nil {
                errPertama = err
            }
            mu.Unlock()
        }
    }(url)
}
wg.Wait()
// Semua goroutine tetap berjalan sampai selesai
// meski yang pertama sudah gagal sejak awal.

import "golang.org/x/sync/errgroup"

func ambilSemua(ctx context.Context, daftarURL []string) error {
    g, ctx := errgroup.WithContext(ctx)

    for _, url := range daftarURL {
        g.Go(func() error {
            return ambil(ctx, url)     // cukup kembalikan error
        })
    }

    return g.Wait()   // error PERTAMA yang bukan nil
}

g, ctx := errgroup.WithContext(ctx)
g.SetLimit(10)     // maksimal 10 goroutine berjalan bersamaan

for _, berkas := range sejutaBerkas {
    g.Go(func() error {
        return proses(ctx, berkas)
    })
}
return g.Wait()

func ambilSemuaHasil(ctx context.Context, urls []string) ([]Hasil, error) {
    hasil := make([]Hasil, len(urls))   // dialokasikan di muka
    g, ctx := errgroup.WithContext(ctx)
    g.SetLimit(runtime.NumCPU())

    for i, url := range urls {
        g.Go(func() error {
            r, err := ambil(ctx, url)
            if err != nil {
                return fmt.Errorf("ambil %s: %w", url, err)
            }
            hasil[i] = r     // AMAN: tiap goroutine menulis indeks berbeda
            return nil
        })
    }

    if err := g.Wait(); err != nil {
        return nil, err
    }
    return hasil, nil
}

// Di Go 1.21 dan sebelumnya, kode ini BUG:
for _, url := range urls {
    go func() {
        ambil(url)     // semua goroutine melihat url yang SAMA
    }()
}
// Solusi lama: url := url, atau kirim sebagai argumen.

// Sejak Go 1.22, variabel perulangan dibuat BARU di tiap iterasi,
// sehingga kode di atas kini berperilaku benar.

func proses(ctx context.Context, item Item) error {
    // Selalu periksa pembatalan pada pekerjaan yang panjang
    select {
    case <-ctx.Done():
        return ctx.Err()
    default:
    }

    // Teruskan ctx ke SEMUA panggilan yang memblokir
    req, _ := http.NewRequestWithContext(ctx, "GET", item.URL, nil)
    resp, err := http.DefaultClient.Do(req)
    ...
    row := db.QueryRowContext(ctx, "SELECT ...")
    ...
}

func FuzzUraiWaktu(f *testing.F) {
    // Benih: contoh masukan yang valid sebagai titik awal
    f.Add("12:30")
    f.Add("00:00")
    f.Add("23:59")

    f.Fuzz(func(t *testing.T, s string) {
        jam, menit, err := UraiWaktu(s)
        if err != nil {
            return    // menolak masukan buruk itu WAJAR
        }

        // Bila berhasil diurai, hasilnya HARUS masuk akal
        if jam < 0 || jam > 23 {
            t.Errorf("jam di luar rentang: %d dari %q", jam, s)
        }
        if menit < 0 || menit > 59 {
            t.Errorf("menit di luar rentang: %d dari %q", menit, s)
        }
    })
}

# Jalankan sebagai uji biasa (hanya memakai benih)
go test ./...

# Jalankan fuzzing sungguhan selama 30 detik
go test -fuzz=FuzzUraiWaktu -fuzztime=30s

# Masukan yang membuat gagal otomatis DISIMPAN ke
# testdata/fuzz/FuzzUraiWaktu/ dan menjadi kasus uji permanen.

func TestCacheKedaluwarsa(t *testing.T) {
    c := NewCache(100 * time.Millisecond)
    c.Set("a", 1)

    time.Sleep(150 * time.Millisecond)   // uji jadi lambat

    if _, ada := c.Get("a"); ada {
        t.Error("seharusnya sudah kedaluwarsa")
    }
}
// Punya 50 uji seperti ini? Pipeline Anda bertambah lambat
// berdetik-detik, dan tetap gagal acak di runner yang sibuk.

import "testing/synctest"

func TestCacheKedaluwarsa(t *testing.T) {
    synctest.Test(t, func(t *testing.T) {
        c := NewCache(100 * time.Millisecond)
        c.Set("a", 1)

        // Waktu di dalam gelembung ini PALSU.
        // Maju 150 ms secara seketika.
        time.Sleep(150 * time.Millisecond)

        if _, ada := c.Get("a"); ada {
            t.Error("seharusnya sudah kedaluwarsa")
        }
    })
}

synctest.Test(t, func(t *testing.T) {
    hasil := make(chan int, 1)

    go func() {
        time.Sleep(1 * time.Second)
        hasil <- 42
    }()

    // Tunggu sampai semua goroutine dalam gelembung memblokir
    synctest.Wait()

    // Sekarang aman untuk memeriksa keadaan
    select {
    case v := <-hasil:
        if v != 42 { t.Errorf("dapat %d", v) }
    default:
        t.Error("goroutine belum selesai")
    }
})

# Deteksi data race -- WAJIB dijalankan di CI
go test -race ./...

# Laporan cakupan
go test -coverprofile=cover.out ./...
go tool cover -html=cover.out

# Benchmark beserta alokasi memori
go test -bench=. -benchmem

# Uji contoh yang keluarannya diverifikasi
func ExampleUraiWaktu() {
    j, m, _ := UraiWaktu("12:30")
    fmt.Println(j, m)
    // Output: 12 30
}

# Subuji berbasis tabel dengan t.Parallel()
for _, kasus := range kasusUji {
    t.Run(kasus.nama, func(t *testing.T) {
        t.Parallel()
        ...
    })
}