5 Syntax Dasar Golang yang Wajib Anda Ketahui

aris egi saputra -

Menguasai Fondasi: 5 Syntax Dasar Golang yang Wajib Anda Ketahui

Setelah berhasil menyiapkan lingkungan pengembangan Golang Anda di artikel sebelumnya, kini saatnya kita benar-benar mulai "berbicara" dalam bahasa Go! Seperti mempelajari bahasa manusia, langkah pertama adalah memahami kosakata dan tata bahasa dasarnya. Dalam pemrograman, ini berarti menguasai syntax golang fundamental. Jangan khawatir jika Anda baru memulai, karena Go dirancang dengan kesederhanaan dalam pikiran. Artikel ini akan memandu Anda melalui lima pilar syntax dasar yang akan menjadi fondasi kokoh untuk membangun program Go yang lebih kompleks di kemudian hari. Siapkan editor kode Anda, mari kita selami contoh-contoh praktis!

1. Paket (Packages), Variabel (Variables), dan Fungsi (Functions): Tiga Serangkai Awal

Setiap program Go dimulai dengan deklarasi package. Paket main adalah paket spesial yang menandakan bahwa program ini dapat dieksekusi. Untuk menggunakan fungsionalitas dari paket lain (baik itu paket standar Go atau paket eksternal), kita menggunakan statement import. Contoh paling umum adalah mengimpor paket fmt yang menyediakan fungsi untuk input/output terformat, seperti mencetak ke konsol.

Selanjutnya adalah variabel golang. Variabel digunakan untuk menyimpan data. Go adalah bahasa yang diketik secara statis, artinya tipe data setiap variabel harus diketahui saat kompilasi. Anda bisa mendeklarasikan variabel menggunakan kata kunci var, diikuti nama variabel, tipe data, dan opsional nilai awal. Cara yang lebih singkat dan sering digunakan di dalam fungsi adalah menggunakan operator := (short variable declaration), di mana Go akan otomatis menyimpulkan tipe datanya.

Terakhir, ada fungsi. Fungsi adalah blok kode yang melakukan tugas tertentu. Fungsi main dalam paket main adalah titik masuk (entry point) eksekusi program Anda. Struktur dasar fungsi dimulai dengan kata kunci func, diikuti nama fungsi, daftar parameter dalam tanda kurung, tipe data kembalian (jika ada), dan badan fungsi dalam kurung kurawal {}.

Mari lihat contoh yang menggabungkan ketiganya:

package main // Deklarasi paket

import "fmt" // Mengimpor paket fmt

// Fungsi utama, titik masuk program
func main() {
    // Deklarasi variabel menggunakan 'var'
    var greeting string
    greeting = "Halo, para pembelajar Go!"

    // Deklarasi variabel menggunakan ':='
    day := "Jumat"
    number := 23

    // Mencetak variabel ke konsol menggunakan fungsi Println dari paket fmt
    fmt.Println(greeting)
    fmt.Println("Hari ini hari", day)
    fmt.Println("Angka favorit:", number)

    // Memanggil fungsi lain
    printSeparator()
    result := add(5, 7)
    fmt.Println("Hasil penjumlahan:", result)
}

// Contoh fungsi sederhana tanpa parameter dan tanpa nilai kembalian
func printSeparator() {
    fmt.Println("--------------------"),
}

// Contoh fungsi dengan parameter dan nilai kembalian
func add(a int, b int) int {
    return a + b
}

2. Mengatur Alur Program: Percabangan dengan if/else

Seringkali, kita ingin program mengambil keputusan berdasarkan kondisi tertentu. Di sinilah statement if/else berperan. Sintaksnya cukup lugas: if diikuti kondisi boolean, lalu blok kode yang akan dieksekusi jika kondisi benar (true). Anda bisa menambahkan blok else if untuk kondisi tambahan atau blok else yang akan dieksekusi jika semua kondisi sebelumnya salah (false).

package main

import "fmt"

func main() {
    score := 75

    if score >= 90 {
        fmt.Println("Nilai: A")
    } else if score >= 80 {
        fmt.Println("Nilai: B")
    } else if score >= 70 {
        fmt.Println("Nilai: C")
    } else {
        fmt.Println("Nilai: D")
        fmt.Println("Perlu belajar lebih giat!")
    }

    // If dengan short statement (deklarasi variabel di dalam kondisi)
    if num := 10; num%2 == 0 {
        fmt.Println(num, "adalah angka genap")
    } else {
        fmt.Println(num, "adalah angka ganjil")
    }
}

3. Melakukan Pengulangan: Mengenal for, Satu-Satunya Loop di Golang

Berbeda dengan bahasa lain yang mungkin memiliki while, do-while, dan for, Golang menyederhanakannya hanya dengan satu kata kunci untuk pengulangan: for. Namun, loop golang ini sangat fleksibel dan bisa digunakan dalam berbagai bentuk:

  • Bentuk klasik (seperti for di C/Java): Memiliki inisialisasi, kondisi, dan post-statement.
  • Bentuk kondisi (seperti while): Hanya menggunakan kondisi boolean.
  • Bentuk tanpa kondisi (infinite loop): Berjalan terus menerus sampai dihentikan secara eksplisit (misalnya dengan break).
  • Bentuk for...range: Cara idiomatik untuk mengiterasi elemen dalam struktur data seperti slice, array, map, atau string.
package main

import "fmt"

func main() {
    // 1. Bentuk klasik
    fmt.Println("Bentuk Klasik:")
    for i := 0; i < 3; i++ {
        fmt.Println("Iterasi ke-", i)
    }
    printSeparator()

    // 2. Bentuk kondisi (mirip while)
    fmt.Println("Bentuk Kondisi:")
    counter := 0
    for counter < 2 {
        fmt.Println("Counter:", counter)
        counter++
    }
    printSeparator()

    // 3. Bentuk for...range (untuk slice)
    fmt.Println("Bentuk for...range (Slice):")
    names := []string{"Andi", "Budi", "Citra"}
    for index, name := range names {
        fmt.Printf("Index: %d, Nama: %s\n", index, name)
    }
    printSeparator()

    // 4. Bentuk for...range (untuk map)
    fmt.Println("Bentuk for...range (Map):")
    capitals := map[string]string{"Indonesia": "Jakarta", "Jepang": "Tokyo"}
    for country, capital := range capitals {
        fmt.Printf("Ibukota %s adalah %s\n", country, capital)
    }
}

func printSeparator() {
    fmt.Println("--------------------"),
}

4. Menyimpan Kumpulan Data: Struktur Data Dasar (Array, Slice, Map)

Selain tipe data dasar seperti angka dan string, kita sering perlu menyimpan kumpulan data. Go menyediakan beberapa struktur data bawaan yang penting:

  • Array: Kumpulan elemen dengan tipe data yang sama dan ukuran tetap (fixed-size). Ukurannya adalah bagian dari tipe array itu sendiri.
  • Slice: Struktur data yang lebih fleksibel dan umum digunakan daripada array. Slice merujuk pada segmen dari array yang mendasarinya dan memiliki ukuran dinamis. Slice lebih sering digunakan dalam kode Go idiomatik.
  • Map: Kumpulan pasangan kunci-nilai (key-value) yang tidak terurut. Kunci harus unik dan memiliki tipe data yang dapat dibandingkan (seperti string, int, float, bool, pointer, struct), sedangkan nilai bisa bertipe apa saja.
package main

import "fmt"

func main() {
    // Array (ukuran tetap 5)
    var numbers [5]int
    numbers[0] = 10
    numbers[4] = 50
    fmt.Println("Array:", numbers)
    fmt.Println("Panjang Array:", len(numbers))

    // Slice (ukuran dinamis)
    // Membuat slice dari array yang ada
    var primes = [6]int{2, 3, 5, 7, 11, 13}
    var s []int = primes[1:4] // Elemen dari index 1 hingga sebelum 4 (index 1, 2, 3)
    fmt.Println("Slice (dari array):", s)

    // Membuat slice menggunakan make
    names := make([]string, 3) // Slice string dengan panjang 3
    names[0] = "Go"
    names[1] = "Is"
    names[2] = "Fun"
    names = append(names, "!") // Menambah elemen ke slice
    fmt.Println("Slice (make & append):", names)
    fmt.Println("Panjang Slice:", len(names), "Kapasitas:", cap(names))

    // Map (key-value)
    studentScores := make(map[string]int)
    studentScores["Alice"] = 95
    studentScores["Bob"] = 80
    fmt.Println("Map Skor Siswa:", studentScores)
    fmt.Println("Skor Bob:", studentScores["Bob"])

    // Mengecek keberadaan key di map
    score, exists := studentScores["Charlie"]
    if exists {
        fmt.Println("Skor Charlie:", score)
    } else {
        fmt.Println("Charlie tidak ditemukan di map.")
    }
}

5. Referensi Memori: Pengantar Singkat tentang Pointer

Pointer mungkin terdengar menakutkan bagi sebagian orang, tetapi di Go, penggunaannya dibuat lebih aman dan sederhana dibandingkan bahasa seperti C/C++. Pointer pada dasarnya adalah variabel yang menyimpan alamat memori dari variabel lain. Mengapa kita membutuhkannya? Alasan utamanya adalah untuk memungkinkan fungsi memodifikasi nilai variabel yang dideklarasikan di luar fungsi tersebut (pass by reference) atau untuk menghindari penyalinan data besar yang tidak perlu saat melewatkan argumen ke fungsi, sehingga lebih efisien.

Operator & digunakan untuk mendapatkan alamat memori suatu variabel, sedangkan operator * (dereference) digunakan untuk mengakses nilai yang disimpan di alamat memori yang ditunjuk oleh pointer.

package main

import "fmt"

// Fungsi ini menerima pointer ke integer
func increment(val *int) {
    // Menggunakan * untuk mengakses nilai dan menambahkannya
    *val++
}

func main() {
    x := 10
    fmt.Println("Nilai x awal:", x)

    // Mendapatkan alamat memori x dan menyimpannya di pointer p
    p := &x

    fmt.Println("Alamat memori x:", p)
    fmt.Println("Nilai yang ditunjuk oleh p:", *p)

    // Memanggil fungsi increment dengan memberikan alamat x
    increment(&x)

    fmt.Println("Nilai x setelah increment:", x)
}

Kesimpulan: Fondasi Telah Diletakkan

Selamat! Anda baru saja mempelajari lima konsep syntax golang paling fundamental: cara kerja paket, variabel, dan fungsi; bagaimana mengontrol alur program dengan if/else; melakukan pengulangan menggunakan loop golang for yang serbaguna; menyimpan kumpulan data dengan array, slice, dan map; serta pengantar singkat tentang pointer. Ini adalah blok bangunan penting yang akan terus Anda gunakan sepanjang perjalanan belajar Go Anda.

Jangan berhenti di sini! Cara terbaik untuk memperkuat pemahaman adalah dengan berlatih. Coba modifikasi contoh kode di atas, buat program sederhana Anda sendiri, dan jangan takut untuk bereksperimen. Di artikel selanjutnya, kita akan membahas topik penting lainnya: bagaimana mengelola dependensi atau paket eksternal dalam proyek Go Anda menggunakan Go Modules.

Internal Link: Kembali ke panduan instalasi Golang