Type Assertion ב-Golang: x.(T), comma-ok ו-type switch

x.(T): הוצאת הערך מתוך interface

ערך interface מסתיר את הטיפוס הקונקרטי שהוא מחזיק. type assertion x.(T) מבקש אותו בחזרה.

package main

import "fmt"

func main() {
	var v any = "gopher"

	s := v.(string) // v holds a string: ok
	fmt.Println(s, len(s))

	n, ok := v.(int) // comma-ok: no panic on mismatch
	fmt.Println(n, ok)

	if str, ok := v.(string); ok {
		fmt.Println("string of length", len(str))
	}
}

פלט:

gopher 6
0 false
string of length 6

ל-x חייב להיות טיפוס interface. assertion על טיפוס קונקרטי לא מתקמפל: invalid operation: s (variable of type string) is not an interface.

הצורה עם ערך אחד גורמת ל-panic

כשה-assertion שגוי, הצורה עם ערך יחיד גורמת ל-panic עם הודעה שמציינת את שני הטיפוסים:

package main

import "fmt"

func main() {
	defer func() {
		fmt.Println("recovered:", recover())
	}()

	var v any = 42
	s := v.(string)
	fmt.Println(s)
}

פלט:

recovered: interface conversion: interface {} is int, not string

השתמשו בצורה עם ערך אחד רק כשטיפוס אחר יהיה שגיאת תכנות שאתם רוצים לקרוס בגללה. בכל מקום אחר, השתמשו ב-comma-ok. בכישלון, comma-ok נותן את ערך האפס של T ו-false.

assertion על interface שהוא nil גם נכשל: var v any; v.(string) גורם ל-panic עם interface conversion: interface {} is nil, not string, וצורת ה-comma-ok מחזירה "", false.

Assertion ל-interface אחר

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

package main

import (
	"fmt"
	"strings"
)

type Temp float64

func (t Temp) String() string { return fmt.Sprintf("%.1f degrees", float64(t)) }

func describe(v any) string {
	if s, ok := v.(fmt.Stringer); ok {
		return "Stringer: " + s.String()
	}
	return fmt.Sprintf("plain value: %v", v)
}

func main() {
	fmt.Println(describe(Temp(21.5)))
	fmt.Println(describe(42))

	// io.Copy uses the same trick to check for WriterTo / ReaderFrom.
	var r any = strings.NewReader("x")
	_, hasLen := r.(interface{ Len() int })
	fmt.Println("has Len:", hasLen)
}

io.Copy בודקת אם המקור שלה מממש את io.WriterTo ומשתמשת בזה כשכן. fmt בודקת Stringer ו-error. הדפוס הזה מאפשר ל-interface קטן להישאר קטן, בזמן שהקוראים עדיין נהנים ממימושים עשירים יותר.

Type switch

כשערך יכול להיות אחד מכמה טיפוסים, type switch מחליף שרשרת של assertions. x.(type) תקף רק בתוך switch.

package main

import (
	"fmt"
	"strconv"
)

func toString(v any) string {
	switch x := v.(type) {
	case nil:
		return "nil"
	case string:
		return x // x is a string here
	case int, int64:
		return fmt.Sprintf("integer %v", x) // x is any: two types in one case
	case float64:
		return strconv.FormatFloat(x, 'f', 2, 64)
	case fmt.Stringer:
		return x.String()
	case error:
		return "error: " + x.Error()
	default:
		return fmt.Sprintf("unhandled %T", x)
	}
}

func main() {
	values := []any{"hi", 7, int64(8), 3.14159, nil, fmt.Errorf("boom"), []int{1}}
	for _, v := range values {
		fmt.Println(toString(v))
	}
}

פלט:

hi
integer 7
integer 8
3.14
nil
error: boom
unhandled []int

כללים ששווה להכיר:

• במקרה עם טיפוס אחד, ל-x יש את הטיפוס הזה. במקרה שמפרט כמה טיפוסים, וב-default, ל-x יש את הטיפוס של ה-interface המקורי (כאן any).
• המקרים נבדקים לפי הסדר. שימו interfaces ספציפיים יותר לפני רחבים יותר, כי ערך יכול לממש כמה מהם.
• case nil מתאים רק ל-interface שהוא nil, לא ל-interface שמחזיק מצביע nil.
• אין fallthrough ב-type switch.

errors.As: ה-assertion לשגיאות עטופות

שגיאות נעטפות לעיתים קרובות בהקשר: fmt.Errorf("load config: %w", err). type assertion ישיר מסתכל רק על השגיאה החיצונית ביותר ומפספס את זו שבפנים. errors.As עוברת על השרשרת.

package main

import (
	"errors"
	"fmt"
	"io/fs"
	"os"
)

func load() error {
	_, err := os.Open("/no/such/file")
	if err != nil {
		return fmt.Errorf("load config: %w", err)
	}
	return nil
}

func main() {
	err := load()

	_, ok := err.(*fs.PathError)
	fmt.Println("type assertion finds it:", ok)

	var pe *fs.PathError
	if errors.As(err, &pe) {
		fmt.Println("errors.As finds it:", pe.Op, pe.Path)
	}
}

פלט:

type assertion finds it: false
errors.As finds it: open /no/such/file

השתמשו ב-type assertion על שגיאות רק כשאתם יודעים שהשגיאה לא עטופה, ובפועל זה כמעט אף פעם. הדף על שגיאות מותאמות מכסה את errors.As, את errors.Is והגדרה של טיפוסי שגיאה משלכם.

Assertions מול המרות מול generics

קוד מלא ב-any וב-type switches הוא לעיתים קרובות סימן לכך ש-generics או interface מתאים היו מבטאים את הכוונה טוב יותר ותופסים טעויות בזמן הידור.

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

• שימוש בצורה שגורמת ל-panic על נתונים לא מהימנים. JSON מפוענח, ערכי map מטיפוס any, קלטים של plugins: תמיד comma-ok.
• Assertion לטיפוס מספרי שגוי. מספרי JSON מפוענחים לתוך any כ-float64, ולכן v.(int) נכשל עליהם.
• Assertion לטיפוס ערך כששמור מצביע. אם ה-interface מחזיק *User, אז v.(User) נכשל. בצעו assertion ל-v.(*User).
• Type assertions על שגיאות. השתמשו ב-errors.As.