Memahami Basic Syntax di Go (Golang) untuk Pemula

Go (atau Golang) kian populer karena kesederhanaan, kecepatan, dan performanya yang tangguh untuk sistem backend. Dikembangkan oleh Google, bahasa ini dirancang untuk menyelesaikan masalah skalabilitas dengan sintaks yang bersih dan tidak bertele-tele.

Jika Anda baru memulai perjalanan Anda dengan Go, memahami sintaks dasarnya adalah langkah krusial. Berikut adalah panduan inti elemen-elemen fundamental Go.

1. Struktur Dasar: “Hello World”

Setiap program Go yang dapat dieksekusi harus memiliki struktur dasar paket dan fungsi utama.

package main // 1. Definisi Package

import "fmt" // 2. Import Library

func main() { // 3. Fungsi Main (Entry Point)
    fmt.Println("Hello, World!")
}

• Package main: Memberi tahu kompilator bahwa ini adalah program yang dapat dieksekusi, bukan shared library.
• Import: Memanggil paket standar Go. fmt digunakan untuk formatting I/O (input/output).
• Func main: Tempat eksekusi program dimulai.

2. Variabel dan Tipe Data

Go adalah bahasa statically typed, artinya tipe data variabel dicek saat kompilasi. Namun, Go memiliki fitur canggih bernama Type Inference.

Deklarasi Variabel

Ada dua cara umum untuk membuat variabel:

Cara 1: Deklarasi Eksplisit

Digunakan ketika Anda ingin menentukan tipe data secara manual atau mendeklarasikan tanpa nilai awal.

var nama string = "Budi"
var umur int = 25

Cara 2: Short Variable Declaration (:=)

Ini adalah cara paling umum di dalam fungsi. Go akan otomatis menebak tipe datanya.

negara := "Indonesia" // Go tahu ini String
skor := 95.5          // Go tahu ini Float64

Catatan: Di Go, jika Anda mendeklarasikan variabel tetapi tidak menggunakannya, program akan error (gagal kompilasi). Ini memaksa kode tetap bersih.

3. Fungsi (Functions)

Fungsi di Go memiliki keunikan dibandingkan bahasa seperti C atau Java: fungsi bisa mengembalikan banyak nilai (multiple return values).

func hitung(a int, b int) (int, int) {
    tambah := a + b
    kurang := a - b
    return tambah, kurang
}

func main() {
    hasilTambah, hasilKurang := hitung(10, 5)
    fmt.Println(hasilTambah, hasilKurang) // Output: 15 5
}

4. Kontrol Alur (Flow Control)

Sintaks kontrol alur di Go sangat minimalis. Tidak perlu tanda kurung ( ) di sekitar kondisi.

nilai := 80

if nilai >= 75 {
    fmt.Println("Lulus")
} else {
    fmt.Println("Remidial")
}

Loops (Hanya for)

Go tidak memiliki while atau do-while. Semua perulangan menggunakan for.

Sebagai for loop standar:

for i := 0; i < 5; i++ {
    fmt.Println(i)
}

Sebagai while loop:

counter := 0
for counter < 5 {
    fmt.Println(counter)
    counter++
}

5. Array dan Slices

Ini adalah bagian yang sering membingungkan pemula.

• Array: Ukurannya tetap (fixed). Jarang digunakan secara langsung.
• Slice: Ukurannya dinamis. Ini yang paling sering digunakan.

// Array (Ukuran tetap 3)
var arr [3]int = [3]int{1, 2, 3}

// Slice (Ukuran dinamis, tidak perlu menulis angka di kurung siku)
hobi := []string{"Coding", "Gaming", "Reading"}

// Menambah data ke Slice
hobi = append(hobi, "Cycling")

6. Structs (Pengganti Class)

Go bukan bahasa Object-Oriented murni (tidak ada class atau inheritance), tetapi menggunakan Struct untuk mengelompokkan data.

type User struct {
    Nama  string
    Email string
    Umur  int
}

func main() {
    user1 := User{
        Nama:  "Andi",
        Email: "andi@mail.com",
        Umur:  30,
    }
    
    fmt.Println(user1.Nama)
}

7. Error Handling

Go tidak menggunakan try-catch. Error diperlakukan sebagai nilai (value) yang dikembalikan oleh fungsi.

import ("errors"; "fmt")

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

func main() {
    hasil, err := bagi(10, 0)
    
    if err != nil {
        fmt.Println("Error:", err)
    } else {
        fmt.Println("Hasil:", hasil)
    }
}

Pola if err != nil akan sangat sering Anda temui dalam kode Go.

Sintaks Go dirancang agar mudah dibaca dan dipelihara. Dengan menghilangkan kompleksitas seperti inheritance yang rumit atau banyak jenis loop, developer bisa fokus pada logika program.

Mulailah dengan mencoba kode-kode di atas. Konsistensi adalah kunci dalam mempelajari bahasa baru. Selamat mengoding!