סוג קביעה

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

תַחבִּיר

var i interface{} = "ciao"

s := i.(string)           // "panic" form: panics if it's not a string
s, ok := i.(string)       // "comma ok" form: ok = false if it's not a string

שתי צורות, שתי סמנטיות:

טופס "פסיק בסדר": הכי בטוח

var i interface{} = 42

if s, ok := i.(string); ok {
    fmt.Println("è stringa:", s)
} else {
    fmt.Println("non è stringa, ignoro")
}

ok מאפשר לך לטפל במקרה של "סוג לא נכון" ללא פאניקה. זה ה דפוס אידיומטי ברוב המכריע של המקרים.

טענה לממשק

הטענה לא עובדת רק על סוגי קונקרטיים, אלא גם על אחרים ממשקים:

type Closer interface { Close() error }

func tryClose(x interface{}) {
    if c, ok := x.(Closer); ok {
        c.Close()
    }
}

דפוס נפוץ מאוד בספרייה הסטנדרטית: "אם הקלט שלי הוא גם an io.Closer, התקשר לסגור בסוף".

טענה על מצביעים מול ערכים

הטענה חייבת להתאים בדיוק לסוג הדינמי:

type Cat struct{}
func (c *Cat) Meow() {}

var a interface{} = &Cat{}

c1, ok := a.(*Cat)   // ok = true
c2, ok := a.(Cat)    // ok = false: it holds *Cat, not Cat

*Cat וCat הם סוגים נפרדים עבור מערכת הסוג.

מתי להשתמש ב-assertion vs type switch

• סוג אחד אפשרי בלבד, בדיקת "זיהוי תכונה" (למשל, העברה לממשק אופציונלי): הצהרת סוג עם comma ok.
• 2+ סוגים אפשריים, שיגור על פני מספר סניפים: מתג סוג (השיעור הבא).

נסה את זה

var i interface{} = 42
s := i.(string)

לְסַכֵּם

• v := i.(T): פאניקה אם הסוג הדינמי ≠ T.
• v, ok := i.(T): דפוס בטוח, סמן את ok.
• עובד גם נגד ממשק אחר ("זיהוי תכונה").
• T ו-*T הם סוגים נפרדים עבור הטענה.
• סוג אחד → קביעה; 2+ סוגים → מתג סוג.