החזרת כמה ערכים ב-Golang: (value, error) ו-named results

להחזיר יותר מערך אחד

רשמו את טיפוסי התוצאות בסוגריים. החזירו את הערכים מופרדים בפסיקים, וקבלו אותם באותה צורה.

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

הפונקציות המובנות min ו-max קיימות מאז Go 1.21. הקוד הקורא חייב לקבל כל תוצאה: x := minMax(nums) לא מתקמפל, עם assignment mismatch: 1 variable but minMax returns 2 values.

המוסכמה (value, error)

הסיבה הנפוצה ביותר להחזיר שני ערכים היא לדווח על כישלון. לפי המוסכמה השגיאה באה אחרונה, וכשהיא לא nil צריך להתייחס לשאר התוצאות כחסרות משמעות.

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

פלט:

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

בכישלון, החזירו את ערך האפס לכל שאר התוצאות (0, "", nil). התבנית המלאה, כולל עטיפה ובדיקה, נמצאת בעמוד על טיפול בשגיאות.

הביטוי comma-ok

כמה פעולות מובנות מחזירות bool שני ואופציונלי שאומר אם הערך הראשון אמיתי. לפי המוסכמה, המשתנה נקרא 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
}

שלוש הצורות האלה (חיפוש ב-map, type assertion, קבלה מ-channel) מיוחדות: הן מחזירות ערך אחד או שניים, לפי מספר המשתנים שאליהם משימים. הפונקציות שלכם לא יכולות לעשות את זה. פונקציה שהוצהרה עם שתי תוצאות תמיד מחזירה שתיים.

המזהה הריק

_ מקבל ערך וזורק אותו. השתמשו בו לתוצאות שאתם לא צריכים:

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

התעלמות משגיאה עם _ מתקמפלת, אז עשו את זה רק כשאתם יודעים שהקריאה לא יכולה להיכשל, או שהכישלון לא משנה. למשל, strings.Builder.WriteString תמיד מחזירה שגיאה שהיא nil; סגירת קובץ אחרי כתיבה לא.

Named results

לפרמטרים של תוצאה יכולים להיות שמות. הם מוצהרים בתחילת הפונקציה, מאותחלים לערכי האפס שלהם, ו-return בלי ערכים מחזיר את מה שהם מחזיקים.

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

השמות מופיעים בפלט של go doc, וזה עוזר כששתי תוצאות מאותו טיפוס: (quotient, remainder int) אומר יותר מ-(int, int).

return חשוף בפונקציה ארוכה קשה לקריאה, כי הקורא צריך לחזור אחורה כדי לראות מה התוצאות מחזיקות. ההמלצה המקובלת: תנו שמות לתוצאות כשהשמות מתעדים משהו, ועדיין כתבו return quotient, remainder במפורש, אלא אם הפונקציה באורך של כמה שורות.

Named results ו-defer

פונקציה שנדחתה עם defer רצה אחרי שפקודת ה-return קבעה את התוצאות ולפני שהקוד הקורא מקבל אותן. עם named results, הפונקציה שנדחתה יכולה לקרוא אותן ולשנות אותן. כך מוסיפים הקשר לכל שגיאה שפונקציה מחזירה, או הופכים panic לשגיאה.

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

זה מדפיס load : empty name ואחר כך <nil>. return errors.New(...) קודם משים ל-err, ואז הפונקציה שנדחתה עוטפת אותו. עוד על זה בעמוד על defer.

הצללה של named result

named results חיים ב-scope החיצוני ביותר של הפונקציה. := בתוך בלוק מקונן יוצר משתנה חדש עם אותו שם, ו-return חשוף מחזיר אז את החיצוני.

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

הקומפיילר תופס את המקרה הגרוע ביותר: return חשוף בתוך הבלוק שבו תוצאה מוצללת נכשל עם result parameter err not in scope at return. הוא לא תופס את הגרסה שלמעלה, שבה ה-return נמצא מחוץ לבלוק. השתמשו ב-= במקום ב-:= כשאתם מתכוונים למשתני התוצאה.

טעויות נפוצות

• שימוש בערך כש-err הוא לא nil. בדקו קודם את err. פונקציה רשאית להחזיר זבל לצד שגיאה.
• החזרת pointer מטיפוס מסוים שהוא nil בתור שגיאה. var e *MyErr; return e מחזיר error שהוא לא nil. החזירו nil מפורש בהצלחה.
• יותר מדי תוצאות. שלוש תוצאות או יותר עם משמעויות שונות קשות לשימוש. החזירו struct במקום.