Golang – Deklarasi dan Pemanggilan Fungsi

 

Fungsi adalah salah satu fondasi utama dalam setiap bahasa pemrograman. Tanpa fungsi, kode akan seperti film tanpa adegan berpindah: membosankan, berantakan, dan bikin kita ingin pulang sebelum selesai. Di Golang, fungsi bahkan bisa jadi salah satu alasan kenapa banyak developer betah berkutat karena sintaksnya sederhana, tapi kemampuan dan fleksibilitasnya luar biasa.

Pada artikel ini, kita akan membahas apa itu fungsi, cara mendeklarasikan fungsi, cara memanggil fungsi, return value, fungsi dengan banyak nilai kembali, fungsi variadic, fungsi sebagai parameter, hingga anonymous function, dengan gaya santai-lucu dan tetap berbobot.

Langsung saja kita mulai perjalanan ini!

 

Apa Itu Fungsi?

Secara sederhana:
Fungsi adalah sebuah blok kode yang bisa dipakai ulang, dilakukan saat diminta, dan biasanya berperan menyelesaikan satu tugas tertentu.

Analogi gampangnya:
Fungsi itu kayak tukang bakso langganan. Kamu panggil → dia kerja → dia kasih hasil.
Bedanya, fungsi tidak libur dan tidak pulang kampung waktu lebaran.

 

Deklarasi Fungsi di Golang

Format dasar deklarasi fungsi di Go seperti ini:

func namaFungsi(parameter) tipeKembalian {
    // isi fungsi
}

Tiga hal penting:

1. func → kata kunci untuk mendefinisikan fungsi.

2. namaFungsi → huruf kecil = private, huruf besar = public (exported).

3. parameter dan return → opsional, tapi sering dipakai.

Mari kita lihat contoh paling standar:

func sapa() {
    fmt.Println("Halo! Ini fungsi tanpa parameter.")
}

Fungsi di atas tidak punya parameter dan tidak mengembalikan nilai. Sederhana, tapi efektif.

 

Memanggil Fungsi

Untuk memanggil fungsi dalam Golang, caranya mudah sekali:

sapa()

Sama seperti memanggil teman dari jauh, tapi teman ini pasti datang.

 

Fungsi Dengan Parameter

Parameter memungkinkan kita mengirim data ke fungsi agar bisa diproses.

Contoh:

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

Pemanggilan:

halo("Budi")

Output:

Halo, Budi

Simpel, rapi, dan tidak ribut.

 

Fungsi Dengan Return Value

Tidak semua fungsi hanya menyapa. Fungsi kadang perlu mengembalikan hasil.

Formatnya:

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

Pemanggilan:

hasil := tambah(3, 4)
fmt.Println("Hasil:", hasil)

Output:

Hasil: 7

Multiple Return Value (Go Punya, Bahasa Lain Iri)

Golang punya fitur keren: fungsi bisa mengembalikan lebih dari satu nilai!

Contoh:

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

Pemanggilan:

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

Output:

Jumlah: 13
Selisih: 7

Beberapa bahasa lain harus pakai array, object, tuple khusus, atau doa-doa tertentu.
Go? Tinggal tulis dua angka di return.

 

Named Return Value

Go juga punya fitur named return, semacam “mengisi label dulu baru direturn”.

Contoh:

func luasPersegi(sisi float64) (luas float64) {
    luas = sisi * sisi
    return
}

Perhatikan:

• Nilai luas otomatis direturn karena sudah diberi nama.

• Tidak wajib tapi bisa membuat kode lebih rapi kalau dipakai dengan bijak.

   

Fungsi Variadic (Parameter Tak Terbatas)

Pernah ingin membuat fungsi yang menerima banyak sekali nilai, tanpa batas?
Misalnya fungsi jumlah total angka:

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

Pemanggilan:

fmt.Println(total(1, 2, 3))
fmt.Println(total(5, 10, 15, 20))

Output:

6
50

Huruf ... artinya parameter tersebut boleh diisi sebanyak apa pun, bahkan nol.

 

Anonymous Function

Golang juga mendukung fungsi tanpa nama.

Contoh:

func() {
    fmt.Println("Ini anonymous function")
}()

Dipanggil langsung dengan tanda () di belakang.

Atau disimpan ke variabel:

say := func(nama string) {
    fmt.Println("Halo", nama)
}
say("Mahmud") 

Fungsi Sebagai Parameter

Golang mendukung konsep function as first-class citizen.
Artinya fungsi bisa dikirim sebagai parameter.

Contoh:

func prosesAngka(angka int, f func(int) int) int {
    return f(angka)
}

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

hasil := prosesAngka(5, kaliDua)
fmt.Println(hasil)

Output:

10

Ini sangat berguna dalam:

• callback

• middleware

• sistem event

• custom logic

   

Fungsi Rekursif

Fungsi yang memanggil dirinya sendiri.
Contoh klasik: faktorial.

func faktorial(n int) int {
    if n == 1 {
        return 1
    }
    return n * faktorial(n-1)
}

Meskipun indah, gunakan rekursi dengan hati-hati.
Stack overflow itu nyata.

 

Fungsi di Dalam Package

Di Golang, nama fungsi public dimulai dengan huruf besar.

File: mathku/mathku.go

package mathku

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

Pemanggilan di file lain:

import "mathku"

hasil := mathku.Tambah(2, 3)
fmt.Println(hasil)

Best Practice Dalam Menggunakan Fungsi

Untuk memastikan kode kamu bukan horor bagi programmer lain:

✔ Buat fungsi dengan satu tujuan

Fungsi yang melakukan 7 hal sekaligus = mimpi buruk debugging.

✔ Gunakan nama yang jelas

hitungLuas(), bukan hl().

✔ Hindari parameter terlalu banyak

Jika lebih dari 4, pakai struct.

✔ Return value sebaiknya jelas maknanya

Kalau perlu, gunakan named return.

✔ Hindari over-engineering

Tidak semua harus anonymous function, higher-order function, dsb.

 

Contoh Proyek Mini: Fungsi Lengkap

Berikut gabungan berbagai konsep:

package main

import "fmt"

// fungsi biasa
func salam(nama string) {
    fmt.Println("Halo", nama)
}

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

// fungsi variadic
func total(angka ...int) int {
    sum := 0
    for _, v := range angka {
        sum += v
    }
    return sum
}

// fungsi sebagai parameter
func operasi(a int, f func(int) int) int {
    return f(a)
}

func main() {
    salam("Doni")

    fmt.Println("Tambah:", tambah(3, 4))

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

    hasil := operasi(10, func(x int) int {
        return x * x
    })

    fmt.Println("Kuadrat:", hasil)
}

Output:

Halo Doni
Tambah: 7
Total: 15
Kuadrat: 100

Semua konsep berkumpul dalam satu program kecil namun jelas.

 

Fungsi adalah jantung dari setiap program Golang. Dengan memahami:

• cara deklarasi fungsi

• cara pemanggilan

• parameter

• return value

• multiple returns

• variadic function

• anonymous function

• fungsi sebagai parameter

• best practice

…maka kamu sudah punya bekal kuat untuk menulis program yang efisien dan enak dibaca.

Fungsi membantu menyederhanakan kode, menjaga struktur, dan membuat proyek scalable. Tanpa fungsi, dunia pemrograman akan jadi tempat yang gelap… seperti debug tanpa log.