Утверждение типа в Golang: x.(T), comma-ok и type switch

x.(T): достаём значение из интерфейса

Значение интерфейса скрывает конкретный тип, который в нём лежит. Утверждение типа 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 должен иметь интерфейсный тип. Утверждение на конкретном типе не компилируется: invalid operation: s (variable of type string) is not an interface.

Форма с одним значением паникует

Если утверждение неверно, форма с одним значением паникует с сообщением, где названы оба типа:

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.

Утверждение на nil-интерфейсе тоже не проходит: var v any; v.(string) паникует с interface conversion: interface {} is nil, not string, а форма comma-ok возвращает "", false.

Утверждение к другому интерфейсу

T может быть интерфейсным типом. Тогда утверждение успешно, если динамическое значение реализует 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. Этот шаблон позволяет маленькому интерфейсу оставаться маленьким, а вызывающему коду всё равно пользоваться более богатыми реализациями.

Type switch

Когда значение может быть одного из нескольких типов, type switch заменяет цепочку утверждений. 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 имеет тип исходного интерфейса (здесь any).
• Ветки проверяются по порядку. Ставьте более конкретные интерфейсы раньше общих, ведь значение может удовлетворять нескольким.
• case nil совпадает только с nil-интерфейсом, а не с интерфейсом, в котором лежит nil-указатель.
• fallthrough в type switch нет.

errors.As: утверждение для обёрнутых ошибок

Ошибки часто оборачивают контекстом: fmt.Errorf("load config: %w", err). Прямое утверждение типа смотрит только на самую внешнюю ошибку и пропускает ту, что внутри. 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

Применяйте утверждение типа к ошибкам, только если точно знаете, что ошибка не обёрнута, а на практике это почти никогда. errors.As, errors.Is и определение собственных типов ошибок разобраны на странице о собственных ошибках.

Утверждения, преобразования и дженерики

Код, полный any и type switch, часто говорит о том, что дженерики или нормальный интерфейс лучше выразили бы намерение и ловили бы ошибки на этапе компиляции.

Частые ошибки

• Паникующая форма на непроверенных данных. Декодированный JSON, значения мапы типа any, входные данные плагинов: всегда comma-ok.
• Утверждение к не тому числовому типу. Числа JSON декодируются в any как float64, поэтому v.(int) на них не срабатывает.
• Утверждение к типу-значению, когда хранится указатель. Если в интерфейсе лежит *User, то v.(User) не пройдёт. Пишите v.(*User).
• Утверждения типа на ошибках. Используйте errors.As.