result parameter err not in scope at return
Funcția are rezultate numite (func f() (n int, err error)), iar într-un bloc interior ai redeclarat cu := o variabilă cu același nume. Un return gol de acolo ar întoarce variabila exterioară, nu pe cea nouă, așa că Go îl refuză. Folosește = în loc de := sau scrie explicit valorile: return n, err.
Explicat de Tudor Andrei Dumitrescu, Senior Software Developer, fondatorul Academiei ProgramatorilorActualizat la
Ce înseamnă
Cu rezultate numite, return fără valori întoarce valorile curente ale acelor variabile. Dacă într-un bloc (if, for) scrii n, err := ..., creezi variabile noi cu aceleași nume, care le ascund pe cele ale funcției. Un return gol din acel bloc ar întoarce variabilele exterioare (probabil încă zero), nu valorile pe care tocmai le-ai calculat. Ca să prevină acest bug, compilatorul raportează result parameter err not in scope at return și arată inner declaration of var err error.
Reparațiile:
=în loc de:=, ca să atribui chiar rezultatelor numite;return n, errexplicit, care întoarce variabilele interioare;- nume diferite pentru variabilele locale.
De ce apare: cauzele frecvente
1:= în if ascunde rezultatul numit
func citeste(t string) (n int, err error) {
if t != "" {
n, err := strconv.Atoi(t)
if err != nil {
return
}
_ = n
}
return
}func citeste(t string) (n int, err error) {
if t != "" {
n, err = strconv.Atoi(t)
if err != nil {
return
}
}
return
}Cu =, strconv.Atoi scrie direct în rezultatele numite, iar return gol le întoarce.
2Return explicit
func total(p []string) (suma int, err error) {
for _, x := range p {
v, err := strconv.Atoi(x)
if err != nil {
return
}
suma += v
}
return
}func total(p []string) (suma int, err error) {
for _, x := range p {
v, err := strconv.Atoi(x)
if err != nil {
return 0, err
}
suma += v
}
return suma, nil
}return 0, err întoarce eroarea din buclă, fără ambiguitate.
Repară eroarea, direct în pagină
Funcția parseaza citește o vârstă din text și folosește rezultate numite, dar redeclară varsta și err cu := în if, iar compilarea se oprește cu result parameter varsta not in scope at return. Repară funcția ca programul să afișeze:
34 <nil>
0 strconv.Atoi: parsing "x": invalid syntaxpackage main
import (
"fmt"
"strconv"
"strings"
)
func parseaza(text string) (varsta int, err error) {
text = strings.TrimSpace(text)
if text != "" {
varsta, err := strconv.Atoi(text)
if err != nil {
return
}
_ = varsta
}
return
}
func main() {
fmt.Println(parseaza(" 34 "))
fmt.Println(parseaza("x"))
}34 <nil> 0 strconv.Atoi: parsing "x": invalid syntax
Indiciu
Atribuie rezultatelor numite cu =, nu crea variabile noi cu :=.
Reparația
package main
import (
"fmt"
"strconv"
"strings"
)
func parseaza(text string) (varsta int, err error) {
text = strings.TrimSpace(text)
if text != "" {
varsta, err = strconv.Atoi(text)
if err != nil {
return 0, err
}
}
return
}
func main() {
fmt.Println(parseaza(" 34 "))
fmt.Println(parseaza("x"))
}De ce merge
:= din if crea variabile noi, varsta și err, care le ascundeau pe cele întoarse de funcție. Un return gol ar fi întors 0 și nil chiar și după o eroare, de aceea compilatorul l-a refuzat. Cu =, strconv.Atoi scrie direct în rezultatele numite, iar pe ramura de eroare return 0, err întoarce explicit eroarea.
Alte forme ale mesajului
result parameter n not in scope at returnresult parameter err not in scope at return inner declaration of var err error
Cum o eviți pe viitor
Folosește rezultate numite doar când chiar ajută la documentare sau la defer care modifică eroarea. În rest, scrie return valoare, err explicit, mai ales în funcții cu blocuri imbricate. go vet -vettool cu analiza shadow (sau golangci-lint) găsește variabilele ascunse cu :=.
Întrebări frecvente
De ce Go nu întoarce pur și simplu variabila interioară?
Pentru că return gol înseamnă, prin definiție, „întoarce rezultatele numite ale funcției”. Variabila interioară are același nume, dar e alta; compilatorul preferă să te oprească decât să întoarcă tacit valoarea greșită.
Când sunt utile rezultatele numite?
La funcții scurte, unde numele explică ce întorci ((min, max int)), și când un defer trebuie să modifice eroarea întoarsă, de exemplu ca să o împacheteze.
Erori înrudite
no new variables on left side of := Folosești := pentru o variabilă care există deja în același bloc. := declară o variabilă nouă; ca să schimbi valoarea uneia existente, folosește =. Când ai mai multe variabile în stânga, cel puțin una trebuie să fie nouă. missing return O funcție care declară că întoarce o valoare se poate termina pe un drum fără return. Adaugă un return la finalul funcției (după if-uri și bucle), ca toate căile să întoarcă ceva. too many return values Instrucțiunea return întoarce mai multe valori decât declară funcția. Sub mesaj vezi have (ce returnezi) și want (ce e declarat). Adaugă tipurile lipsă în semnătură, de exemplu (int, error), sau returnează doar valorile declarate. Î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.
