Belajar Go

package main

import "fmt"

func main() {
    fmt.Println("Halo, Go!")
}

$ go version
go version go1.26.4 windows/amd64

$ go env GOROOT GOPATH
C:\\Program Files\\Go
C:\\Users\\kamimu\\go

$ mkdir halo && cd halo
$ go mod init github.com/kamu/halo
go: creating new go.mod: module github.com/kamu/halo

$ go get github.com/google/uuid
go: added github.com/google/uuid v1.6.0

package main

import (
    "fmt"

    "github.com/google/uuid"
)

func main() {
    fmt.Println(uuid.NewString())
}

$ go env GOPATH
C:\\Users\\kamimu\\go

$ go env GOMODCACHE
C:\\Users\\kamimu\\go\\pkg\\mod

# Pasang ekstensi lalu jalankan dari command palette:
> Go: Install/Update Tools

# Semua beres? Cek formatter bawaan:
$ gofmt -w main.go

$ go run main.go        # jalankan cepat, tanpa berkas hasil
$ go build               # bangun binary proyek aktif
$ go test ./...          # uji semua paket
$ go fmt ./...           # format semua berkas
$ go vet ./...           # periksa pola mencurigakan
$ go doc fmt.Println     # baca dokumentasi
$ go help                # bantuan semua subperintah

$ GOOS=linux   GOARCH=amd64 go build -o app-linux
$ GOOS=windows GOARCH=amd64 go build -o app.exe
$ GOOS=darwin  GOARCH=arm64 go build -o app-mac

package main

import "fmt"

func main() {
    fmt.Println("Halo dari Go!")
    fmt.Println(2 + 3)
}

package main

import (
    "bufio"
    "fmt"
    "os"
    "strings"
)

func main() {
    pembaca := bufio.NewScanner(os.Stdin)
    fmt.Print("Namamu siapa? ")
    pembaca.Scan()
    nama := strings.TrimSpace(pembaca.Text())
    fmt.Printf("Halo, %s!\n", nama)
}

package main

import "fmt"

// Sapa menyapa pengguna dengan nama yang diberikan.
func Sapa(nama string) string {
    return "Halo, " + nama + "!"
}

func main() {
    // Komentar satu baris: penjelas singkat langkah di bawahnya.
    fmt.Println(Sapa("Ari")) /* blok: jarang dipakai, */
}

package main

import "fmt"

func main() {
    var nama string = "Ari"
    umur := 17
    var aktif bool
    fmt.Println(nama, umur, aktif)
}

func main() {
    x, y := 1, 2
    x, y = y, x
    fmt.Println(x, y) // 2 1
}

func main() {
    nama := new(string)
    *nama = "Ari"
    fmt.Println(*nama)  // Ari
    fmt.Println(nama)   // 0xc000010250 (alamat memori)
}

package main

import "fmt"

const tarifOjol = 2500

func main() {
    km := 6
    total := tarifOjol * km
    murah := total < 20000
    fmt.Println("Total:", total, "Murah?", murah)
}

const (
    Senin = iota + 1 // 1
    Selasa           // 2
    Rabu             // 3
    Kamis            // 4
    Jumat            // 5
)

func main() {
    fmt.Println(Senin, Jumat) // 1 5
}

package main

import "fmt"

func main() {
    nilai := 82
    switch {
    case nilai >= 90:
        fmt.Println("A")
    case nilai >= 80:
        fmt.Println("B")
    default:
        fmt.Println("C")
    }
}

func main() {
    hari := "sabtu"
    switch hari {
    case "sabtu", "minggu":
        fmt.Println("Weekend!")
        fallthrough
    case "jumat":
        fmt.Println("Santai.")
    default:
        fmt.Println("Hari kerja.")
    }
}

package main

import "fmt"

func main() {
    buah := []string{"apel", "mangga", "jeruk"}
    for i, nama := range buah {
        fmt.Println(i, nama)
    }
}

func main() {
    angka := [][]int{{1, 2}, {3, -1, 4}, {5}}
luar:
    for _, baris := range angka {
        for _, n := range baris {
            if n < 0 {
                break luar
            }
            fmt.Print(n, " ")
        }
    }
    fmt.Println() // 1 2 3
}

package main

import "fmt"

func main() {
    var nilai [3]int
    nilai[0] = 80
    nilai[1] = 90
    nilai[2] = 75

    singkat := [...]int{4, 8, 15, 16, 23, 42}
    fmt.Println(len(nilai), len(singkat), nilai[1], singkat[5])
}

func ubah(a [3]int) {
    a[0] = 999
}

func main() {
    asli := [3]int{1, 2, 3}
    ubah(asli)
    fmt.Println(asli) // [1 2 3] — tidak berubah
}

func main() {
    papan := [2][3]int{
        {1, 2, 3},
        {4, 5, 6},
    }
    fmt.Println(papan[1][2]) // 6
}

package main

import (
    "fmt"
    "slices"
)

func main() {
    nilai := []int{80, 90, 75}
    nilai = append(nilai, 100)
    potongan := nilai[1:3]
    fmt.Println(len(nilai), cap(nilai), potongan)
}

func main() {
    asal := []int{1, 2, 3, 4, 5}
    tujuan := make([]int, 2)
    n := copy(tujuan, asal)
    fmt.Println(n, tujuan) // 2 [1 2]

    a := asal[0:2]                 // len 2, cap 5
    b := append(a, 99)
    fmt.Println(asal)              // [1 2 99 4 5] — indeks 2 tertimpa!
}

func main() {
    nama := []string{"adi", "citra", "budi"}
    slices.Sort(nama)
    fmt.Println(nama)                         // [adi budi citra]
    fmt.Println(slices.Contains(nama, "budi")) // true
    fmt.Println(slices.Index(nama, "citra"))   // 2
}

package main

import "fmt"

func main() {
    stok := map[string]int{"kopi": 12, "teh": 8}
    stok["susu"] = 5
    jumlah, ada := stok["teh"]
    fmt.Println(jumlah, ada)
}

package main

import (
    "fmt"
    "slices"
)

func main() {
    umur := map[string]int{"citra": 19, "adi": 21, "budi": 20}
    for nama, u := range umur {
        fmt.Println(nama, u) // urutan acak tiap jalankan
    }

    kunci := []string{}
    for nama := range umur {
        kunci = append(kunci, nama)
    }
    slices.Sort(kunci)
    for _, nama := range kunci {
        fmt.Println(nama, umur[nama]) // selalu adi, budi, citra
    }
}

package main

import "fmt"

func jumlah(angka ...int) int {
    total := 0
    for _, n := range angka {
        total += n
    }
    return total
}

func main() {
    fmt.Println(jumlah(2, 4, 6))
}

func minMax(angka []int) (min int, max int) {
    min, max = angka[0], angka[0]
    for _, n := range angka[1:] {
        if n < min {
            min = n
        }
        if n > max {
            max = n
        }
    }
    return // return polos: bawa min dan max
}

func main() {
    kecil, besar := minMax([]int{7, 2, 9, 4})
    fmt.Println(kecil, besar) // 2 9
}

package main

import "fmt"

func buatPenghitung() func() int {
    hitung := 0
    return func() int {
        hitung++
        return hitung
    }
}

func main() {
    next := buatPenghitung()
    fmt.Println(next(), next(), next()) // 1 2 3
}

func saring(angka []int, kriteria func(int) bool) []int {
    hasil := []int{}
    for _, n := range angka {
        if kriteria(n) {
            hasil = append(hasil, n)
        }
    }
    return hasil
}

func main() {
    data := []int{3, 8, 1, 9, 4, 6}
    genap := saring(data, func(n int) bool { return n%2 == 0 })
    besar := saring(data, func(n int) bool { return n > 5 })
    fmt.Println(genap) // [8 4 6]
    fmt.Println(besar) // [8 9 6]
}

package main

import "fmt"

func naikkan(poin *int) {
    *poin += 10
}

func main() {
    skor := 70
    naikkan(&skor)
    fmt.Println(skor)
}

type Titik struct{ X, Y int }

func geser(t *Titik, dx, dy int) {
    t.X += dx // singkat: (*t).X boleh ditulis t.X
    t.Y += dy
}

func main() {
    posisi := Titik{X: 2, Y: 3}
    geser(&posisi, 5, -1)
    fmt.Println(posisi) // {7 2}
}

package main

import "fmt"

type Alamat struct {
    Kota   string
    KodePos string
}

type Siswa struct {
    Nama  string
    Poin  int
    Tinggal Alamat
}

func main() {
    ari := Siswa{Nama: "Ari", Poin: 10, Tinggal: Alamat{Kota: "Bandung", KodePos: "40115"}}
    fmt.Printf("%+v\n", ari)
}

type Pengguna struct {
    Email string
}

type Admin struct {
    Pengguna          // embedded: tanpa nama field
    Level   int
}

func main() {
    a := Admin{Pengguna: Pengguna{Email: "ops@site.dev"}, Level: 5}
    fmt.Println(a.Email) // akses langsung, bukan a.Pengguna.Email
}

func main() {
    hasil := struct {
        Nama string
        Skor int
    }{Nama: "Ari", Skor: 95}
    fmt.Println(hasil.Nama, hasil.Skor)
}

package main

import "fmt"

type Siswa struct {
    Nama string
    Poin int
}

func (s *Siswa) Tambah(p int) {
    s.Poin += p
}

func (s Siswa) Label() string {
    return fmt.Sprintf("%s (%d poin)", s.Nama, s.Poin)
}

func main() {
    ari := Siswa{Nama: "Ari", Poin: 10}
    ari.Tambah(25)
    fmt.Println(ari.Label())
}

type Celcius float64

func (c Celcius) Fahrenheit() float64 {
    return float64(c)*9/5 + 32
}

func (c Celcius) Beku() bool {
    return c <= 0
}

func main() {
    suhu := Celcius(25.5)
    fmt.Println(suhu.Fahrenheit(), suhu.Beku()) // 77.9 false
}

// ---- berkas: hitung/hitung.go ----
package hitung

// Luas diekspor: publik untuk siapa saja.
func Luas(r float64) float64 {
    return pi() * r * r
}

// pi tidak diekspor: rahasia paket ini.
func pi() float64 {
    return 3.14159
}

// ---- berkas: main.go ----
package main

import (
    "fmt"
    "hitung"
)

func main() {
    fmt.Println(hitung.Luas(7)) // 153.93791
}

package main

import "fmt"

type Pengirim interface {
    Kirim(pesan string) string
}

type Email struct{}

func (e Email) Kirim(pesan string) string {
    return "Email: " + pesan
}

func kirimSemua(p Pengirim, pesan string) {
    fmt.Println(p.Kirim(pesan))
}

func main() {
    kirimSemua(Email{}, "Halo!")
}

func jelaskan(x any) string {
    switch v := x.(type) {
    case int:
        return fmt.Sprintf("angka %d", v)
    case string:
        return fmt.Sprintf("teks %q sepanjang %d", v, len(v))
    case []byte:
        return "deretan byte"
    default:
        return "tipe lain"
    }
}

func main() {
    fmt.Println(jelaskan(42), jelaskan("go"))
}

package main

import "fmt"

func tampilSemua(nilai ...interface{}) {
    for _, v := range nilai {
        fmt.Print(v, " ")
    }
    fmt.Println()
}

func main() {
    tampilSemua("umur", 17, 55.5, true, []int{1, 2})
}

package main

import (
    "fmt"
    "strings"
)

func main() {
    var data interface{} = 42

    if n, ok := data.(int); ok {
        fmt.Println("angka:", n*2) // angka: 84
    }

    data = "golang"
    if s, ok := data.(string); ok {
        fmt.Println("teks:", strings.ToUpper(s)) // teks: GOLANG
    }
}

package main

import (
    "fmt"
    "reflect"
)

type Siswa struct {
    Nama  string
    Poin  int
}

func main() {
    x := 42
    fmt.Println(reflect.TypeOf(x).Kind()) // int

    s := Siswa{Nama: "Ari", Poin: 10}
    t := reflect.TypeOf(s)
    for i := 0; i < t.NumField(); i++ {
        f := t.Field(i)
        fmt.Printf("%s %s\n", f.Name, f.Type)
    }
}

package main

import (
    "fmt"
    "time"
)

func tugas(nama string) {
    fmt.Println("mulai", nama)
    time.Sleep(500 * time.Millisecond)
    fmt.Println("selesai", nama)
}

func main() {
    go tugas("A") // tidak menunggu
    go tugas("B")
    time.Sleep(1 * time.Second) // demo saja: beri waktu goroutine
    fmt.Println("main selesai")
}

func main() {
    for i := 1; i <= 5; i++ {
        go func(n int) {
            fmt.Println("tugas", n)
        }(i)
    }
    time.Sleep(300 * time.Millisecond)
}

package main

import "fmt"

func pesan(nama string, ch chan string) {
    ch <- "Halo dari " + nama
}

func main() {
    ch := make(chan string)
    go pesan("goroutine", ch)
    fmt.Println(<-ch)
}

func pekerja(tugas chan string, hasil chan int) {
    nama := <-tugas            // terima pekerjaan
    hasil <- len(nama)         // kirim hasil
}

func main() {
    tugas := make(chan string)
    hasil := make(chan int)
    go pekerja(tugas, hasil)
    tugas <- "concURRENCY"     // kirim pekerjaan
    fmt.Println(<-hasil)       // 10
}

package main

import "fmt"

func main() {
    ch := make(chan int, 3)

    ch <- 1 // tidak menunggu: buffer masih kosong
    ch <- 2
    ch <- 3

    fmt.Println(len(ch), cap(ch)) // 3 3
    fmt.Println(<-ch)             // 1 (yang pertama masuk)
    fmt.Println(<-ch)             // 2
}

func main() {
    ch := make(chan int, 2)

    ch <- 1
    ch <- 2
    // ch <- 3 // deadlock! buffer penuh tanpa penerima

    fmt.Println(<-ch)
    fmt.Println(<-ch)
}

package main

import (
    "fmt"
    "time"
)

func main() {
    cepat := make(chan string)
    lambat := make(chan string)

    go func() {
        time.Sleep(1 * time.Second)
        cepat <- "satu detik"
    }()
    go func() {
        time.Sleep(3 * time.Second)
        lambat <- "tiga detik"
    }()

    for i := 0; i < 2; i++ {
        select {
        case pesan := <-cepat:
            fmt.Println("dari cepat:", pesan)
        case pesan := <-lambat:
            fmt.Println("dari lambat:", pesan)
        }
    }
}

func main() {
    ch := make(chan int)

    select {
    case n := <-ch:
        fmt.Println("dapat", n)
    default:
        fmt.Println("belum ada data, lanjut kerja lain")
    }
}

package main

import "fmt"

func kirim(ch chan int) {
    for i := 1; i <= 3; i++ {
        ch <- i
    }
    close(ch) // pengirim memberi tahu: data habis
}

func main() {
    ch := make(chan int)
    go kirim(ch)

    for v := range ch {
        fmt.Println(v) // 1, 2, 3, lalu loop berhenti sendiri
    }
}

func main() {
    ch := make(chan int, 2)
    ch <- 10
    close(ch)

    v, ok := <-ch
    fmt.Println(v, ok) // 10 true — sisa buffer

    v, ok = <-ch
    fmt.Println(v, ok) // 0 false — sudah kering
}

package main

import (
    "errors"
    "fmt"
    "time"
)

func ambilLambat(ch chan string) {
    time.Sleep(3 * time.Second) // simulasi layanan lambat
    ch <- "data"
}

func main() {
    ch := make(chan string)
    go ambilLambat(ch)

    select {
    case data := <-ch:
        fmt.Println("dapat:", data)
    case <-time.After(1 * time.Second):
        fmt.Println("timeout: terlalu lama menunggu")
    }
}

func ambil(ch chan string) (string, error) {
    select {
    case v := <-ch:
        return v, nil
    case <-time.After(2 * time.Second):
        return "", errors.New("batas waktu terlampaui")
    }
}

func main() {
    ch := make(chan string)
    go func() { time.Sleep(3 * time.Second); ch <- "telat" }()

    if _, err := ambil(ch); err != nil {
        fmt.Println("gagal:", err)
    }
}

package main

import "fmt"

func main() {
    defer fmt.Println("ketiga (defer terakhir didaftar)")
    defer fmt.Println("kedua (LIFO: defer ini lebih dulu)")
    fmt.Println("pertama (isi fungsi biasa)")
}

func bacaConfig(nama string) error {
    f, err := os.Open(nama)
    if err != nil {
        return err
    }
    defer f.Close() // pasti dipanggil di SEMUA return

    // ... proses berkas di sini
    return nil
}

func main() {
    defer fmt.Println("pembersihan") // TIDAK akan jalan

    fmt.Println("sebelum exit")
    os.Exit(1) // berhenti seketika, kode keluar 1
}