Golang Birden Fazla Dönüş Değeri: (value, error), Adlı Sonuçlar

Birden fazla değer döndürmek

Sonuç tiplerini parantez içinde listeleyin. Değerleri virgülle ayırarak döndürün ve aynı şekilde alın.

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)
}

Yerleşik min ve max Go 1.21'den beri vardır. Çağıran her sonucu almak zorundadır: x := minMax(nums), assignment mismatch: 1 variable but minMax returns 2 values hatasıyla derlenmez.

(value, error) geleneği

İki değer döndürmenin en yaygın nedeni başarısızlığı bildirmektir. Geleneğe göre hata en sona gelir ve nil değilse diğer sonuçlar anlamsız kabul edilmelidir.

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)
	}
}

Çıktı:

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

Başarısızlıkta diğer her sonuç için sıfır değeri döndürün (0, "", nil). Sarmalama ve kontrol dahil kalıbın tamamı hata yönetimi sayfasında.

Virgül-ok kalıbı

Birkaç yerleşik işlem, ilk değerin gerçek olup olmadığını söyleyen isteğe bağlı ikinci bir bool döndürür. Değişken geleneksel olarak ok diye adlandırılır.

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
}

Bu üç biçim (map araması, type assertion, channel alımı) özeldir: kaç değişkene atadığınıza bağlı olarak bir ya da iki değer döndürürler. Kendi fonksiyonlarınız bunu yapamaz. İki sonuçla tanımlanmış bir fonksiyon her zaman iki değer döndürür.

Boş tanımlayıcı

_ bir değeri alır ve atar. İhtiyacınız olmayan sonuçlar için kullanın:

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

Bir hatayı _ ile yok saymak derlenir, bu yüzden bunu yalnızca çağrının başarısız olamayacağını ya da başarısızlığın önemli olmadığını bildiğinizde yapın. Örneğin strings.Builder.WriteString her zaman nil bir hata döndürür; yazdıktan sonra bir dosyayı kapatmak ise öyle değildir.

Adlı sonuçlar

Sonuç parametrelerinin adları olabilir. Fonksiyonun başında tanımlanırlar, sıfır değerleriyle başlatılırlar ve değersiz bir return onların tuttuğu değeri döndürür.

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")
}

Adlar go doc çıktısında görünür; bu da iki sonuç aynı tipi paylaştığında işe yarar: (quotient, remainder int), (int, int)'ten daha çok şey söyler.

Uzun bir fonksiyondaki çıplak return zor okunur, çünkü okuyucu sonuçların ne tuttuğunu görmek için geri taramak zorunda kalır. Yaygın tavsiye: adlar bir şeyi belgeliyorsa sonuçları adlandırın, ama fonksiyon birkaç satırlık değilse yine de return quotient, remainder'ı açıkça yazın.

Adlı sonuçlar ve defer

Ertelenmiş bir fonksiyon, return ifadesi sonuçları ayarladıktan sonra ve çağıran onları almadan önce çalışır. Adlı sonuçlarla ertelenmiş fonksiyon onları okuyup değiştirebilir. Bir fonksiyonun döndürdüğü herhangi bir hataya bağlam eklemenin ya da bir panic'i hataya çevirmenin yolu budur.

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"))
}

Bu önce load : empty name, sonra <nil> yazdırır. return errors.New(...) önce err'e atama yapar, ardından ertelenmiş fonksiyon onu sarmalar. Daha fazlası defer sayfasında.

Adlı bir sonucu gölgelemek

Adlı sonuçlar fonksiyonun en dış kapsamında yaşar. İç içe bir bloktaki := aynı adda yeni bir değişken oluşturur ve çıplak bir return bu durumda dıştakini döndürür.

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

Derleyici en kötü durumu yakalar: bir sonucun gölgelendiği bloğun içindeki çıplak bir return, result parameter err not in scope at return hatasıyla başarısız olur. Return'ün bloğun dışında olduğu yukarıdaki sürümü ise yakalamaz. Sonuç değişkenlerini kastettiğinizde := yerine = kullanın.

Sık yapılan hatalar

• err nil değilken değeri kullanmak. Önce err'i kontrol edin. Bir fonksiyon bir hatanın yanında çöp değer döndürmekte serbesttir.
• Tipli bir nil pointer'ı error olarak döndürmek. var e *MyErr; return e, nil olmayan bir error döndürür. Başarıda düz bir nil döndürün.
• Çok fazla sonuç. Anlamları karışık üç ya da daha fazla sonucu kullanmak zordur. Bunun yerine bir struct döndürün.