Golang – Parameter & Return Value

 

Ketika kamu mulai mempelajari Golang, salah satu konsep yang paling sering ditemui adalah fungsi. Tapi fungsi itu tidak hidup sendirian, dia butuh parameter untuk bekerja, dan sering kali mengembalikan sesuatu melalui return value. Tanpa dua hal ini, fungsi akan menjadi seperti tukang pijat tanpa pelanggan: ada niat, tapi tidak ada yang dikerjakan.

Dalam artikel ini, kita akan membahas dengan santai dan lengkap tentang parameter, return value, cara penulisannya, kelebihan Golang dengan multiple return value, fungsi variadic, hingga best-practice. 

 

Apa Itu Parameter?

Parameter adalah data masuk ke sebuah fungsi. Ketika fungsi dipanggil, kamu memberikan nilai tertentu, dan nilai itu digunakan untuk diproses di dalam fungsi.

Analoginya seperti kamu menyerahkan baju kotor ke laundry.
Parameter = baju yang kamu kasih.
Fungsi = proses laundry-nya.
Return value = baju yang sudah bersih.

Contoh paling sederhana:

func sapa(nama string) {
    fmt.Println("Halo", nama)
}

Parameter di sini adalah:

• nama → nama variabel parameternya

• string → tipe datanya

Pemanggilan:

sapa("Budi")

Output:

Halo Budi

Cara Menulis Parameter yang Benar di Golang

1. Parameter dengan tipe yang sama

Kalau dua parameter punya tipe sama, kamu boleh menyingkat penulisannya:

func tambah(a, b int) int {
    return a + b
}

Ini sama artinya dengan:

func tambah(a int, b int) int

Lebih pendek → lebih bahagia.

2. Parameter Beda Tipe

Kalau beda tipe, ya ditulis satu-satu:

func info(nama string, umur int) {
    fmt.Println(nama, "berumur", umur)
}

Apa Itu Return Value?

Return value adalah hasil yang dikeluarkan oleh fungsi setelah ia selesai melakukan tugasnya.

Ibarat kamu order martabak:
Orderan → parameter
Proses bikin martabak → isi fungsi
Martabak matang → return value

Contoh sederhana:

func luasPersegi(sisi int) int {
    return sisi * sisi
}

Pemanggilan:

hasil := luasPersegi(5)
fmt.Println(hasil)

Output:

25 

Return Lebih dari Satu Nilai (Multiple Return Value)

Fitur ini bikin bahasa lain kadang iri.

Di Golang, fungsi boleh mengembalikan lebih dari satu nilai. Ini berguna banget ketika kamu ingin mengembalikan data + error, atau dua hasil perhitungan sekaligus.

Contoh:

func hitung(a int, b int) (int, int) {
    jumlah := a + b
    selisih := a - b
    return jumlah, selisih
}

Pemanggilan:

j, s := hitung(10, 3)
fmt.Println("Jumlah:", j)
fmt.Println("Selisih:", s)

Output:

Jumlah: 13
Selisih: 7

Kenapa ini penting?

Karena di Golang, konsep error handling menggunakan teknik:

hasil, err := someFunction()
if err != nil {
    // tangani error
}

Multiple return adalah hal wajib kalau ingin menjadi Gopher sejati.

 

Named Return Value (Return Bernama)

Golang memperbolehkan return value diberi nama.
Ini cocok kalau fungsi kamu agak panjang.

Contoh:

func volumeKubus(sisi int) (hasil int) {
    hasil = sisi * sisi * sisi
    return
}

Kelebihan:

• Kode bisa lebih rapi

• Tidak perlu menuliskan nilai return di akhir (cukup return saja)

Tapi gunakan dengan bijak kalau berlebihan justru bikin bingung.

 

Fungsi Dengan Banyak Parameter

Terlalu banyak parameter itu sebenarnya tanda bahwa ada sesuatu yang perlu dipikirkan ulang.
Tapi kadang tetap perlu.

Contoh:

func biodata(nama string, umur int, kota string, aktif bool) {
    fmt.Println(nama, umur, kota, aktif)
}

Tapi jika lebih dari 4 parameter, biasanya lebih baik pakai struct.

 

Variadic Parameter — Parameter Tak Terbatas

Kalau kamu mau membuat fungsi yang menerima parameter sebanyak apa pun, gunakan variadic:

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

Pemanggilan:

fmt.Println(jumlahkan(1, 2, 3))
fmt.Println(jumlahkan(10, 20, 30, 40, 50))

Output:

6
150

Variadic parameter hanya boleh ada satu dan harus berada di akhir daftar parameter.

 

Parameter Fungsi yang Menggunakan Fungsi Lain

Golang memperlakukan fungsi sebagai first-class citizen.
Artinya, fungsi bisa:

• dikirim sebagai parameter

• disimpan dalam variabel

• dikembalikan sebagai nilai

Contoh:

func proses(x int, f func(int) int) int {
    return f(x)
}

func kaliDua(a int) int {
    return a * 2
}

fmt.Println(proses(5, kaliDua))

Output:

10

Ini berguna untuk callback, middleware, router, dan banyak pola lainnya.

 

Passing by Value vs Passing by Reference

Golang = pass by value (secara default)

Artinya ketika kamu mengirim parameter:

• nilai asli TIDAK berubah

• fungsi hanya menerima copy nilai tersebut

Contoh:

func ubah(a int) {
    a = 100
}

x := 5
ubah(x)
fmt.Println(x)

Output:

5

Nilai x tidak berubah.

Kalau mau mengubah nilai asli → pakai pointer

func ubah(a *int) {
    *a = 100
}

x := 5
ubah(&x)
fmt.Println(x)

Output:

100

Simple tapi powerful.

 

Contoh Lengkap Menggabungkan Semua Konsep

package main

import "fmt"

func sapa(nama string) {
    fmt.Println("Halo", nama)
}

func tambah(a, b int) int {
    return a + b
}

func bagi(a, b int) (int, error) {
    if b == 0 {
        return 0, fmt.Errorf("pembagian dengan nol")
    }
    return a / b, nil
}

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

func proses(x int, f func(int) int) int {
    return f(x)
}

func main() {
    sapa("Doni")

    fmt.Println("Tambah 3 + 4 =", tambah(3, 4))

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

    fmt.Println("Total:", total(1, 2, 3, 4, 5))

    fmt.Println("Proses kali dua:", proses(6, func(i int) int {
        return i * 2
    }))
}

Program di atas mencakup:

• parameter biasa

• return value

• multiple return value (dengan error)

• variadic

• fungsi sebagai parameter

• anonim function

Komplit!

 

Kesimpulan

Parameter dan return value adalah dua konsep fundamental dalam Golang.
Dengan memahami keduanya, kamu bisa:

• membuat fungsi yang fleksibel

• mengolah data secara terstruktur

• memisahkan logika menjadi bagian-bagian kecil

• mengurangi duplikasi kode

• menulis program yang profesional dan mudah dirawat

Intinya: parameter adalah bahan baku, return value adalah hasil masakannya.

Kalau kamu sudah paham dua hal ini, kamu sudah melewati salah satu gerbang penting untuk jadi programmer Go yang matang.