Go言語の型アサーション：x.(T)、カンマok、型スイッチ

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。

1値の形はpanicする

アサーションが間違っていると、1値の形は両方の型を示すメッセージとともにpanicします。

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

1値の形を使うのは、別の型が来たらクラッシュさせたいプログラミングのエラーであるときだけにします。それ以外はすべてカンマokを使います。失敗したとき、カンマokは T のゼロ値と false を返します。

nilのインターフェースに対するアサーションも失敗します。var v any; v.(string) は interface conversion: interface {} is nil, not string でpanicし、カンマ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 をチェックします。このパターンによって、小さなインターフェースを小さいまま保ちつつ、呼び出し側はより豊かな実装の恩恵を受けられます。

型スイッチ

値がいくつかの型のどれかでありうるとき、型スイッチはアサーションの連鎖の代わりになります。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

知っておきたいルールは次のとおりです。

• 型が1つのcaseでは、x はその型になります。複数の型を並べたcaseと default では、x は元のインターフェースの型（ここでは any）です。
• caseは順にチェックされます。値は複数のインターフェースを満たしうるので、より具体的なインターフェースを広いものより前に置きます。
• case nil に一致するのはnilのインターフェースだけで、nilポインタを保持するインターフェースは一致しません。
• 型スイッチに fallthrough はありません。

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 と型スイッチだらけのコードは、ジェネリクスや適切なインターフェースのほうが意図をよく表し、間違いをコンパイル時に捕まえられるというサインであることがよくあります。

よくある間違い

• 信頼できないデータにpanicする形を使う。 デコードしたJSON、any 型のマップの値、プラグインからの入力には、常にカンマokを使います。
• 間違った数値型にアサーションする。 JSONの数値は any に float64 としてデコードされるので、v.(int) は失敗します。
• ポインタが格納されているのに値の型にアサーションする。 インターフェースが *User を保持していれば、v.(User) は失敗します。v.(*User) でアサーションします。
• エラーに型アサーションを使う。 errors.As を使います。