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).
Explicat de Tudor Andrei Dumitrescu, Senior Software Developer, fondatorul Academiei ProgramatorilorActualizat la
Ce înseamnă
O aserțiune de tip v.(int) întreabă: „valoarea concretă ascunsă în interfața v este un int?”. Întrebarea are sens doar pentru interfețe, care pot ține valori de tipuri diferite. O variabilă de tip int este mereu int, așa că aserțiunea pe ea nu are sens și compilatorul se oprește cu invalid operation: n (variable of type int) is not an interface.
La un switch n.(type) pe o variabilă concretă mesajul este n (variable of type int) is not an interface.
Apare când vii din limbaje dinamice și „verifici tipul” peste tot, când o funcție primea înainte any și a fost schimbată să primească un tip concret, sau când confunzi aserțiunea cu conversia: pentru int spre float64 se scrie float64(n), nu n.(float64).
De ce apare: cauzele frecvente
1Conversie scrisă ca aserțiune
n := 7
x := n.(float64)n := 7
x := float64(n)Între tipuri numerice concrete se face conversie T(x), nu aserțiune.
2Type switch pe un tip concret
func descrie(v int) {
switch v.(type) {
case int:
fmt.Println("număr")
}
}func descrie(v any) {
switch v.(type) {
case int:
fmt.Println("număr")
}
}Dacă funcția trebuie să primească tipuri diferite, parametrul trebuie să fie o interfață.
3Verificare inutilă
nume := "Ana"
if s, ok := nume.(string); ok {
fmt.Println(s)
}nume := "Ana"
fmt.Println(nume)Tipul unei variabile concrete este cunoscut la compilare; nu trebuie verificat.
Repară eroarea, direct în pagină
Funcția descrie ar trebui să primească valori de tipuri diferite și să le descrie cu un type switch, dar parametrul ei este int și compilarea se oprește cu v (variable of type int) is not an interface. Schimbă parametrul ca programul să afișeze:
număr: 42
text: salutpackage main
import "fmt"
func descrie(v int) {
switch x := v.(type) {
case int:
fmt.Println("număr:", x)
case string:
fmt.Println("text:", x)
}
}
func main() {
descrie(42)
descrie("salut")
}număr: 42 text: salut
Indiciu
Type switch-ul are nevoie de un parametru de tip interfață, de exemplu any.
Reparația
package main
import "fmt"
func descrie(v any) {
switch x := v.(type) {
case int:
fmt.Println("număr:", x)
case string:
fmt.Println("text:", x)
}
}
func main() {
descrie(42)
descrie("salut")
}De ce merge
Un type switch întreabă ce tip concret se află într-o interfață, deci nu are sens pe un parametru int. Cu v any, funcția poate primi și numărul 42, și șirul "salut". Type switch-ul alege apoi ramura după tipul concret, iar în fiecare ramură x are deja tipul respectiv.
Alte forme ale mesajului
n (variable of type int) is not an interfaceinvalid operation: p (variable of struct type Produs) is not an interface
Cum o eviți pe viitor
Folosește aserțiunile și type switch-urile doar pe valori care vin ca interfață: any din JSON, error (pentru erori personalizate folosește însă errors.As), fmt.Stringer. Pentru transformări între numere folosește conversii T(x). Dacă te trezești că verifici tipuri peste tot, probabil ai nevoie de o interfață cu metode sau de generice.
Întrebări frecvente
Care e diferența dintre v.(T) și T(v)?
T(v) este o conversie între tipuri compatibile, verificată la compilare. v.(T) este o aserțiune: verifică la rulare ce tip concret e într-o interfață și poate eșua (cu panică sau cu ok == false).
Pot face aserțiune pe un error?
Da, error este o interfață: e, ok := err.(*MyErr). Totuși, errors.As este de preferat, pentru că găsește eroarea și când este împachetată cu %w.
Erori înrudite
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: operator + not defined on a (variable of interface type any) Valorile de tip any (interface{}) nu suportă operații aritmetice sau de comparare, pentru că Go nu știe ce tip concret au. Extrage tipul cu o aserțiune (v.(int)) sau un type switch, sau folosește direct tipul concret. cannot convert s (variable of type string) to type int În Go nu poți transforma un text în număr cu int(s). Conversia de tip funcționează doar între tipuri compatibile (int, float64, byte...). Pentru text folosește strconv.Atoi(s) sau strconv.ParseFloat(s, 64) și verifică eroarea întoarsă. Î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.
