Golang Type Assertion: x.(T), Virgül-ok ve Type Switch

x.(T): değeri bir interface'ten çıkarmak

Bir interface değeri tuttuğu somut tipi gizler. Bir type assertion x.(T) onu geri ister.

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))
	}
}

Çıktı:

gopher 6
0 false
string of length 6

x'in bir interface tipi olmalıdır. Somut bir tip üzerinde assertion derlenmez: invalid operation: s (variable of type string) is not an interface.

Tek değerli biçim panic olur

Assertion yanlış olduğunda tek değerli biçim, iki tipi de adlandıran bir mesajla panic olur:

package main

import "fmt"

func main() {
	defer func() {
		fmt.Println("recovered:", recover())
	}()

	var v any = 42
	s := v.(string)
	fmt.Println(s)
}

Çıktı:

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

Tek değerli biçimi yalnızca farklı bir tipin, çökmesini istediğiniz bir programlama hatası olacağı durumlarda kullanın. Diğer her yerde virgül-ok kullanın. Başarısızlıkta virgül-ok, T'nin sıfır değerini ve false verir.

Nil bir interface üzerinde assertion da başarısız olur: var v any; v.(string), interface conversion: interface {} is nil, not string ile panic olur, virgül-ok biçimi ise "", false döndürür.

Başka bir interface'e assertion

T bir interface tipi olabilir. Assertion bu durumda dinamik değer T'yi gerçekleştiriyorsa başarılı olur ve sonuç aynı dinamik değeri korur. Standart kütüphane isteğe bağlı yetenekleri böyle kontrol eder.

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, kaynağının io.WriterTo'yu gerçekleştirip gerçekleştirmediğini kontrol eder ve gerçekleştiriyorsa onu kullanır. fmt, Stringer ve error'u kontrol eder. Bu kalıp, küçük bir interface'in küçük kalmasını sağlarken çağıranların daha zengin gerçekleştirmelerden yararlanmasına da izin verir.

Type switch

Bir değer birkaç tipten biri olabildiğinde bir type switch, assertion zincirinin yerini alır. x.(type) yalnızca bir switch içinde geçerlidir.

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))
	}
}

Çıktı:

hi
integer 7
integer 8
3.14
nil
error: boom
unhandled []int

Bilmeye değer kurallar:

• Tek tipli bir case'te x o tipe sahiptir. Birkaç tip listeleyen bir case'te ve default'ta x orijinal interface'in tipine (burada any) sahiptir.
• Case'ler sırayla kontrol edilir. Bir değer birkaç interface'i karşılayabileceği için daha belirli interface'leri daha genişlerden önce koyun.
• case nil yalnızca nil bir interface ile eşleşir, nil bir pointer tutan bir interface ile değil.
• Bir type switch'te fallthrough yoktur.

errors.As: sarmalanmış hatalar için assertion

Hatalar çoğu zaman bağlamla sarmalanır: fmt.Errorf("load config: %w", err). Doğrudan bir type assertion yalnızca en dıştaki hataya bakar ve içtekini kaçırır. errors.As zinciri dolaşır.

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)
	}
}

Çıktı:

type assertion finds it: false
errors.As finds it: open /no/such/file

Hatalar üzerinde type assertion'ı yalnızca hatanın sarmalanmadığını bildiğinizde kullanın; bu da pratikte neredeyse hiçbir zaman demektir. errors.As, errors.Is ve kendi hata tiplerinizi tanımlamayı özel hatalar sayfası anlatıyor.

Assertion'lar, dönüşümler ve generics

any ve type switch'lerle dolu kod çoğu zaman generics'in ya da düzgün bir interface'in niyeti daha iyi ifade edeceğine ve hataları derleme zamanında yakalayacağına işarettir.

Sık yapılan hatalar

• Güvenilmeyen veride panic yapan biçimi kullanmak. Çözülmüş JSON, any tipindeki map değerleri, eklenti girdileri: her zaman virgül-ok.
• Yanlış sayısal tipe assertion. JSON sayıları any içine float64 olarak çözülür, bu yüzden v.(int) onlarda başarısız olur.
• Pointer saklanmışken değer tipine assertion. Interface *User tutuyorsa v.(User) başarısız olur. v.(*User) ile assertion yapın.
• Hatalar üzerinde type assertion. errors.As kullanın.