Go From Zero to Hero #13: Mengenal Prosedur (Procedure) di Go dan Rahasia Parameter Pointer

Halo Go Developers! Selamat datang kembali di seri Go From Zero to Hero.

Di artikel kedua belas kemarin, kita sudah berhasil membongkar misteri terbesar di Alpro 2, yaitu Pointer. Kita sudah belajar bagaimana cara melihat alamat memori menggunakan operator & dan mengintip nilainya menggunakan operator *. Pemahaman RAM ini akan jadi senjata rahasia kita hari ini!

Bicara soal memecah kode program, di artikel 11 kita sudah berkenalan dengan Fungsi (Function). Nah, kalau kamu perhatikan modul praktikum kuliah atau buku-buku algoritma, pasti ada satu istilah lagi yang selalu bersanding dengan fungsi: Prosedur (Procedure).

Banyak pemula yang bingung, “Bang, di Go-lang kan sama-sama ditulis pakai kata kunci func, lalu apa bedanya Fungsi sama Prosedur?”

Nah, di artikel ketiga belas ini, kita akan kupas tuntas apa perbedaan nyata antara keduanya secara konsep, kapan harus pakai prosedur, dan bagaimana cara memanfaatkan Pointer untuk membuat prosedur yang bertenaga.

Yuk, buka laptopmu, siapkan compiler Go-mu, dan mari kita mulai!

Perbedaan Mendasar: Fungsi vs Prosedur

Secara konsep dasar algoritma, perbedaan fungsi dan prosedur itu sebenarnya sangat simpel dan bisa dilihat dari tujuan akhir tugasnya:

• Fungsi (Function): Bertugas menghitung atau memproses sesuatu, lalu mengembalikan (return) nilai ke pemanggilnya. Fokusnya adalah menghasilkan data baru.
• Prosedur (Procedure): Bertugas melakukan serangkaian aksi atau tugas (seperti mencetak teks, mengubah status, menyusun data) TANPA mengembalikan nilai apa pun.

Kalau diibaratkan dunia nyata, Fungsi itu seperti kalkulator (kamu pencet 5 + 5, dia mengembalikan angka 10). Sedangkan Prosedur itu seperti tombol print di printer (kamu pencet, dia melakukan aksi mencetak kertas, tapi tidak memberikan data balik ke tanganmu).

Di Go-lang, karena tidak ada keyword khusus bernama procedure, maka prosedur dirancang dengan cara membuat func yang tidak menuliskan tipe data kembalian di deklarasinya.

1. Menulis Prosedur Paling Dasar di Go

Mari kita lihat bentuk visual dari sebuah prosedur di Go-lang yang hanya bertugas melakukan aksi mencetak informasi ke terminal:

package main

import "fmt"

// Ini adalah PROSEDUR karena tidak ada tipe data kembalian setelah tanda kurung ()
func cetakMenuUtama() {
    fmt.Println("=== APLIKASI KASIR KAMPUS ===")
    fmt.Println("1. Lihat Daftar Menu")
    fmt.Println("2. Tambah Pesanan Baru")
    fmt.Println("3. Hitung Total & Bayar")
    fmt.Println("4. Keluar Aplikasi")
    fmt.Println("=============================")
}

func main() {
    // Memanggil prosedur cukup sebut namanya saja
    cetakMenuUtama()
}

Perhatikan baris func cetakMenuUtama(). Di sana tidak ada kata kunci return dan tidak ada tipe data seperti int atau string di ujungnya. Program hanya masuk, mengeksekusi perintah cetak, lalu keluar.

2. Prosedur dengan Parameter (Aksi Dinamis)

Sama seperti fungsi, prosedur juga bisa menerima input data (parameter) agar aksi yang dilakukan di dalamnya bisa lebih dinamis dan fleksibel.

package main

import "fmt"

// Prosedur ini menerima input nama dan nilai UTS, lalu mencetak statusnya
func cetakStatusKelulusan(nama string, nilai int) {
    fmt.Printf("Mahasiswa bernama %s mendapatkan nilai: %d\n", nama, nilai)
    
    if nilai >= 75 {
        fmt.Println("Status: LULUS MURNI")
    } else {
        fmt.Println("Status: SILAHKAN MENGIKUTI REMIDI")
    }
    fmt.Println("-----------------------------------")
}

func main() {
    // Memanggil prosedur dengan argumen berbeda
    cetakStatusKelulusan("Siti", 85)
    cetakStatusKelulusan("Budi", 60)
}

3. Rahasia Prosedur Kelas Kakap: Mengubah Data lewat Pointer

Di dunia perkuliahan Alpro 2, tantangan terbesar menggunakan prosedur adalah ketika kamu diminta membuat prosedur yang bisa mengubah nilai variabel asli di luar prosedur.

Ingat pelajaran artikel 12? Go-lang itu Pass by Value (mengirimkan fotokopi data). Jadi kalau kita buat prosedur biasa seperti ini:

func resetNilai(n int) {
    n = 0 // Cuma mengubah salinannya!
}

Variabel aslimu di main tidak akan pernah berubah. Nah, solusinya adalah dengan mengirimkan Pointer sebagai parameternya (Pass by Reference)!

Mari kita lihat contoh implementasi prosedur penambah tabungan berikut ini:

package main

import "fmt"

// Prosedur ini menerima parameter berbentuk POINTER (*int)
func tambahSaldo(saldo *int, jumlahSetoran int) {
    // Kita ketuk alamat memorinya (*), lalu tambahkan nilainya langsung di RAM
    *saldo = *saldo + jumlahSetoran
}

func main() {
    dompetKu := 50000
    fmt.Println("Saldo Awal Dompet:", dompetKu) // Output: 50000

    // Kita panggil prosedur dengan mengirimkan ALAMAT MEMORI (&) dari dompetKu
    tambahSaldo(&dompetKu, 25000)

    // Cek apakah dompetKu aslinya ikut bertambah?
    fmt.Println("Saldo Akhir Dompet:", dompetKu) // Output: 75000 (Berhasil berubah!)
}

Dengan mengombinasikan Prosedur + Parameter Pointer, kamu bisa memanipulasi data program dalam skala besar dengan sangat efisien tanpa perlu repot menggunakan perintah return.

Kesimpulan & Penutup

Selamat, Fondasi Modular-mu Sudah Lengkap! 🧠

Sekarang kamu sudah tahu rahasianya: Fungsi dipakai saat kamu butuh kembalian angka atau data baru, sedangkan Prosedur dipakai saat kamu hanya ingin program melakukan sebuah aksi (action). Ditambah dengan ilmu Pointer kemarin, kamu kini bisa membuat fungsi dan prosedur yang jauh lebih efisien dalam mengelola memori laptopmu!

Yuk, Nyicip Eksperimen Kecil! 🛠️

Coba buat sebuah prosedur bernama hitungDiskon yang menerima dua parameter: totalBelanja (int) dan sudahMember (bool). Jika sudahMember bernilai true, cetak kalimat “Mendapatkan diskon 10%!”, jika false cetak “Tidak ada diskon”.

🎯 Tantangan Untukmu (Challenge!)

Buatlah sebuah program Go dengan prosedur bernama kalkulatorBonus yang menerima dua parameter: jumlahPenjualan *int dan performa string.

Jika performa bernilai “BAGUS”, naikkan nilai di dalam jumlahPenjualan sebanyak 500.

Jika performa bernilai “SANGAT BAGUS”, naikkan sebanyak 1000.

Tulis kode hasil tantanganmu di kolom komentar di bawah agar bisa kita review bareng-bareng!

Bocoran Artikel Selanjutnya 🚀

Setelah menguasai Fungsi, Pointer, dan Prosedur, kita sudah resmi menyelesaikan bab pemrograman modular dasar. Di artikel berikutnya, kita akan melompat ke konsep perulangan tingkat tinggi yang sangat legendaris dan estetis di mata para dosen: Berpikir Khas Programmer dengan Logika Perulangan Rekursif di Go.

Kita akan belajar bagaimana sebuah fungsi atau prosedur bisa memanggil dirinya sendiri untuk memecahkan masalah matematika yang rumit! Sampai jumpa di Go From Zero to Hero #14, tetap semangat, dan happy coding!