Standard Library

Apa itu Go Standard Library?

Go Standard Library adalah kumpulan package bawaan resmi yang disertakan secara gratis saat kita menginstall compiler Go di komputer.

Dokumentasi lengkap seluruh package Standard Library dapat diakses di situs resmi pkg.go.dev/std.

package main

import (
	"fmt"
	"runtime"
)

func main() {
	fmt.Println("Memulai Modul Golang Standard Library!")
	fmt.Println("Versi Go SDK:", runtime.Version())
}

Package fmt

Package fmt (Formated I/O) menyediakan fungsi untuk format teks masukan dan keluaran.

Format Verb Populer:

Verb	Fungsi / Keterangan
%v	Format nilai default (Default value format)
%+v	Format struct beserta nama field-nya
%#v	Format sintaks kode Go aktual dari objek
%T	Format tipe data dari variabel
%d	Format angka integer desimal
%s	Format nilai string
%t	Format nilai boolean (true/false)

package main

import "fmt"

type Person struct {
	Name string
	Age  int
}

func main() {
	p := Person{Name: "Eko Kurniawan", Age: 30}

	fmt.Printf("Default %%v: %v
", p)
	fmt.Printf("Struct Field %%+v: %+v
", p)
	fmt.Printf("Go Syntax %%#v: %#v
", p)
	fmt.Printf("Type %%T: %T
", p)

	// Sprintf mengembalikan string
	resultString := fmt.Sprintf("Nama: %s, Umur: %d", p.Name, p.Age)
	fmt.Println("Hasil Sprintf:", resultString)
}

Package errors

Package errors menyediakan utilitas untuk membuat dan memeriksa kesalahan di Go modern.

• errors.New("msg"): Membuat error baru sederhana.
• fmt.Errorf("... %w", err): Menguraikan/membungkus error (*Error Wrapping*).
• errors.Is(err, target): Memeriksa apakah error cocok dengan target tertentu (meskipun di-wrap).
• errors.As(err, &targetStruct): Mengonversi error ke tipe custom error struct tertentu.

package main

import (
	"errors"
	"fmt"
)

var (
	ErrNotFound     = errors.New("data tidak ditemukan")
	ErrValidationError = errors.New("validasi gagal")
)

func GetById(id string) error {
	if id == "" {
		return ErrValidationError
	}
	if id != "eko" {
		return fmt.Errorf("search id %s: %w", id, ErrNotFound) // Wrapping Error
	}
	return nil
}

func main() {
	err := GetById("budi")

	if err != nil {
		if errors.Is(err, ErrNotFound) {
			fmt.Println("Pencarian Gagal: Data Not Found!")
		} else {
			fmt.Println("Error Lain:", err)
		}
	}
}

Package os

Package os menyediakan interface independen platform untuk berinteraksi dengan Sistem Operasi.

• os.Args: Slice string yang berisi argumen baris perintah terminal.
• os.Getenv("KEY") / os.Setenv("KEY", "VAL"): Membaca & memasang Environment Variable.
• os.Hostname(): Mengambil nama komputer host.

package main

import (
	"fmt"
	"os"
)

func main() {
	// Membaca Argumen CLI terminal
	args := os.Args
	fmt.Println("CLI Arguments:", args)

	// Environment Variables
	os.Setenv("APP_ENV", "development")
	env := os.Getenv("APP_ENV")
	fmt.Println("APP_ENV Variable:", env)

	// Hostname
	hostname, _ := os.Hostname()
	fmt.Println("Hostname OS:", hostname)
}

Package flag

Package flag memudahkan pembuatan aplikasi berbasis Command Line Interface (CLI) yang menerima opsi bertanda strip (seperti -host=localhost -port=8080).

package main

import (
	"flag"
	"fmt"
)

func main() {
	// Definisi flag (mengembalikan POINTER)
	host := flag.String("host", "localhost", "Put database host")
	port := flag.Int("port", 3306, "Put database port")
	user := flag.String("user", "root", "Put database user")

	// Wajib dipanggil!
	flag.Parse()

	// Membaca nilai pointer dengan *
	fmt.Println("Database Config:")
	fmt.Println("Host:", *host)
	fmt.Println("Port:", *port)
	fmt.Println("User:", *user)
}

Package strings

Package strings menyediakan banyak fungsi utilitas untuk memanipulasi data teks string.

Fungsi	Deskripsi
strings.Contains(s, sub)	Mengecek apakah string memuat substring tertentu (bool)
strings.Split(s, sep)	Memotong string menjadi slice string berdasarkan pemisah
strings.Join(slice, sep)	Menggabungkan slice string menjadi satu string utuh
strings.ToLower(s) / ToUpper(s)	Mengubah huruf menjadi kecil / kapital semua
strings.Trim(s, cutset)	Memotong karakter spasi/tertentu di awal dan akhir string
strings.ReplaceAll(s, old, new)	Mengganti semua substring lama dengan baru

package main

import (
	"fmt"
	"strings"
)

func main() {
	text := "  Eko Kurniawan Khannedy  "

	fmt.Println("Contains 'Kurniawan':", strings.Contains(text, "Kurniawan"))
	fmt.Println("Trimmed:", strings.TrimSpace(text))
	fmt.Println("Upper:", strings.ToUpper(text))
	
	words := strings.Split(strings.TrimSpace(text), " ")
	fmt.Println("Split Words:", words)
	fmt.Println("Joined with Dash:", strings.Join(words, "-"))
}

Package strconv

Package strconv digunakan untuk konversi dari tipe data String ke tipe data primitif (int, float, bool) atau sebaliknya.

Singkatan Populer:

• strconv.Atoi(s): ASCII to Integer (String ke Int).
• strconv.Itoa(i): Integer to ASCII (Int ke String).
• strconv.ParseBool("true"): String ke Boolean.
• strconv.ParseFloat("3.14", 64): String ke Float64.

package main

import (
	"fmt"
	"strconv"
)

func main() {
	// String ke Int (Atoi)
	number, err := strconv.Atoi("1000")
	if err == nil {
		fmt.Println("Hasil Atoi int:", number+500)
	}

	// Int ke String (Itoa)
	strVal := strconv.Itoa(2024)
	fmt.Println("Hasil Itoa string:", strVal + " Tahun")

	// Parse Bool
	booleanVal, _ := strconv.ParseBool("true")
	fmt.Println("Parsed Bool:", booleanVal)
}

Package math

Package math menyediakan fungsi matematika dan konstanta dasar untuk angka bertipe float64.

• math.Round(x): Membulatkan ke angka terdekat.
• math.Floor(x): Membulatkan ke bawah.
• math.Ceil(x): Membulatkan ke atas.
• math.Max(a, b) / math.Min(a, b): Mengambil nilai terbesar / terkecil.

package main

import (
	"fmt"
	"math"
)

func main() {
	fmt.Println("math.Round(1.7):", math.Round(1.7))
	fmt.Println("math.Floor(1.7):", math.Floor(1.7))
	fmt.Println("math.Ceil(1.3):", math.Ceil(1.3))
	fmt.Println("math.Max(10, 20):", math.Max(10, 20))
	fmt.Println("math.Pow(2, 3):", math.Pow(2, 3)) // 2^3 = 8
}

Package container/list

Package container/list mengimplementasikan struktur data Doubly Linked List.

Setiap elemen menunjuk ke elemen sebelum (Prev) dan elemen setelahnya (Next).

package main

import (
	"container/list"
	"fmt"
)

func main() {
	data := list.New()

	data.PushBack("Eko")
	data.PushBack("Kurniawan")
	data.PushBack("Khannedy")
	data.PushFront("Budi") // Ditambah di paling depan

	// Iterasi Linked List dari Front ke Back
	for e := data.Front(); e != nil; e = e.Next() {
		fmt.Println("Element:", e.Value)
	}
}

Package container/ring

Package container/ring mengimplementasikan struktur data **Circular List** (Ring), di mana elemen terakhir kembali menunjuk ke elemen pertama.

package main

import (
	"container/ring"
	"fmt"
	"strconv"
)

func main() {
	data := ring.New(5) // Ring dengan 5 elemen

	for i := 0; i < data.Len(); i++ {
		data.Value = "Data " + strconv.Itoa(i)
		data = data.Next()
	}

	// Iterasi Ring dengan Do()
	data.Do(func(value any) {
		fmt.Println("Ring Value:", value)
	})
}

Package sort

Package sort menyediakan fungsi untuk mengurutkan slice data bawaan maupun objek struct kustom.

Tiga Method Kontrak sort.Interface:

1. Len() int: Mengembalikan jumlah data.
2. Less(i, j int) bool: Pengujian kriteria data i lebih kecil dari j.
3. Swap(i, j int): Menukar posisi elemen i dan j.

package main

import (
	"fmt"
	"sort"
)

type User struct {
	Name string
	Age  int
}

type UserSlice []User

func (s UserSlice) Len() int           { return len(s) }
func (s UserSlice) Less(i, j int) bool { return s[i].Age < s[j].Age } // Sort by Age
func (s UserSlice) Swap(i, j int)      { s[i], s[j] = s[j], s[i] }

func main() {
	users := UserSlice{
		{"Eko", 30},
		{"Budi", 25},
		{"Joko", 35},
	}

	sort.Sort(users)
	fmt.Println("Sorted Users by Age:", users)
}

Package time

Package time menyediakan fungsi pengukursan, kalkulasi, dan formatting waktu.

package main

import (
	"fmt"
	"time"
)

func main() {
	now := time.Now()
	fmt.Println("Waktu Sekarang:", now)

	// Format Tanggal (Gunakan Layout Standar Go 2006-01-02)
	formatter := now.Format("02-01-2006 15:04:05")
	fmt.Println("Formatted Date:", formatter)

	// Parse Tanggal dari String
	layout := "2006-01-02"
	parsedTime, _ := time.Parse(layout, "2024-12-31")
	fmt.Println("Parsed Time:", parsedTime)
}

Package reflect (Reflection)

Reflection adalah kemampuan program membaca tipe data dan struktur metadata variabel pada saat program berjalan (*runtime*).

Sangat populer digunakan untuk framework validator dan ORM menggunakan Struct Tag (misal: `required:"true" max:"10"`).

package main

import (
	"fmt"
	"reflect"
)

type Sample struct {
	Name string `required:"true" max:"10"`
}

func readField(sample any) {
	sampleType := reflect.TypeOf(sample)
	fmt.Println("Type Name:", sampleType.Name())

	for i := 0; i < sampleType.NumField(); i++ {
		field := sampleType.Field(i)
		fmt.Println("Field Name:", field.Name)
		fmt.Println("Field Type:", field.Type)
		fmt.Println("Tag required:", field.Tag.Get("required"))
	}
}

func main() {
	readField(Sample{Name: "Eko"})
}

Package regexp

Package regexp menyediakan pencarian pola teks menggunakan sintaks **Regular Expression** (RegEx).

package main

import (
	"fmt"
	"regexp"
)

func main() {
	// Pola regex untuk mencari kata berpola e[a-z]o
	regex, _ := regexp.Compile(`e([a-z])o`)

	fmt.Println("Match 'eko':", regex.MatchString("eko"))
	fmt.Println("Match 'edo':", regex.MatchString("edo"))
	fmt.Println("Match 'ego':", regex.MatchString("ego"))

	// Mencetak semua pencocokan
	results := regex.FindAllString("eko edo ego eto e1o", -1)
	fmt.Println("Find All:", results)
}

Package encoding

Package encoding berisi sub-package untuk konversi format data seperti encoding/base64, encoding/csv, dan encoding/json.

package main

import (
	"encoding/base64"
	"fmt"
)

func main() {
	original := "Eko Kurniawan Khannedy"

	// Encoding ke Base64
	encoded := base64.StdEncoding.EncodeToString([]byte(original))
	fmt.Println("Encoded Base64:", encoded)

	// Decoding dari Base64
	decodedBytes, _ := base64.StdEncoding.DecodeString(encoded)
	fmt.Println("Decoded Original:", string(decodedBytes))
}

Package slices & maps (Go Modern)

Sejak Go 1.21+, hadir package slices yang mempermudah operasi pencarian, pengurutan, dan komparasi slice tanpa perlu for loop manual.

package main

import (
	"fmt"
	"slices"
)

func main() {
	names := []string{"Eko", "Kurniawan", "Khannedy"}
	values := []int{10, 90, 30, 50}

	fmt.Println("Min value:", slices.Min(values))
	fmt.Println("Max value:", slices.Max(values))
	fmt.Println("Contains 'Eko':", slices.Contains(names, "Eko"))
	fmt.Println("Index 'Khannedy':", slices.Index(names, "Khannedy"))
}

Package path & path/filepath

Package path/filepath digunakan untuk memanipulasi direktori path file sesuai separator OS (slash / di Linux/Mac atau backslash \ di Windows).

package main

import (
	"fmt"
	"path/filepath"
)

func main() {
	path := "/home/user/documents/report.pdf"

	fmt.Println("Dir:", filepath.Dir(path))
	fmt.Println("Base:", filepath.Base(path))
	fmt.Println("Ext:", filepath.Ext(path))
	
	// Join path aman lintas OS
	newPath := filepath.Join("home", "user", "file.txt")
	fmt.Println("Joined Path:", newPath)
}

Package io

Package io menyediakan fondasi interface utama pengolahan data stream di Go:

• io.Reader: Interface pembaca stream data.
• io.Writer: Interface penulisan stream data.
• io.ReadAll(reader): Membaca seluruh sisa data dari reader hingga EOF.

package main

import (
	"fmt"
	"io"
	"strings"
)

func main() {
	// strings.Reader mengimplementasikan io.Reader
	reader := strings.NewReader("Belajar io.Reader di Golang Standard Library")

	// Membaca seluruh data reader
	bytes, _ := io.ReadAll(reader)
	fmt.Println("Hasil ReadAll:", string(bytes))
}

Package bufio (Buffered I/O)

Package bufio membungkus io.Reader atau io.Writer dengan memori **buffer** sehingga mengurangi jumlah panggilan sistem I/O (System Calls) ke disk/network.

package main

import (
	"bufio"
	"fmt"

	"strings"
)

func main() {
	input := "Baris Pertama
Baris Kedua
Baris Ketiga"
	scanner := bufio.NewScanner(strings.NewReader(input))

	// Membaca teks baris demi baris secara efisien
	for scanner.Scan() {
		fmt.Println("Line Scanned:", scanner.Text())
	}
}

File Manipulation di Go

Mekanisme pengolahan file fisik di disk menggunakan kombinasi package os dan io.

• os.WriteFile("file.txt", data, 0666): Menulis file baru sekaligus.
• os.ReadFile("file.txt"): Membaca seluruh isi file sekaligus.
• os.OpenFile("file.txt", os.O_APPEND, 0666): Membuka file untuk menambah isi (append mode).

package main

import (
	"fmt"
	"os"
)

func createAndReadFile() error {
	// Menulis file
	message := []byte("Hello Golang File Manipulation!")
	err := os.WriteFile("sample.txt", message, 0666)
	if err != nil {
		return err
	}

	// Membaca file
	data, err := os.ReadFile("sample.txt")
	if err != nil {
		return err
	}

	fmt.Println("Isi File sample.txt:", string(data))
	return nil
}

func main() {
	createAndReadFile()
}

Package Penting Lainnya di Standard Library:

• net/http: HTTP Web Client dan HTTP Web Server bawaan Go.
• sync: Sinkronisasi Goroutine (WaitGroup, Mutex, Once).
• context: Pembawa sinyal pembatalan & deadline request.
• database/sql: Abstraksi driver database SQL resmi.
• crypto: Algoritma kriptografi & enkripsi (AES, SHA256, RSA).

package main

import "fmt"

func main() {
	fmt.Println("Package Lanjutan Standard Library:")
	fmt.Println("1. net/http (Web Server & REST API)")
	fmt.Println("2. sync & context (Concurrency Management)")
	fmt.Println("3. database/sql (Database ORM & Driver)")
}

Selamat! Anda Telah Menguasai 74 Bab Golang! 🎓🎉

Dengan menguasai Golang Dasar (52 Bab) dan Golang Standard Library (22 Bab), Anda kini siap melangkah ke topik tingkat lanjut!

package main

import "fmt"

func main() {
	fmt.Println("==========================================================")
	fmt.Println(" SELAMAT! ANDA TELAH MENYELESAIKAN 74 BAB TUTORIAL GOLANG ")
	fmt.Println("==========================================================")
	fmt.Println("Siap Melanjutkan ke Golang Concurrency & Web Backend!")
}