invalid syntax tree: use of .(type) outside type switch
Forma x.(type) există doar în antetul unui type switch: switch v := x.(type) { case int: ... }. Pentru a afla tipul ca text folosește fmt.Sprintf("%T", x), iar pentru o verificare punctuală, v, ok := x.(int).
Explicat de Tudor Andrei Dumitrescu, Senior Software Developer, fondatorul Academiei ProgramatorilorActualizat la
Ce înseamnă
x.(type) nu este o expresie care întoarce tipul, ci o sintaxă specială a type switch-ului: switch v := x.(type) { case int: ... case string: ... }. În afara acestui loc (într-o atribuire, un if, un Println), compilatorul spune use of .(type) outside type switch (prefixul invalid syntax tree apare în versiunile recente).
De obicei vrei una din trei lucruri:
- să alegi codul după tip: type switch;
- să verifici un singur tip: aserțiunea cu
ok,n, ok := x.(int); - să afișezi tipul (pentru log sau depanare):
fmt.Sprintf("%T", x)saureflect.TypeOf(x).
În Go tipurile nu sunt valori, deci nu le poți compara cu == (int (type) is not an expression).
De ce apare: cauzele frecvente
1Tipul salvat într-o variabilă
var x any = 42
t := x.(type)
fmt.Println(t)var x any = 42
t := fmt.Sprintf("%T", x)
fmt.Println(t)%T dă numele tipului ca text: int.
2Comparație de tip într-un if
if x.(type) == string {
fmt.Println("text")
}if s, ok := x.(string); ok {
fmt.Println("text:", s)
}Aserțiunea cu ok verifică un tip și îți dă direct valoarea convertită.
Repară eroarea, direct în pagină
Funcția descrie primește valori de orice tip și ar trebui să afișeze o descriere după tip, dar nu compilează: use of .(type) outside type switch. Rescrie-o cu un type switch, ca programul să afișeze:
număr: 42
text: mouse
alt tip: boolpackage main
import "fmt"
func descrie(x any) {
tip := x.(type)
if tip == int {
fmt.Println("număr:", x)
} else if tip == string {
fmt.Println("text:", x)
} else {
fmt.Printf("alt tip: %T\n", x)
}
}
func main() {
descrie(42)
descrie("mouse")
descrie(true)
}număr: 42 text: mouse alt tip: bool
Indiciu
switch v := x.(type) { case int: ... case string: ... default: ... }, iar în default folosește %T.
Reparația
package main
import "fmt"
func descrie(x any) {
switch v := x.(type) {
case int:
fmt.Println("număr:", v)
case string:
fmt.Println("text:", v)
default:
fmt.Printf("alt tip: %T\n", v)
}
}
func main() {
descrie(42)
descrie("mouse")
descrie(true)
}De ce merge
x.(type) are sens doar în antetul unui switch, unde Go compară tipul dinamic al lui x cu fiecare case. În ramura int, v este deja un int, în ramura string un string, iar în default rămâne any, al cărui tip îl afișează %T (bool).
Alte forme ale mesajului
use of .(type) outside type switch
Cum o eviți pe viitor
Când lucrezi cu any, alege din start una din formele de mai sus. Type switch-ul e cel mai potrivit când ai 2 sau mai multe tipuri posibile, iar în ramuri v are deja tipul ramurii. În cod nou, preferă interfețe cu metode sau generice în loc de any și verificări de tip.
Întrebări frecvente
Ce tip are v într-un type switch?
În fiecare ramură cu un singur tip (case int:), v are acel tip. În ramurile cu mai multe tipuri (case int, int64:) și în default, v rămâne de tipul interfeței.
Pot compara două tipuri la rulare?
Da, cu pachetul reflect: reflect.TypeOf(a) == reflect.TypeOf(b). Dar în codul obișnuit un type switch sau o aserțiune sunt mai simple și mai rapide.
Erori înrudite
Produs (type) is not an expression Ai folosit numele unui tip acolo unde trebuia o valoare: fmt.Println(Produs), x := int, &Produs. Creează o valoare a tipului (Produs{}, Produs{Nume: "a"}, new(Produs)) sau folosește variabila pe care ai vrut să o scrii. panic: interface conversion: interface {} is string, not int Ai făcut o aserțiune de tip x.(int) pe o valoare de tip any care conține de fapt un string. Folosește forma cu două valori, v, ok := x.(int), sau un type switch, și tratează cazul în care tipul nu e cel așteptat. invalid operation: n (variable of type int) is not an interface Aserțiunea de tip x.(T) și type switch-ul merg doar pe valori de tip interfață (any, error, io.Reader...). Dacă variabila are deja un tip concret (int, string, struct), nu ai nevoie de aserțiune: folosește-o direct sau convertește cu T(x). Învață Go de la zero, cu exerciții la fiecare lecție
Curs Go: lecții scurte, fiecare cu un exercițiu verificat automat, direct în browser. Primele 15 lecții sunt gratuite.
