Fungsi di Golang: Mendeklarasikan, Memanggil, dan Mengirim Fungsi

Mendeklarasikan fungsi

Deklarasi fungsi terdiri dari func, sebuah nama, parameter, tipe hasil, dan badan fungsi. Tipe ditulis setelah nama parameter, bukan sebelumnya.

package main

import "fmt"

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

func greet(name string) {
	fmt.Println("Hello,", name)
}

func main() {
	sum := add(3, 4)
	fmt.Println(sum)
	greet("Gopher")
}

add menerima dua nilai int dan mengembalikan int. greet tidak mengembalikan apa pun, jadi signature-nya tidak punya tipe hasil dan badannya tidak butuh return.

Fungsi yang mendeklarasikan hasil harus diakhiri dengan pernyataan penutup. Kalau ada jalur yang bisa mencapai kurung kurawal penutup tanpa return, compiler berhenti dengan missing return.

Parameter dengan tipe yang sama

Parameter berurutan yang tipenya sama bisa memakai satu nama tipe bersama. func add(a, b int) int artinya persis sama dengan func add(a int, b int) int. Mencampur keduanya juga boleh:

func scale(x, y float64, factor int) (float64, float64)

Di sini x dan y bertipe float64, sedangkan factor bertipe int.

Nilai kembalian

Sebuah fungsi bisa mengembalikan nol, satu, atau beberapa nilai. Beberapa hasil ditulis di dalam tanda kurung, dan pemanggil menerimanya dengan multiple assignment:

package main

import "fmt"

func divmod(a, b int) (int, int) {
	return a / b, a % b
}

func main() {
	q, r := divmod(17, 5)
	fmt.Println(q, r)
}

Program ini mencetak 3 2. Pasangan (value, error) adalah pemakaian fitur ini yang paling umum di Go, dan punya halamannya sendiri tentang multiple return value.

Argumen disalin

Go mengirim setiap argumen sebagai nilai. Fungsi bekerja pada salinannya, jadi meng-assign nilai ke parameter tidak pernah mengubah variabel milik pemanggil.

package main

import "fmt"

type Point struct{ X, Y int }

func moveCopy(p Point) {
	p.X = 100
}

func movePtr(p *Point) {
	p.X = 100
}

func fillFirst(s []int) {
	s[0] = 99
}

func main() {
	p := Point{1, 2}
	moveCopy(p)
	fmt.Println(p) // unchanged

	movePtr(&p)
	fmt.Println(p) // changed through the pointer

	nums := []int{1, 2, 3}
	fillFirst(nums)
	fmt.Println(nums) // the slice header was copied, the elements were not
}

Output-nya:

{1 2}
{100 2}
[99 2 3]

Baris ketiga sering mengejutkan orang. Nilai slice adalah header kecil (pointer, panjang, kapasitas). Salinannya menunjuk ke array yang sama di baliknya, jadi menulis s[0] berarti menulis ke elemen milik pemanggil. Tetapi append di dalam fungsi bisa mengalokasikan array baru, dan pemanggil tidak pernah melihat header baru itu. Kalau sebuah fungsi menambah isi slice, kembalikan slice yang baru. Logika yang sama berlaku untuk map: fungsi bisa menambahkan key yang terlihat oleh pemanggil, karena nilai map merujuk ke data bersama.

Pakai parameter pointer saat fungsi harus mengubah variabel milik pemanggil, atau saat nilainya berupa struct besar yang tidak ingin kamu salin di setiap pemanggilan.

Fungsi adalah nilai

Fungsi punya tipe, yang ditulis tanpa nama: func(int, int) int. Kamu bisa menyimpan fungsi di variabel, memasukkannya ke map atau slice, dan mengirimnya ke fungsi lain.

package main

import (
	"fmt"
	"strings"
)

func apply(xs []int, f func(int) int) []int {
	out := make([]int, 0, len(xs))
	for _, x := range xs {
		out = append(out, f(x))
	}
	return out
}

func double(n int) int { return n * 2 }

func main() {
	fmt.Println(apply([]int{1, 2, 3}, double))

	square := func(n int) int { return n * n }
	fmt.Println(apply([]int{1, 2, 3}, square))

	ops := map[string]func(string) string{
		"upper": strings.ToUpper,
		"lower": strings.ToLower,
	}
	fmt.Println(ops["upper"]("go"), ops["lower"]("GO"))
}

square adalah fungsi anonim yang di-assign ke sebuah variabel. Fungsi anonim juga bisa membaca dan mengubah variabel dari scope di sekitarnya, dan itulah yang membuatnya menjadi closure.

Tipe fungsi bernama membuat signature lebih mudah dibaca saat bentuk yang sama muncul di banyak tempat:

type Transform func(int) int

func apply(xs []int, f Transform) []int

Zero value dari tipe fungsi adalah nil. Memanggil fungsi nil akan panic dengan invalid memory address or nil pointer dereference, jadi periksa callback opsional sebelum memanggilnya. Nilai fungsi hanya bisa dibandingkan dengan nil, tidak pernah dengan sesamanya.

Rekursi

Fungsi bisa memanggil dirinya sendiri. Go tidak punya optimasi tail call, tetapi stack goroutine bertambah sesuai kebutuhan, jadi kedalaman rekursi yang biasa tidak masalah.

package main

import "fmt"

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

func main() {
	for i := range 6 {
		fmt.Println(i, factorial(i))
	}
}

for i := range 6 menghitung dari 0 sampai 5 dan butuh Go 1.22 atau lebih baru.

Yang tidak dimiliki fungsi di Go

• Tidak ada overloading. Dua fungsi dalam satu package tidak bisa memakai nama yang sama, meskipun parameternya berbeda.
• Tidak ada argumen default atau argumen bernama. Setiap parameter dikirim di setiap pemanggilan, secara berurutan. Struct konfigurasi memberimu field yang bernama dan opsional: NewServer(Config{Port: 8080}).
• Tidak ada fungsi bernama yang bersarang. Di dalam badan fungsi, kamu hanya bisa mendeklarasikan fungsi anonim, biasanya di-assign ke sebuah variabel.

Daftar argumen dengan panjang yang bervariasi didukung lewat fungsi variadic.

Fungsi yang diekspor dan tidak diekspor

Fungsi yang namanya diawali huruf kapital (Parse) diekspor dan bisa dipanggil dari package lain. Nama dengan huruf kecil (parse) hanya terlihat di dalam package-nya sendiri. Tidak ada kata kunci public atau private; huruf kapital adalah satu-satunya aturan.

Kesalahan umum

• Mengharapkan perubahan parameter sampai ke pemanggil. Meng-assign nilai ke parameter hanya mengubah salinannya. Kembalikan nilai yang baru atau terima pointer.
• Melakukan append di dalam fungsi dan mengabaikan hasilnya. func add(s []int) { s = append(s, 1) } tidak berpengaruh pada panjang slice milik pemanggil. Tulis func add(s []int) []int dan pakai s = add(s).
• Hasil yang tidak dipakai. Go membolehkan mengabaikan nilai kembalian. go vet tidak menandai error yang dibuang, tetapi linter seperti errcheck (bagian dari golangci-lint) menandainya. Pakai _ = hanya saat mengabaikannya memang sebuah keputusan.