Multiple Return Values

Banyak operasi program menghasilkan lebih dari satu keluaran: pembagian menghasilkan hasil sekaligus status keberhasilan, pencarian menghasilkan data sekaligus tanda ketemu. Bahasa lain mengatasinya dengan parameter keluaran atau tipe pasangan khusus, sedangkan Go memilih bentuk yang paling lugas: satu fungsi boleh mengembalikan banyak nilai sekaligus. Pada chapter ini kita akan memakai bentuk tersebut untuk dua nilai data, lalu untuk pola paling terkenal di seluruh ekosistem Go: pasangan nilai dan error.

Mengembalikan Dua Nilai #

Tipe kembalian berganda ditulis sebagai daftar tipe di dalam tanda kurung, misalnya (int, int). Statement return kemudian mengirim nilai yang dipisahkan koma, dan pemanggil menampungnya dengan beberapa variabel sekaligus. Fungsi minMax di bawah mengembalikan nilai terkecil dan terbesar dari sebuah slice:

// minMax mengembalikan nilai terkecil dan terbesar dari slice.
func minMax(angka []int) (int, int) {
	kecil := angka[0]
	besar := angka[0]
	for _, v := range angka {
		if v < kecil {
			kecil = v
		}
		if v > besar {
			besar = v
		}
	}
	return kecil, besar
}

Pemanggilannya memakai dua variabel dalam satu deklarasi: kecil, besar := minMax([]int{23, 7, 45, 15}) mengisi kecil dengan 7 dan besar dengan 45. Urutan variabel harus mengikuti urutan nilai pada return; Go tidak membaca nama, hanya posisi.

Pola Nilai dan Error #

Kekuatan sesungguhnya muncul saat nilai terakhir bertipe error. Nilai error bernilai nil ketika operasi berhasil, dan berisi deskripsi galat ketika operasi gagal. Fungsi bagi berikut menolak pembagi nol dengan membuat galat lewat errors.New:

// bagi membagi a dengan b dan melaporkan galat saat pembagi nol.
func bagi(a, b int) (int, error) {
	if b == 0 {
		return 0, errors.New("pembagi tidak boleh nol")
	}
	return a / b, nil
}

Pemanggil yang idiomatik selalu membaca keduanya sekaligus, lalu memeriksa err sebelum memakai hasilnya:

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

Cara baca pola hasil, err := seperti ini: “jalankan bagi, simpan hasilnya di hasil, dan simpan statusnya di err”. Kebiasaan memeriksa err != nil di baris berikutnya adalah konvensensi seluruh standard library — kita akan menemukannya hampir di setiap pemanggilan strconv, os, hingga net/http.

Membuang Nilai dengan Pengenal Kosong #

Go melarang variabel terdeklarasi tanpa pemakaian, termasuk hasil fungsi. Ketika kita hanya butuh sebagian nilai, pengenal kosong _ menampung nilai yang dibuang. Contohnya, pemanggil yang hanya tertarik nilai terbesar menulis _, terbesar := minMax(...) — nilai pertama dihitung tetap diabaikan. Pengenal _ boleh dipakai berulang karena _ bukan variabel sungguhan, melainkan tempat pembuangan.

Program Utuh #

Berkas multiple-return.go menggabungkan bagi, minMax, dan pemakaian _ dalam satu program. Jalankan dari direktori chapter:

go run multiple-return.go

Output yang Dihasilkan:

10 / 2 = 5
Galat: pembagi tidak boleh nol
Terkecil: 7, Terbesar: 45
Hanya butuh terbesar: 19

Mari kita telaah baris demi baris program di atas:

1. Baris 9 (func bagi(a, b int) (int, error)): mendeklarasikan dua nilai kembalian — hasil pembagian dan status galat.
2. Baris 11 (return 0, errors.New(...)): jalur gagal mengirim hasil netral 0 berpasangan dengan galat baru dari errors.New.
3. Baris 13 (return a / b, nil): jalur sukses mengirim hasil perhitungan dan nil sebagai penanda tidak ada galat.
4. Baris 16–29 (minMax): memetakan seluruh elemen slice lalu mengembalikan pasangan kecil, besar dengan satu return.
5. Baris 31–51 (isi main): memanggil bagi dua kali — sekali sukses dan sekali gagal — lalu memakai kecil, besar sekaligus bentuk _, terbesar untuk membuang nilai pertama.

Dua baris pertama output membuktikan dua jalur bagi: sukses mencetak 5, gagal mencetak pesan galat tanpa menghentikan program. Dengan pola ini, eksplisit menjadi kebiasaan: tidak ada status yang tersembunyi, semuanya kembali ke pemanggil. Ketika daftar nilai kembalian mulai membingungkan urutannya, Go menyediakan bentuk berikutnya: memberi nama pada tiap nilai kembalian — bahasan chapter Named Return Values .

Referensi #

• Effective Go: multiple returns — penjelasan resmi filosofi multi-return.
• Package errors — dokumentasi errors.New dan kawan-kawannya.
• Assignments — Go Spec — aturan penetapan nilai berganda dan _.

package main

import (
	"errors"
	"fmt"
)

// bagi membagi a dengan b dan melaporkan galat saat pembagi nol.
func bagi(a, b int) (int, error) {
	if b == 0 {
		return 0, errors.New("pembagi tidak boleh nol")
	}
	return a / b, nil
}

// minMax mengembalikan nilai terkecil dan terbesar dari slice.
func minMax(angka []int) (int, int) {
	kecil := angka[0]
	besar := angka[0]
	for _, v := range angka {
		if v < kecil {
			kecil = v
		}
		if v > besar {
			besar = v
		}
	}
	return kecil, besar
}

func main() {
	hasil, err := bagi(10, 2)
	if err != nil {
		fmt.Println("Galat:", err)
	} else {
		fmt.Println("10 / 2 =", hasil)
	}

	hasil, err = bagi(10, 0)
	if err != nil {
		fmt.Println("Galat:", err)
	} else {
		fmt.Println("10 / 0 =", hasil)
	}

	kecil, besar := minMax([]int{23, 7, 45, 15})
	fmt.Printf("Terkecil: %d, Terbesar: %d\n", kecil, besar)

	// Pengenal kosong _ membuang nilai pertama.
	_, terbesar := minMax([]int{8, 3, 19})
	fmt.Println("Hanya butuh terbesar:", terbesar)
}