Что такое type assertions и type switches?

Question

Accepted Answer

**Type assertion** извлекает конкретный тип из значения интерфейса, а **type switch** разветвляется в зависимости от основного типа интерфейса. Это способ получить конкретную информацию о типе из интерфейса (особенно пустого интерфейса / `any`).

## Type assertion — извлечение конкретного типа

```go
var i interface{} = "hello"     // an interface holding a string

s := i.(string)                  // assert it's a string → s = "hello"
fmt.Println(s)

n := i.(int)                     // ❌ PANIC — i is not an int (wrong assertion)
```

Синтаксис `i.(Type)` утверждает, что интерфейс `i` содержит значение типа `Type`, и извлекает его. Но неправильное утверждение **паникует** — поэтому обычно вы используете безопасную форму comma-ok.

## Безопасная форма comma-ok

```go
s, ok := i.(string)
if ok {
    fmt.Println("it's a string:", s)   // ok = true, s = the value
} else {
    fmt.Println("not a string")         // ok = false, s = zero value, NO panic
}
```

Двухзначная форма возвращает значение плюс логическое значение — `ok` имеет значение false (вместо паники), если утверждение не выполняется. **Всегда отдавайте предпочтение этому**, если вы не уверены в типе.

## Type switch — разветвление на несколько возможных типов

```go
func describe(i interface{}) string {
    switch v := i.(type) {           // the special .(type) form, only in a switch
    case int:
        return fmt.Sprintf("int: %d (doubled: %d)", v, v*2)
    case string:
        return fmt.Sprintf("string of length %d", len(v))
    case bool:
        return fmt.Sprintf("bool: %t", v)
    case nil:
        return "nil value"
    default:
        return fmt.Sprintf("unknown type: %T", v)
    }
}

describe(42)        // "int: 42 (doubled: 84)"
describe("hi")      // "string of length 2"
```

Форма `switch v := i.(type)` проверяет основной тип и привязывает `v` (соответственно типизированный в каждом случае). Это чистый способ обработки интерфейса, который может содержать несколько типов.

## Утверждение типов интерфейса

```go
// assert that a value implements a specific interface
if w, ok := i.(io.Writer); ok {
    w.Write([]byte("data"))    // use it as an io.Writer if it satisfies that interface
}
```

## Когда вам это нужно

```text
✓ Processing values of unknown type (interface{}/any) — JSON, generic handlers
✓ Checking if a value implements an optional interface (e.g. io.Closer)
✓ Handling heterogeneous data
⚠️ Often a sign you could use generics or better-typed interfaces instead — don't overuse
```

## Почему это важно

Type assertions и type switches — это важные инструменты для работы со значениями интерфейса — извлечение конкретной информации о типе из `interface{}`/`any` или проверка того, удовлетворяет ли значение определённому интерфейсу.

Они необходимы при работе с данными неизвестного или разнообразного типа (анализ динамического JSON, общая обработка, проверки опциональных интерфейсов, таких как "реализует ли это io.Closer?").

Понимание **различия panic-vs-safe** критично: простое утверждение `i.(T)` паникует при несовпадении, в то время как **форма comma-ok** `v, ok := i.(T)` безопасно сообщает об ошибке — использование безопасной формы является ключевой практикой для предотвращения ошибок времени выполнения.

Type switch элегантно обрабатывает несколько возможных типов.

Знание этого (и того, что интенсивное использование часто указывает на то, что вместо этого следует обратиться к обобщениям или лучше типизированным конструкциям) важно для безопасного, идиоматичного Go и является частым предметом собеседования, поскольку интерфейсы и пустой интерфейс настолько центральны для языка.