Multiple Return Values di Golang: (value, error) dan Named Result

Mengembalikan lebih dari satu nilai

Tulis tipe-tipe hasilnya di dalam tanda kurung. Kembalikan nilainya dipisahkan koma, dan terima dengan cara yang sama.

package main

import "fmt"

func minMax(xs []int) (int, int) {
	lo, hi := xs[0], xs[0]
	for _, x := range xs[1:] {
		lo = min(lo, x)
		hi = max(hi, x)
	}
	return lo, hi
}

func main() {
	lo, hi := minMax([]int{4, 9, 1, 7})
	fmt.Println("min:", lo, "max:", hi)
}

Fungsi bawaan min dan max sudah ada sejak Go 1.21. Pemanggil harus menerima setiap hasil: x := minMax(nums) gagal dikompilasi dengan assignment mismatch: 1 variable but minMax returns 2 values.

Konvensi (value, error)

Alasan paling umum mengembalikan dua nilai adalah untuk melaporkan kegagalan. Menurut konvensi, error berada di posisi terakhir, dan saat error-nya tidak nil, hasil lainnya harus dianggap tidak bermakna.

package main

import (
	"errors"
	"fmt"
	"strconv"
)

func parsePort(s string) (int, error) {
	n, err := strconv.Atoi(s)
	if err != nil {
		return 0, fmt.Errorf("port %q: %w", s, err)
	}
	if n < 1 || n > 65535 {
		return 0, errors.New("port out of range")
	}
	return n, nil
}

func main() {
	for _, in := range []string{"8080", "http", "70000"} {
		port, err := parsePort(in)
		if err != nil {
			fmt.Println("error:", err)
			continue
		}
		fmt.Println("port:", port)
	}
}

Output:

port: 8080
error: port "http": strconv.Atoi: parsing "http": invalid syntax
error: port out of range

Saat gagal, kembalikan zero value untuk setiap hasil lainnya (0, "", nil). Pola lengkapnya, termasuk wrapping dan pemeriksaan, ada di halaman penanganan error.

Idiom comma-ok

Beberapa operasi bawaan mengembalikan bool kedua yang opsional, yang menyatakan apakah nilai pertama benar-benar ada. Variabelnya biasanya dinamai ok.

package main

import "fmt"

func main() {
	ages := map[string]int{"ana": 31}

	age, ok := ages["bob"]
	fmt.Println(age, ok) // 0 false: missing key, not a zero age

	var v any = "hello"
	s, ok := v.(string)
	fmt.Println(s, ok)

	ch := make(chan int, 1)
	ch <- 5
	close(ch)
	x, ok := <-ch
	fmt.Println(x, ok) // 5 true: a buffered value is still delivered
	x, ok = <-ch
	fmt.Println(x, ok) // 0 false: closed and drained
}

Ketiga bentuk ini (pencarian di map, type assertion, penerimaan dari channel) istimewa: mereka mengembalikan satu atau dua nilai tergantung berapa variabel yang kamu assign. Fungsi buatanmu sendiri tidak bisa begitu. Fungsi yang dideklarasikan dengan dua hasil selalu mengembalikan dua.

Blank identifier

_ menerima sebuah nilai lalu membuangnya. Pakai untuk hasil yang tidak kamu butuhkan:

_, err := fmt.Sscan(input, &n)
key, _ := parseLine(line)

Mengabaikan error dengan _ tetap bisa dikompilasi, jadi lakukan hanya kalau kamu tahu pemanggilannya tidak mungkin gagal atau kegagalannya tidak berpengaruh. Misalnya, strings.Builder.WriteString selalu mengembalikan error nil; menutup file setelah menulis tidak begitu.

Named result

Parameter hasil bisa diberi nama. Parameter ini dideklarasikan di awal fungsi, diinisialisasi dengan zero value, dan return tanpa nilai akan mengembalikan apa pun isinya saat itu.

package main

import "fmt"

func split(total int) (quotient, remainder int) {
	quotient = total / 7
	remainder = total % 7
	return
}

func main() {
	weeks, days := split(45)
	fmt.Println(weeks, "weeks and", days, "days")
}

Nama-nama itu muncul di output go doc, yang membantu saat dua hasil punya tipe yang sama: (quotient, remainder int) lebih informatif daripada (int, int).

return tanpa nilai di fungsi yang panjang sulit dibaca, karena pembaca harus menelusuri ke atas untuk melihat isi hasilnya. Saran yang umum: beri nama pada hasil kalau nama itu mendokumentasikan sesuatu, dan tetap tulis return quotient, remainder secara eksplisit kecuali fungsinya hanya beberapa baris.

Named result dan defer

Fungsi yang di-defer berjalan setelah pernyataan return mengisi hasilnya dan sebelum pemanggil menerimanya. Dengan named result, fungsi yang di-defer bisa membaca dan mengubah hasil itu. Beginilah cara menambahkan konteks ke error apa pun yang dikembalikan sebuah fungsi, atau mengubah panic menjadi error.

package main

import (
	"errors"
	"fmt"
)

func load(name string) (err error) {
	defer func() {
		if err != nil {
			err = fmt.Errorf("load %s: %w", name, err)
		}
	}()
	if name == "" {
		return errors.New("empty name")
	}
	return nil
}

func main() {
	fmt.Println(load(""))
	fmt.Println(load("config.json"))
}

Program ini mencetak load : empty name lalu <nil>. return errors.New(...) lebih dulu meng-assign ke err, lalu fungsi yang di-defer membungkusnya. Selengkapnya di defer.

Shadowing pada named result

Named result berada di scope terluar fungsi. := di dalam blok bersarang membuat variabel baru dengan nama yang sama, lalu return tanpa nilai akan mengembalikan variabel yang di luar.

func find() (n int, err error) {
	if true {
		n, err := compute() // new n and err, shadowing the results
		_ = n
		_ = err
	}
	return // returns 0, nil
}

Compiler menangkap kasus terburuknya: return tanpa nilai di dalam blok tempat sebuah hasil di-shadow gagal dengan result parameter err not in scope at return. Compiler tidak menangkap versi di atas, yang return-nya berada di luar blok. Pakai = alih-alih := kalau yang kamu maksud adalah variabel hasil.

Kesalahan umum

• Memakai nilainya saat err tidak nil. Periksa err dulu. Sebuah fungsi bebas mengembalikan nilai sampah bersama error.
• Mengembalikan pointer nil bertipe sebagai error. var e *MyErr; return e mengembalikan error yang tidak nil. Kembalikan nil literal saat sukses.
• Terlalu banyak hasil. Tiga hasil atau lebih dengan makna yang bercampur sulit dipakai. Kembalikan struct sebagai gantinya.