סוג מתג

מתג סוג מבחין בין מספר סוגים אפשריים של ערך ממשק. זו הכללה של comma ok כשיש יותר ממקרה אחד.

תַחבִּיר

func describe(i interface{}) string {
    switch v := i.(type) {
    case int:
        return fmt.Sprintf("int %d", v)
    case string:
        return fmt.Sprintf("string %q", v)
    case nil:
        return "nil"
    default:
        return fmt.Sprintf("altro tipo: %T", v)
    }
}

• i.(type) הוא תחביר מיוחד, תקף רק בתוך switch.
• v := ... מקשר את הערך עם סוג התיק הנוכחי: בתוך case int, ל-v יש את הסוג int.
• default תופס את כל הסוגים האחרים; שם v יש את סוג הממשק המקורי.
• case nil תואם את הממשק לסוג דינמי אפס.

מקרה "חסר שם".

אם אינך זקוק לערך שהוקלד, תוכל להשמיט את ה-v:

switch i.(type) {
case int:
    // you know it's an int, but you don't have a variable of that type
case string:
    // ...
}

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

מספר סוגים באותו מקרה

switch v := i.(type) {
case int, int64:
    // here v is still interface{}: the "common" type is just the interface
    fmt.Println("numero intero:", v)
case string:
    // here v is string
    fmt.Println("stringa:", v)
}

מקרה שימוש אופייני: הדפסה מעוצבת

func print(i interface{}) {
    switch v := i.(type) {
    case int:
        fmt.Printf("%d\n", v)
    case string:
        fmt.Printf("%s\n", v)
    case fmt.Stringer:
        fmt.Println(v.String())
    default:
        fmt.Printf("%v\n", v)
    }
}

fmt.Println עצמו משתמש במתג סוג פנימי כדי לטפל ב פורמטים סטנדרטיים.

מתג סוג לעומת השתקפות

עבור כמה סוגים ידועים → סוג מתג (מהיר, קריא). לבדיקה דינמית של סוגים לא ידועים → חבילת reflect (עוד חזק אך איטי יותר ומפורש יותר).

נסה את זה

switch ??? {
  case int: ...
}

לְסַכֵּם

• switch v := i.(type) { case T: ... }: מפלה על הסוג הדינמי.
• בתוך מארז מסוג יחיד, v כולל את סוג המארז.
• case T1, T2: v שומר על סוג הממשק המקורי.
• default עבור מקרים לא מטופלים; case nil עבור הממשק האפסי.
• אין fallthrough במתגי סוג.
• סוג אחד → קביעת סוג; 2+ סוגים → מתג סוג.