Утверждение типа и переключатели типов в Golang

Утверждение типа (type assertion) обеспечивает доступ к конкретному значению интерфейса.

Утверждение типа на самом деле не преобразует интерфейс в другой тип данных, но обеспечивает доступ к конкретному значению интерфейса, которое обычно является тем, что вам нужно.

Утверждение типа x.(T) утверждает, что конкретное значение, хранящееся в x, имеет тип T, и что x не равно nil.

• Если T не является интерфейсом, он утверждает, что динамический тип x идентичен T.
• Если T является интерфейсом, он утверждает, что динамический тип x реализует T.

var x interface{} = "foo"

var s string = x.(string)
fmt.Println(s)     // "foo"

s, ok := x.(string)
fmt.Println(s, ok) // "foo true"

n, ok := x.(int)
fmt.Println(n, ok) // "0 false"

n = x.(int)        // ILLEGAL

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

Переключатели типов

Переключатель типов (type switch) выполняет несколько утверждений типа последовательно и запускает первый случай с подходящим типом.

switch v := x.(type) {
case nil:
    fmt.Println("x is nil")            
case int: 
    fmt.Println("x is", v)             
case bool, string:
    fmt.Println("x is bool or string")
default:
    fmt.Println("type unknown")
}

Вывод:

x is bool or string

---

Читайте также:

• Основы Go: утверждение типа
• Основы Go: switch с типами
• Эффективный Go: преобразования интерфейсов и утверждения типа

Канал в Телеграм

Спецификация Go: переключатель типов (type switch)

Переключатель типов сравнивает типы, а не значения. В остальном он аналогичен переключателю выражений. Он помечается специальным выражением-переключателем, которое имеет форму утверждения типа, используя зарезервированное слово type, а не фактический тип:

switch x.(type) {
// cases
}

Затем случаи (cases) сопоставляют фактические типы T с динамическим типом выражения x. Как и в утверждении типа, x должен иметь интерфейсный тип, и каждый неинтерфейсный тип T, указанный в случае (case), должен реализовывать тип x. Типы, перечисленные в случаях переключения типов, должны быть разными.

TypeSwitchStmt  = "switch" [ SimpleStmt ";" ] TypeSwitchGuard "{" { TypeCaseClause } "}" .
TypeSwitchGuard = [ identifier ":=" ] PrimaryExpr "." "(" "type" ")" .
TypeCaseClause  = TypeSwitchCase ":" StatementList .
TypeSwitchCase  = "case" TypeList | "default" .
TypeList        = Type { "," Type } .

TypeSwitchGuard может включать краткое объявление переменной. Когда эта форма используется, переменная объявляется в конце TypeSwitchCase в неявном блоке каждого пункта. В пунктах со случаем точно одного типа переменная имеет этот тип; в противном случае переменная имеет тип выражения в TypeSwitchGuard.

Вместо типа случай (case) может использовать предварительно объявленный идентификатор nil; этот случай выбирается, когда выражение в TypeSwitchGuard имеет нулевое значение интерфейса. Может быть не более одного нулевого случая.

Дано выражение x типа interface{}, следующий переключатель типов:

switch i := x.(type) {
case nil:
    printString("x is nil")                // тип i это тип x (interface{})
case int:
    printInt(i)                            // тип i это int
case float64:
    printFloat64(i)                        // тип i это float64
case func(int) float64:
    printFunction(i)                       // тип i это func(int) float64
case bool, string:
    printString("type is bool or string")  // тип i это тип x (interface{})
default:
    printString("don't know the type")     // тип i это тип x (interface{})
}

может быть записан как:

v := x  // x оценивается только единожды
if v == nil {
    i := v                                 // тип i это тип x (interface{})
    printString("x is nil")
} else if i, isInt := v.(int); isInt {
    printInt(i)                            // тип i это int
} else if i, isFloat64 := v.(float64); isFloat64 {
    printFloat64(i)                        // тип i это float64
} else if i, isFunc := v.(func(int) float64); isFunc {
    printFunction(i)                       // тип i это func(int) float64
} else {
    _, isBool := v.(bool)
    _, isString := v.(string)
    if isBool || isString {
        i := v                         // тип i это тип x (interface{})
        printString("type is bool or string")
    } else {
        i := v                         // тип i это тип x (interface{})
        printString("don't know the type")
    }
}

Защите переключения типа может предшествовать простое утверждение, которое выполняется до оценки защиты.

"fallthrough" утверждение запрещено в переключателе типов.

---

Читайте также:

• Основы Go: switch
• Эффективный Go: оператор switch
• Основы Go: switch с типами