Erori Go explicate: ce înseamnă și cum le repari
Mesajele de eroare Go pe care le primești cel mai des, fiecare explicat pe înțeles: ce înseamnă, de ce apare, cod greșit lângă cod corect și cum o repari. Înveți de la zero cu Curs Go: primele 15 lecții sunt gratuite.
Pagină coordonată de Tudor Andrei Dumitrescu, Senior Software Developer, fondatorul Academiei ProgramatorilorActualizat la
- 200erori
- 11capitole
- 112ușor
- 80mediu
- 8greu
Aici găsești erorile pe care le primești cel mai des când înveți sau lucrezi cu Go, explicate pe înțeles: erorile compilatorului (variabile și importuri nefolosite, nume nedefinite, tipuri care nu se potrivesc, valori returnate lipsă), panicile de la rulare (index în afara slice-ului, pointer nil, map nil, împărțire la zero) și erorile de la conversii, JSON și goroutine. Pentru fiecare vezi ce înseamnă mesajul, de ce apare, codul greșit lângă cel corect și cum o eviți pe viitor.
Erorile sunt grupate pe capitole, de la sintaxă și declarații până la concurență. Caută mesajul exact pe care l-ai primit, citește cauzele frecvente și repară codul direct în pagină: în secțiunea „Repară tu” ai un editor Go în care programul dă chiar eroarea respectivă, iar tu îl corectezi și îl rulezi.
Erori de sintaxă
syntax error: non-declaration statement outside function body Ai scris o instrucțiune (de exemplu x := 5 sau un apel de funcție) direct în fișier, în afara oricărei funcții. În afara funcțiilor Go acceptă doar declarații: var, const, type, func, import. Mută instrucțiunea în main() sau folosește var x = 5. Explicația completă → Ușor Repară tu syntax error: unexpected newline in composite literal; possibly missing comma or } Într-un literal scris pe mai multe rânduri (slice, map, struct) lipsește virgula după ultimul element. Go cere virgulă la finalul fiecărui rând, inclusiv al ultimului, înainte de acolada de pe rândul următor. Adaugă virgula și eroarea dispare. Explicația completă → Ușor Repară tu syntax error: unexpected semicolon or newline before { Ai pus acolada { pe rândul următor, după func main(), if, for sau switch. În Go acolada de deschidere trebuie să fie pe același rând cu instrucțiunea. Mut-o la finalul rândului de deasupra. Explicația completă → Ușor Repară tu syntax error: unexpected keyword else, expected } Ai scris else pe rândul de sub acolada } a lui if. În Go else trebuie să fie pe același rând cu acolada care închide if-ul: } else {. Mută else lângă acoladă. Explicația completă → Ușor Repară tu function main is undeclared in the main package Pachetul main nu are o funcție numită exact main. Probabil ai scris Main, mainn sau ai uitat funcția. Programul Go pornește din func main() din package main: redenumește funcția exact main, cu literă mică. Explicația completă → Ușor Repară tu newline in string Un șir între ghilimele duble nu are ghilimeaua de închidere pe aceeași linie. În Go, șirurile "..." nu pot continua pe linia următoare: închide ghilimelele, folosește \n pentru rând nou sau un șir între backticks pentru text pe mai multe linii. Explicația completă → Ușor Repară tu more than one character in rune literal Ai pus un text între apostrofuri. În Go, apostroful 'a' înseamnă un singur caracter (rune), nu un șir. Pentru text folosește ghilimele duble: "Ana", nu 'Ana'. Explicația completă → Ușor Repară tu invalid character U+003F '?' Go nu are operatorul ternar cond ? a : b, iar caracterul ? nu are niciun sens în limbaj. Înlocuiește expresia cu un if/else care atribuie valoarea unei variabile. Explicația completă → Ușor Repară tu syntax error: unexpected ++ at end of statement În Go, i++ este o instrucțiune, nu o expresie: nu îl poți folosi ca valoare (y := i++, f(i++), return i++). Scrie incrementarea pe o linie separată, apoi folosește variabila. Explicația completă → Ușor Repară tu unknown escape Ai un backslash urmat de o literă care nu e o secvență de escape validă, de obicei "\d" sau "\s" într-o expresie regulată sau o cale Windows. Scrie șirul între backticks (`\d+`) sau dublează backslash-ul ("\\d+"). Explicația completă → Ușor Repară tu expected 'package', found 'import' Fișierul .go nu începe cu declarația package. Orice fișier Go trebuie să înceapă (după comentarii) cu package main sau package <nume>. Adaugă linia package main deasupra importurilor. Explicația completă → Ușor Repară tu syntax error: unexpected :=, expected = Ai combinat cele două forme de declarare: var x := 5. În Go scrii fie var x = 5 (sau var x int = 5), fie x := 5, fără var. Iar în afara funcțiilor, la nivel de pachet, merge doar forma cu var și =. Explicația completă → Ușor Repară tu syntax error: unexpected name in, expected { Ai scris bucla ca în Python: for x in lista. În Go cuvântul in nu există; parcurgi o colecție cu for i, x := range lista (sau for _, x := range lista dacă nu ai nevoie de index). Explicația completă → Ușor Repară tu syntax error: unexpected name i at end of statement Pe aceeași linie au rămas două instrucțiuni lipite, iar parserul a găsit un nume unde se aștepta sfârșitul instrucțiunii. Cel mai des apare la while (care nu există în Go: scrii for i < 3 { ... }) sau când lipsește un operator ori o virgulă între două nume. Explicația completă → Ușor Repară tu syntax error: unexpected newline, expected type Ai declarat o variabilă cu var fără tip și fără valoare (var x), iar Go nu poate ghici ce tip are. Adaugă tipul (var x int) sau o valoare inițială (var x = 0, ori x := 0). Explicația completă → Ușor Repară tu syntax error: missing parameter type Un parametru al funcției nu are tip. În Go tipul se scrie după nume (func aria(l int, h int) sau prescurtat func aria(l, h int)), iar dacă un parametru are tip, toți trebuie să aibă. Explicația completă → Ușor Repară tu break is not in a loop, switch, or select Ai pus break (sau continue) într-un loc din care nu are ce buclă să oprească: într-un if din afara unei bucle, într-o funcție separată sau într-un closure. Folosește return ca să ieși din funcție, sau mută instrucțiunea în bucla pe care vrei să o oprești. Explicația completă → Ușor Repară tu label exterior defined and not used Ai pus o etichetă (exterior:) în fața unei bucle, dar niciun break, continue sau goto nu o folosește. Go tratează eticheta nefolosită ca eroare: folosește-o (break exterior) sau șterge-o. Explicația completă → Mediu Repară tu fallthrough statement out of place fallthrough poate fi doar ultima instrucțiune dintr-un case al unui switch obișnuit (nu în if, for sau type switch) și nu în ultimul case. Dacă vrei același cod pentru mai multe valori, scrie-le în același case: case 6, 7:. Explicația completă → Ușor Repară tu syntax error: imports must appear before other declarations Ai pus un import după o funcție, o variabilă, o constantă sau un tip. În Go ordinea fișierului e fixă: package, apoi toate importurile, apoi restul. Mută blocul import imediat sub linia package. Explicația completă → Mediu Repară tu syntax error: unexpected name calculeaza, expected ( Ai declarat o funcție cu nume în interiorul altei funcții. Go nu permite `func nume()` decât la nivelul pachetului; în interiorul unei funcții folosești o funcție anonimă păstrată într-o variabilă: `calculeaza := func() {...}`. Sau muți funcția în afara lui main. Explicația completă → Ușor Repară tu syntax error: var declaration not allowed in for initializer În inițializarea unui for nu poți scrie var. Folosește declararea scurtă: for i := 0; i < n; i++ { ... }. Dacă vrei un anumit tip, convertește valoarea: for i := int64(0); ... . Explicația completă → Mediu Repară tu cannot range over 10 (untyped int constant): requires go1.22 or later Codul folosește o facilitate nouă (aici range peste un număr, din Go 1.22), dar versiunea de limbaj a proiectului e mai veche. Ridică linia go din go.mod (go 1.22 sau mai nou) ori scrie codul în stilul vechi, cu for i := 0; i < n; i++. Explicația completă → Ușor Repară tu invalid digit '8' in octal literal Un număr întreg scris cu 0 în față (08, 09, 0712) este citit de Go ca număr în baza 8, unde există doar cifrele 0-7. Scoate zeroul din față (8 în loc de 08) sau, dacă e un cod cu zerouri (telefon, cod poștal), păstrează-l ca string. Explicația completă → Ușor Repară tu too many errors Compilatorul Go s-a oprit după primele 10 erori și a scris too many errors în loc să le mai listeze pe restul. Nu e o eroare separată: repară prima eroare din listă (de multe ori una singură le provoacă pe toate), apoi compilează din nou. Explicația completă → Ușor Repară tu syntax error: unexpected keyword range, expected expression Ai folosit range în afara antetului unui for (de exemplu v := range lista sau x = range s). În Go, range există doar în for ... range: scrie for i, v := range lista { ... } și lucrează cu v în corpul buclei. Explicația completă → Ușor Repară tu multiple defaults (first at main.go:8:2) Un switch sau un select are două ramuri default. Fiecare poate avea cel mult una: păstrează un singur default (de obicei la final) și mută codul celeilalte într-un case cu valoarea potrivită. Explicația completă → Variabile, importuri și nume
declared and not used: x Ai declarat o variabilă locală pe care nu o folosești nicăieri. În Go asta e eroare de compilare, nu avertisment. Folosește variabila, șterge-o sau, dacă e o valoare returnată de care nu ai nevoie, înlocuiește-i numele cu _ (identificatorul gol). Explicația completă → Ușor Repară tu "os" imported and not used Ai importat un pachet pe care nu îl folosești în fișier. În Go asta e eroare de compilare. Șterge importul sau folosește pachetul; editoarele cu goimports adaugă și șterg automat importurile. Explicația completă → Ușor Repară tu undefined: total Folosești un nume (variabilă, funcție, pachet) pe care compilatorul nu îl găsește în locul acela. Cauze tipice: greșeală de scriere sau de majuscule, variabila e declarată într-un bloc (if, for) și folosită în afara lui, sau ai uitat importul pachetului. Declară numele în locul potrivit sau corectează-l. Explicația completă → Ușor Repară tu 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ă. Explicația completă → Ușor Repară tu x redeclared in this block Același nume este declarat de două ori în același bloc (cu var, const, type sau func). Redenumește una dintre declarații sau, dacă voiai doar să schimbi valoarea, folosește = în loc de o nouă declarație. Explicația completă → Ușor Repară tu package string is not in std Importul cere un pachet care nu există în biblioteca standard, de obicei din cauza unei greșeli de scriere ("string" în loc de "strings", "maths" în loc de "math"). Corectează calea din import; pentru pachete externe, rulează go get în modulul tău. Explicația completă → Ușor Repară tu undefined: strings.toUpper (but have ToUpper) Ai scris numele unei funcții din alt pachet cu literă mică. În Go, doar numele care încep cu majusculă sunt exportate: strings.ToUpper, strconv.Itoa, json.Marshal. Compilatorul îți arată chiar numele corect în paranteză. Explicația completă → Ușor Repară tu use of untyped nil in assignment Ai scris x := nil (sau var x = nil). Din nil singur, Go nu poate deduce tipul variabilei. Declară tipul explicit: var err error, var p *Produs, var lista []string. Explicația completă → Mediu Repară tu invalid recursive type: Nod refers to itself Un struct se conține pe sine direct (de exemplu Nod are un câmp de tip Nod), deci ar avea mărime infinită. Folosește un pointer: urm *Nod. Pentru liste și arbori, legăturile sunt mereu pointeri (sau slice-uri). Explicația completă → Ușor Repară tu duplicate key "mouse" in map literal Ai scris aceeași cheie de două ori într-un literal de map. Go verifică la compilare cheile constante și refuză duplicatele, pentru că una dintre valori s-ar pierde. Șterge dublura sau corectează cheia greșită. Explicația completă → Ușor Repară tu non-name m["a"] on left side of := := declară variabile noi, deci în stânga lui poate sta doar un nume simplu. Pentru a schimba un element de map sau slice ori un câmp de struct (m["a"], s[0], p.Nume) folosește =. Explicația completă → Mediu Repară tu use of package fmt not in selector Ai folosit numele unui pachet singur, ca pe o valoare (x := strings, fmt == nil), în loc să accesezi ceva din el (strings.ToUpper). Un pachet nu e o variabilă: scrie pachet.Funcție, sau redenumește variabila care avea, de fapt, același nume cu pachetul. Explicația completă → Mediu Repară tu string (local variable) is not a type Ai folosit ca tip un nume care, în acel loc, e o variabilă sau o funcție. Cel mai des ai numit o variabilă la fel ca un tip (string := ..., produs := Produs{} urmat de var p produs) și ai ascuns tipul. Redenumește variabila. Explicația completă → Ușor Repară tu cannot use nil as int value in return statement nil este valoarea „nimic” doar pentru pointeri, slice-uri, map-uri, canale, funcții și interfețe. Un int, string, bool sau struct nu poate fi nil: întoarce valoarea zero (0, "", false, Produs{}) împreună cu eroarea. Explicația completă → Mediu Repară tu len(s) (value of type int) is not constant O constantă (const) trebuie să aibă o valoare cunoscută la compilare: literale, alte constante și operații între ele. Rezultatul unei funcții sau o variabilă se cunoaște abia la rulare, deci folosește var sau := în loc de const. Explicația completă → Ușor Repară tu invalid array length n Lungimea unui array ([n]int) trebuie să fie o constantă cunoscută la compilare. Dacă dimensiunea vine dintr-o variabilă, folosește un slice: make([]int, n). Explicația completă → Ușor Repară tu missing init expr for Max O constantă trebuie să primească valoarea chiar la declarare: const Max int = 10 sau const Max = 10. Mesajul apare și când declari mai multe constante pe un rând, dar dai mai puține valori. Dacă valoarea se schimbă mai târziu, folosește var. Explicația completă → Ușor Repară tu cannot use _ as value or type Identificatorul _ (blank) doar aruncă o valoare: poți scrie în el, dar nu poți citi din el. Dacă ai nevoie de valoare mai târziu, dă-i un nume (n, err) în loc de _. Explicația completă → Mediu Repară tu goto fin jumps over declaration of x at main.go:12:2 Un goto sare peste o declarație de variabilă, iar la eticheta destinație variabila ar exista fără să fi fost inițializată. Mută declarația înainte de goto sau, mai bine, înlocuiește goto cu return, break sau if. Explicația completă → Greu Repară tu initialization cycle for total O variabilă de la nivelul pachetului depinde, direct sau printr-o funcție, de ea însăși, deci Go nu poate decide ce să inițializeze întâi. Rupe cercul: inițializează valoarea în init() sau în main, ori scoate dependența din funcție. Explicația completă → Mediu Repară tu cannot use iota outside constant declaration iota există doar într-un bloc const, unde numără constantele (0, 1, 2...). Ai scris-o într-un var sau în corpul unei funcții. Mută valorile într-un bloc const ( A = iota; B; C ) și folosește constantele acolo unde aveai nevoie de numere. Explicația completă → Tipuri și conversii la compilare
cannot use n (variable of type int) as string value in assignment Încerci să pui o valoare de un tip într-o variabilă (sau un parametru) de alt tip. Go nu face conversii automate. Convertește explicit: strconv.Itoa(n) sau fmt.Sprint(n) pentru int în string, float64(n) pentru int în float64, ori schimbă tipul variabilei. Explicația completă → Ușor Repară tu invalid operation: a * b (mismatched types float64 and int) Faci o operație (+, -, *, /, comparație) între un float64 și un int. În Go ambii operanzi trebuie să aibă același tip. Convertește unul dintre ei: pret * float64(cantitate), sau int(x) dacă vrei rezultat întreg. Explicația completă → Ușor Repară tu invalid operation: s + n (mismatched types string and int) Încerci să lipești un număr de un text cu +. În Go + între string și int nu e permis. Transformă numărul în text cu strconv.Itoa(n) sau construiește mesajul cu fmt.Sprintf("...%d", n) ori fmt.Println cu mai multe argumente. Explicația completă → Ușor Repară tu non-boolean condition in if statement Condiția din if nu este de tip bool. În Go un număr, un string sau un pointer nu se transformă automat în adevărat/fals. Scrie comparația explicit: if n != 0, if s != "", if p != nil. Explicația completă → Ușor Repară tu invalid argument: index 5 out of bounds [0:3] Folosești un index constant care depășește dimensiunea unui array (sau a unui string constant), iar compilatorul vede asta înainte de rulare. Pentru un array de 3 elemente indicii valizi sunt 0, 1 și 2. Folosește un index mai mic decât lungimea sau mărește array-ul. Explicația completă → Ușor Repară tu 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ă. Explicația completă → Ușor Repară tu cannot use 300 (untyped int constant) as byte value in variable declaration (overflows) Valoarea constantă nu încape în tipul ales: un byte (uint8) ține doar 0-255, un int8 ține -128..127. Alege un tip mai mare (int, int32, int64) sau verifică dacă valoarea e corectă. Explicația completă → Ușor Repară tu cannot use 2.5 (untyped float constant) as int value in variable declaration (truncated) Ai pus un număr cu zecimale într-o variabilă de tip int. Go nu taie zecimalele în tăcere la constante. Folosește float64 pentru valori zecimale, sau un număr întreg dacă chiar vrei int. Explicația completă → Mediu Repară tu invalid operation: a == b (slice can only be compared to nil) În Go nu poți compara două slice-uri (sau map-uri, sau funcții) cu ==. Singura comparație permisă este cu nil. Pentru conținut folosește slices.Equal(a, b), maps.Equal(m1, m2) sau reflect.DeepEqual. Explicația completă → Ușor Repară tu cannot index n (variable of type int) Ai folosit [] pe o valoare care nu se poate indexa (un număr, un struct, un pointer la slice). Doar șirurile, slice-urile, array-urile și map-urile se indexează. Pentru cifrele unui număr, transformă-l întâi în text cu strconv.Itoa. Explicația completă → Mediu Repară tu invalid operation: cannot call total (variable of type int): int is not a function Ai pus () după ceva care nu e funcție: o variabilă de tip int, string sau struct. Cel mai des, o variabilă locală are același nume ca o funcție și o ascunde. Redenumește variabila sau verifică ce ai vrut să apelezi. Explicația completă → Ușor Repară tu invalid append: argument must be a slice; have m (variable of type map[string]int) append funcționează doar pe slice-uri. Pentru un map adaugi direct cu m[cheie] = valoare, iar pentru un string concatenezi cu +. Verifică tipul variabilei pe care o dai lui append. Explicația completă → Mediu Repară tu 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. Explicația completă → Mediu Repară tu 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). Explicația completă → Ușor Repară tu invalid operation: s[0] == "a" (mismatched types byte and untyped string) s[0] dintr-un string este un byte (un număr), iar "a" este un string. Compară cu un caracter scris între apostrofuri: s[0] == 'a', sau compară texte: strings.HasPrefix(s, "a"), s[:1] == "a". Explicația completă → Ușor Repară tu invalid operation: operator % not defined on x (variable of type float64) Restul împărțirii (%) există în Go doar pentru numere întregi. Pentru float64 folosește math.Mod(x, y), sau convertește la int dacă valorile sunt de fapt întregi. Explicația completă → Ușor Repară tu invalid operation: s++ (non-numeric type string) ++ și -- funcționează doar pe numere. Ai aplicat ++ unui string, bool sau struct, de cele mai multe ori pentru că variabila nu era cea pe care o credeai (textul în loc de contor). Incrementează contorul numeric sau adaugă text cu +=. Explicația completă → Ușor Repară tu invalid argument: n (variable of type int) for built-in len len măsoară doar string-uri, slice-uri, array-uri, map-uri și canale. Pe un număr nu are sens: pentru numărul de cifre folosește len(strconv.Itoa(n)), iar pe un struct aplică len pe câmpul care e colecție (len(c.Produse)). Explicația completă → Ușor Repară tu cannot range over p (variable of struct type Produs) range merge peste slice-uri, array-uri, string-uri, map-uri, canale, numere întregi și funcții iterator, dar nu peste un struct sau un pointer la slice. Parcurge câmpul care e colecție (range c.Produse) sau dereferențiază pointerul (range *p). Explicația completă → Mediu Repară tu range over ch (variable of type chan int) permits only one iteration variable Ai pus două variabile (i, v) într-un range care dă o singură valoare: un canal (doar valorile primite), un număr întreg (doar indicii) sau un iter.Seq. Păstrează o singură variabilă: for v := range ch, for i := range 10. Explicația completă → Ușor Repară tu 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. Explicația completă → Mediu Repară tu invalid map key type []string Cheia unui map trebuie să fie un tip comparabil cu ==. Slice-urile, map-urile, funcțiile și struct-urile care conțin astfel de câmpuri nu pot fi chei. Folosește un string construit din valori (strings.Join), un array de lungime fixă sau un struct doar cu câmpuri comparabile. Explicația completă → Mediu Repară tu invalid operation: cannot take address of f() (value of type int) Operatorul & merge doar pe lucruri care au o locație în memorie: variabile, câmpuri, elemente de slice sau array, literale de struct. Rezultatul unei funcții, o constantă sau un element de map nu au adresă: pune valoarea întâi într-o variabilă și ia adresa variabilei. Explicația completă → Ușor Repară tu duplicate case "a" (constant of type string) in expression switch Aceeași valoare constantă apare în două case-uri ale aceluiași switch, deci al doilea nu s-ar executa niciodată. Șterge duplicatul sau unește codul într-un singur case; de multe ori duplicatul ascunde o greșeală de tastare ("a" în loc de "b"). Explicația completă → Ușor Repară tu invalid composite literal type int Acoladele Tip{...} creează doar struct-uri, array-uri, slice-uri și map-uri. Pentru un număr, un string sau un pointer folosește conversia int(x), valoarea simplă sau &Tip{...}. Explicația completă → Ușor Repară tu missing key in map literal Într-un literal de map fiecare element trebuie scris ca cheie: valoare. Ai pus doar valori, ca într-un slice. Scrie map[string]int{"mouse": 5}, sau folosește un slice dacă nu ai chei. Explicația completă → Ușor Repară tu invalid case s in switch on n (mismatched types string and int) Valoarea dintr-un case are alt tip decât expresia din switch, de exemplu un string comparat cu un int. Toate ramurile trebuie să aibă tipul expresiei: convertește valoarea (strconv.Itoa, strconv.Atoi) sau schimbă expresia din switch. Explicația completă → Mediu Repară tu invalid operation: shift count x (variable of type float64) must be integer Operatorii << și >> mută biții cu un număr întreg de poziții, iar tu ai pus în dreapta un float64 (sau un string). Convertește numărul de poziții la întreg: 1 << uint(n), ori folosește math.Pow dacă voiai de fapt o putere cu zecimale. Explicația completă → Ușor Repară tu cannot slice n (variable of type int) Expresia a[i:j] merge doar pe string-uri, slice-uri, array-uri și pointeri la array. Ai aplicat-o pe un număr, un map sau un struct. Pentru cifrele unui număr convertește-l întâi în text cu strconv.Itoa; pentru map-uri parcurge cheile. Explicația completă → Ușor Repară tu missing argument in conversion to int Ai scris o conversie fără valoare, de exemplu int() sau float64(). O conversie primește exact o valoare între paranteze: int(x). Dacă voiai valoarea zero, scrie direct 0 sau var x int. Explicația completă → Ușor Repară tu invalid operation: make([]int) expects 2 or 3 arguments; found 1 make pentru un slice cere lungimea: make([]int, 0) sau make([]int, 0, 10). La map și canal lungimea e opțională. Dacă vrei doar un slice gol, scrie []int{} sau var s []int. Explicația completă → Ușor Repară tu invalid argument: s (variable of type []int) is not a map Funcția delete șterge doar chei din map-uri. Pentru a elimina un element dintr-un slice folosește slices.Delete(s, i, i+1) sau append(s[:i], s[i+1:]...), ori slices.DeleteFunc pentru o condiție. Explicația completă → Ușor Repară tu invalid argument: index f (variable of type float64) must be integer Ai folosit un număr cu zecimale (float64) ca index într-un slice, array sau string. Indicii trebuie să fie întregi: calculează indexul cu int (de ex. (st+dr)/2 cu variabile int) sau convertește explicit, int(f), după ce te-ai asigurat că valoarea e întreagă. Explicația completă → Mediu Repară tu invalid copy: argument must be a slice; have a (variable of type [3]int) copy(dst, src) lucrează doar cu slice-uri (și cu un string ca sursă), iar tu i-ai dat un array, un map sau un număr. Pentru array-uri transmite felii: copy(a[:], b[:]); pentru array-uri de aceeași dimensiune poți scrie direct a = b. Explicația completă → Mediu Repară tu invalid use of [...] array (outside a composite literal) Forma [...]T (array cu lungimea dedusă) e permisă doar într-un literal cu valori, de exemplu [...]int{1, 2, 3}. Într-o declarație fără valori, la un parametru sau la un câmp scrie lungimea explicit ([3]int) sau folosește un slice ([]int). Explicația completă → Funcții și valori returnate
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. Explicația completă → Ușor Repară tu assignment mismatch: 1 variable but strconv.Atoi returns 2 values Funcția apelată întoarce două valori (de obicei rezultatul și o eroare), dar tu le primești într-o singură variabilă. Primește-le pe amândouă: n, err := strconv.Atoi(s), apoi verifică err. Dacă sigur nu ai nevoie de eroare, scrie n, _ := ... Explicația completă → Mediu Repară tu multiple-value strconv.Atoi("5") (value of type (int, error)) in single-value context Folosești direct, într-o expresie, rezultatul unei funcții care întoarce două valori. Go nu poate pune (int, error) acolo unde e nevoie de o singură valoare. Salvează întâi rezultatele în variabile (n, err := ...), verifică err, apoi folosește n. Explicația completă → Ușor Repară tu not enough arguments in call to f Apelezi o funcție cu mai puține argumente decât cere semnătura ei. Sub mesaj, Go îți arată have (ce ai trimis) și want (ce așteaptă). Adaugă argumentele lipsă, în ordinea și cu tipurile din want. Explicația completă → Ușor Repară tu too many arguments in call to f Apelezi o funcție cu mai multe argumente decât parametrii ei. Compară have (ce ai trimis) cu want (ce cere funcția) de sub mesaj, apoi elimină argumentul în plus sau adaugă parametrul în definiția funcției. Explicația completă → Ușor Repară tu 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. Explicația completă → Ușor Repară tu append(q, 2) (value of type []int) is not used Ai apelat append fără să salvezi rezultatul. append nu modifică slice-ul pe loc, ci întoarce unul nou. Scrie mereu s = append(s, x). Explicația completă → Ușor Repară tu expression in defer must be function call După defer (și după go) trebuie să fie un apel de funcție, cu paranteze: defer f.Close(), nu defer f.Close. Adaugă parantezele și argumentele, sau învelește codul într-o funcție anonimă: defer func() { ... }(). Explicația completă → Ușor Repară tu f() (no value) used as value Folosești rezultatul unei funcții care nu întoarce nimic. Fie funcția modifică datele pe loc (sort.Ints, slices.Sort), deci o apelezi singură și folosești apoi variabila, fie trebuie să-i adaugi un tip de return și un return. Explicația completă → Greu Repară tu 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. Explicația completă → Ușor Repară tu cannot use ... in call to non-variadic strings.Join Ai pus ... după un slice (f(s...)), dar funcția nu e variadică: primește slice-ul ca un singur argument. Scoate ... și transmite slice-ul direct: strings.Join(parti, ", "). ... e doar pentru funcții declarate cu ...T. Explicația completă → Ușor Repară tu can only use ... with final parameter Parametrul variadic (...T) trebuie să fie ultimul din lista funcției și poate exista unul singur. Mută-l la final (func log(nivel string, mesaje ...string)), iar dacă ai nevoie de două liste, folosește slice-uri obișnuite. Explicația completă → Greu Repară tu panic: runtime error: range function continued iteration after function for loop body returned false Iteratorul tău (o funcție func(yield func(T) bool)) continuă să cheme yield după ce bucla for ... range s-a oprit cu break sau return. Verifică rezultatul lui yield și ieși imediat: if !yield(v) { return }. Explicația completă → Structs, metode, interfețe și generice
p.Pret undefined (type Produs has no field or method Pret) Accesezi un câmp sau o metodă care nu există pe tipul acela: numele e scris greșit, câmpul nu a fost declarat în struct sau metoda e definită pe alt tip. Verifică definiția struct-ului și adaugă câmpul ori corectează numele. Explicația completă → Ușor Repară tu p.nume undefined (type Produs has no field or method nume, but does have field Nume) Ai scris numele câmpului cu altă literă mică/mare decât în definiție. Go face diferența între majuscule, iar compilatorul îți spune chiar numele corect: but does have field Nume. Folosește p.Nume. Explicația completă → Mediu Repară tu Cerc does not implement Forma (missing method Arie) Folosești un tip acolo unde se cere o interfață, dar tipului îi lipsește una dintre metodele interfeței (sau o are cu alt nume ori altă semnătură). Adaugă metoda exact cum e declarată în interfață: același nume, aceiași parametri, același rezultat. Explicația completă → Greu Repară tu Patrat does not implement Forma (method Arie has pointer receiver) Metoda interfeței e definită pe pointer (func (p *Patrat) Arie()), dar tu folosești o valoare Patrat{}. Doar *Patrat implementează interfața. Pune adresa: &Patrat{...}, sau schimbă receptorul metodei în valoare dacă metoda nu modifică struct-ul. Explicația completă → Mediu Repară tu cannot assign to struct field m["a"].Nume in map Încerci să modifici direct un câmp al unui struct păstrat ca valoare într-un map. Valorile din map nu sunt adresabile. Citește struct-ul într-o variabilă, modifică-l și pune-l înapoi (v := m[k]; v.Stoc--; m[k] = v), sau păstrează pointeri în map (map[string]*Produs). Explicația completă → Mediu Repară tu cannot assign to s[0] (neither addressable nor a map index expression) Încerci să schimbi un caracter dintr-un string cu s[i] = .... În Go string-urile sunt imuabile. Transformă textul în []rune (sau []byte), modifică slice-ul, apoi convertește înapoi cu string(r). Explicația completă → Greu Repară tu string does not satisfy Numar (string missing in int | float64) Apelezi o funcție generică cu un tip care nu respectă constrângerea parametrului de tip. Aici Numar acceptă doar int și float64, iar tu ai trimis string. Trimite un tip permis sau extinde constrângerea (de exemplu cu cmp.Ordered dacă ai nevoie doar de comparații). Explicația completă → Ușor Repară tu unknown field Name in struct literal of type Produs Ai folosit într-un literal de struct un câmp care nu există în tip, de obicei scris greșit sau cu altă literă mare/mică. Verifică definiția struct-ului; Go îți arată adesea și numele corect: "but does have Nume". Explicația completă → Ușor Repară tu too few values in struct literal of type Produs Ai creat un struct fără nume de câmpuri (Produs{"Mouse"}), dar nu ai dat valori pentru toate câmpurile, în ordine. Folosește forma cu nume (Produs{Nume: "Mouse"}), în care câmpurile lipsă primesc valoarea zero. Explicația completă → Mediu Repară tu ambiguous selector c.Nume Struct-ul tău încorporează (embedding) două tipuri care au amândouă un câmp sau o metodă cu același nume, deci Go nu știe pe care îl vrei. Scrie calea completă (c.Persoana.Nume) sau declară un câmp propriu cu acel nume. Explicația completă → Mediu Repară tu cannot call pointer method Depune on Cont Metoda are receptor pointer (func (c *Cont) ...), dar o apelezi pe o valoare care nu are adresă: un element de map sau rezultatul unei funcții. Pune valoarea într-o variabilă, sau ține în map pointeri (map[string]*Cont). Explicația completă → Mediu Repară tu f.Arie undefined (type *Forma is pointer to interface, not interface) Ai declarat un parametru ca pointer la interfață (*Forma). Aproape niciodată nu ai nevoie de asta: o interfață poate ține deja un pointer. Schimbă parametrul în Forma și transmite valoarea direct, fără &. Explicația completă → Mediu Repară tu cannot define new methods on non-local type int Poți adăuga metode doar tipurilor declarate în pachetul tău. Pentru int, string, time.Duration sau tipuri din alte pachete, declară un tip nou pe baza lor (type Lei float64) și pune metodele pe el, sau scrie o funcție obișnuită. Explicația completă → Mediu Repară tu in call to NouaCoada, cannot infer T Funcția generică nu primește niciun argument din care Go să deducă parametrul de tip T (de obicei o funcție care creează ceva gol). Dă tipul explicit la apel: NouaCoada[string](). Explicația completă → Mediu Repară tu invalid operation: a > b (type parameter T cannot use operator >) Constrângerea parametrului de tip (de obicei any) nu garantează că tipul suportă operatorul folosit (>, <, +). Folosește o constrângere potrivită: cmp.Ordered pentru comparații, o uniune de tipuri numerice pentru +, comparable pentru ==. Explicația completă → Ușor Repară tu field and method with the same name Pret Struct-ul are un câmp și o metodă cu același nume (câmpul Pret și metoda Pret()), iar p.Pret ar fi ambiguu. Redenumește unul dintre ele: câmpul cu literă mică (pret) și metoda Pret(), sau metoda după ce calculează (PretCuTVA). Explicația completă → Ușor Repară tu method Produs.Pret already declared at main.go:9:17 Același tip are două metode cu același nume, de exemplu una pe valoare (p Produs) și una pe pointer (p *Produs). În Go un tip poate avea o singură metodă cu un anumit nume, indiferent de receiver și de parametri: șterge-o pe una sau redenumește-o. Explicația completă → Mediu Repară tu cannot use type Numar outside a type constraint: interface contains type constraints O interfață cu o listă de tipuri (interface{ int | float64 }) sau cmp.Ordered este o constrângere pentru generice, nu un tip obișnuit: nu poți declara variabile, parametri sau slice-uri de acel tip. Folosește-o între paranteze drepte: func Suma[T Numar](x []T) T. Explicația completă → Mediu Repară tu not enough type arguments for type Pereche: have 1, want 2 Un tip generic cu mai mulți parametri (Pereche[K, V]) a fost folosit cu prea puține argumente de tip (Pereche[string]). Spre deosebire de funcții, la tipuri Go nu deduce argumentele: scrie-le pe toate, de exemplu Pereche[string, int]. Explicația completă → Mediu Repară tu impossible type assertion: f.(Cerc) Tipul din aserțiune nu implementează interfața, deci valoarea nu poate fi niciodată de acel tip. De obicei metodele au receiver pointer: scrie f.(*Cerc) în loc de f.(Cerc). Rândul următor din mesaj spune metoda care lipsește. Explicația completă → Mediu Repară tu 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). Explicația completă → Mediu Repară tu invalid operation: Stiva[int] (Stiva is not a generic type) Ai pus un parametru de tip între paranteze pătrate (Stiva[int]) la un tip care nu e generic. Fie declari tipul cu parametru, type Stiva[T any] struct{...}, fie scoți [int] de la folosire. Explicația completă → Mediu Repară tu invalid map key type K (missing comparable constraint) Într-o funcție sau un tip generic folosești parametrul K ca cheie de map, dar constrângerea lui e any. Cheile trebuie să suporte ==, deci constrângerea trebuie să fie comparable (sau cmp.Ordered dacă vrei și sortare): [K comparable]. Explicația completă → Ușor Repară tu syntax error: missing type constraint Ai declarat un parametru de tip fără constrângere, de exemplu func Max[T](a, b T). Fiecare parametru de tip are nevoie de una: any, comparable, cmp.Ordered sau o interfață proprie: func Max[T cmp.Ordered](a, b T) T. Explicația completă → Mediu Repară tu invalid receiver type Forma (pointer or interface type) Ai încercat să scrii o metodă pe o interfață (sau pe un tip definit ca pointer). În Go, metodele se definesc doar pe tipuri concrete: scrie o funcție obișnuită care primește interfața, func Descriere(f Forma) string, sau pune metoda pe fiecare struct. Explicația completă → Ușor Repară tu duplicate method Arie Aceeași metodă apare de două ori în lista unei interfețe (de obicei după un copy-paste sau după ce ai unit două interfețe). Șterge una dintre declarații; dacă au semnături diferite, alege una și redenumește-o pe cealaltă. Explicația completă → Mediu Repară tu embedded field type cannot be a pointer to an interface Ai încorporat într-un struct un pointer la o interfață (*Logger). Interfețele se încorporează direct, fără steluță: struct{ Logger }. O valoare de interfață poate deja ține un pointer la tipul concret, deci *Logger nu îți aduce nimic. Explicația completă → Greu Repară tu interface method must have no type parameters Ai pus parametri de tip pe o metodă dintr-o interfață (Pune[T any](v T)). Metodele din interfețe nu pot fi generice; fă interfața însăși generică, type Cache[T any] interface { Pune(cheie string, v T) }, și alege T când o folosești. Explicația completă → Panici la rulare
panic: runtime error: index out of range [3] with length 3 Ai accesat un element al unui slice (sau string) la un index care nu există: aici indexul 3 într-o listă cu 3 elemente, unde indicii valizi sunt 0, 1 și 2. Folosește i < len(s) în bucle, range pentru parcurgere și verifică lungimea înainte de s[0] sau s[i+1]. Explicația completă → Mediu Repară tu panic: runtime error: slice bounds out of range [:5] with capacity 3 Ai făcut o felie s[a:b] cu limite care depășesc slice-ul (sau string-ul): aici ai cerut primele 5 elemente dintr-un slice cu capacitatea 3. Limitează capătul cu min(b, len(s)) și verifică a <= b <= len(s). Explicația completă → Mediu Repară tu panic: runtime error: invalid memory address or nil pointer dereference Ai folosit un pointer care este nil: ai citit un câmp sau ai apelat o metodă printr-un pointer care nu indică spre nicio valoare. Inițializează pointerul (p := &Produs{} sau un constructor) și verifică if p != nil înainte de folosire, mai ales după funcții care pot întoarce nil. Explicația completă → Ușor Repară tu panic: assignment to entry in nil map Scrii o cheie într-un map care nu a fost creat: e declarat cu var m map[string]int, deci este nil. Un map nil poate fi citit, dar nu poate primi valori. Creează-l cu make(map[string]int) sau cu un literal map[string]int{} înainte de prima scriere. Explicația completă → Ușor Repară tu panic: runtime error: integer divide by zero Ai împărțit un întreg la zero (sau ai folosit % cu zero). La numere întregi Go oprește programul cu panică. Verifică împărțitorul înainte: if n == 0 { ... }, și tratează cazul separat (mesaj, valoare implicită sau eroare returnată). Explicația completă → Mediu Repară tu 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. Explicația completă → Mediu Repară tu panic: runtime error: makeslice: len out of range Ai apelat make([]T, n) cu un n negativ (sau uriaș), calculat la rulare. Verifică de unde vine lungimea: de obicei e o diferență care a ieșit negativă. Limitează valoarea la 0 sau validează datele înainte de make. Explicația completă → Mediu Repară tu panic: runtime error: negative shift amount Ai făcut o deplasare pe biți (x << n sau x >> n) cu un n negativ calculat la rulare. De obicei e o poziție numerotată de la 1 transformată greșit (n-1 cu n = 0). Verifică indexul bitului înainte de shift. Explicația completă → Mediu Repară tu panic: runtime error: hash of unhashable type []int Ai folosit ca cheie într-un map[any]... (sau map cu cheie interfață) o valoare care nu poate fi cheie: un slice, un map sau o funcție. Folosește o cheie comparabilă: un array de mărime fixă, un struct fără slice-uri sau un string construit din valori. Explicația completă → Mediu Repară tu panic: regexp: Compile(`(\d+`): error parsing regexp: missing closing ): `(\d+` Expresia regulată dată lui regexp.MustCompile are o greșeală de sintaxă (aici, o paranteză neînchisă), iar MustCompile oprește programul cu panică. Corectează modelul; pentru modele venite din exterior, folosește regexp.Compile și verifică eroarea. Explicația completă → Mediu Repară tu panic: errors: target must be a non-nil pointer Ai dat lui errors.As variabila țintă în loc de adresa ei. Al doilea argument trebuie să fie un pointer la o variabilă de tipul erorii căutate: errors.As(err, &e), nu errors.As(err, e). Explicația completă → Mediu Repară tu panic: time: missing Location in call to Date time.Date a primit un *time.Location nil, de obicei rezultatul unui time.LoadLocation care a eșuat și a cărui eroare a fost ignorată. Verifică eroarea de la LoadLocation sau folosește direct time.UTC ori time.Local. Explicația completă → Ușor Repară tu panic: strings: negative Repeat count Ai apelat strings.Repeat cu un număr negativ de repetări, de obicei rezultatul unei scăderi (latime - len(text)) când textul e mai lung decât spațiul. Limitează valoarea la zero înainte: max(0, n). Explicația completă → Mediu Repară tu panic: strings: illegal use of non-zero Builder copied by value Ai copiat un strings.Builder care avea deja conținut (l-ai transmis prin valoare unei funcții sau l-ai atribuit altei variabile) și apoi ai scris în copie. Transmite-l prin pointer (*strings.Builder) sau ca io.Writer. Explicația completă → Ușor Repară tu panic: strings.NewReplacer: odd argument count strings.NewReplacer primește perechi „vechi, nou”, deci numărul de argumente trebuie să fie par. Ți-a scăpat înlocuitorul pentru ultimul text (sau o virgulă a unit două texte). Completează perechea lipsă. Explicația completă → Mediu Repară tu runtime: goroutine stack exceeds 1000000000-byte limit O funcție se apelează pe ea însăși la nesfârșit (recursivitate fără caz de oprire sau cu un caz care nu e atins niciodată), iar stiva goroutinei a depășit limita. Adaugă sau repară condiția de oprire, ori verifică metodele String() / MarshalJSON care se apelează singure. Explicația completă → Ușor Repară tu panic: invalid argument to Intn rand.Intn(n) a primit n <= 0, de obicei len() al unei liste goale când alegi un element la întâmplare. Verifică lista înainte: if len(s) == 0 { ... } și abia apoi s[rand.Intn(len(s))]. Explicația completă → Ușor Repară tu panic: slices.Max: empty list slices.Max (și slices.Min, MaxFunc, MinFunc) panichează pe un slice gol, pentru că nu există un maxim. Verifică len(s) > 0 înainte de apel și tratează separat cazul fără date. Explicația completă → Mediu Repară tu panic: makechan: size out of range make(chan T, n) a primit o capacitate negativă (sau uriașă), calculată la rulare. Capacitatea unui canal trebuie să fie între 0 și o limită de memorie: verifică valoarea înainte (de ex. -1 citit din configurare ca „fără limită”) și folosește max(n, 0) sau o valoare implicită. Explicația completă → strconv și JSON
strconv.Atoi: parsing "12a": invalid syntax Textul trimis la strconv.Atoi nu este un număr întreg valid: conține litere, spații, zecimale sau e gol. Curăță textul înainte (strings.TrimSpace), folosește ParseFloat pentru zecimale și tratează întotdeauna eroarea întoarsă. Explicația completă → Ușor Repară tu strconv.ParseFloat: parsing "12,5": invalid syntax strconv.ParseFloat acceptă doar punctul ca separator zecimal. Un preț scris în format românesc, cu virgulă (12,5), dă invalid syntax. Înlocuiește virgula cu punct înainte de conversie: strings.Replace(s, ",", ".", 1). Explicația completă → Mediu Repară tu json: cannot unmarshal string into Go struct field Produs.pret of type float64 În JSON câmpul pret este un text ("12.5"), dar în struct l-ai declarat float64. Fie corectezi JSON-ul să trimită număr (12.5), fie adaugi opțiunea ,string în tag (json:"pret,string"), fie declari câmpul string și îl convertești tu. Explicația completă → Mediu Repară tu invalid character '}' looking for beginning of object key string Textul JSON nu este valid: după o virgulă urmează direct } (virgulă în plus la final) sau o cheie fără ghilimele. În JSON cheile se scriu între ghilimele duble și nu se pune virgulă după ultimul element. Corectează textul JSON. Explicația completă → Mediu Repară tu unexpected end of JSON input Textul JSON s-a terminat înainte să fie complet: lipsește o acoladă sau o paranteză de închidere, textul e trunchiat sau e chiar gol. Verifică ce primești în date (afișează-l), închide toate { și [ și tratează separat cazul în care corpul e gol. Explicația completă → Ușor Repară tu json: Unmarshal(non-pointer main.Produs) Ai trimis la json.Unmarshal variabila însăși (p), nu adresa ei (&p). Unmarshal are nevoie de un pointer ca să poată scrie datele în variabila ta. Scrie json.Unmarshal(data, &p). Explicația completă → Mediu Repară tu json: unsupported type: func() float64 json.Marshal a întâlnit un câmp exportat de un tip care nu are reprezentare JSON: funcție, canal, număr complex. Exclude câmpul cu tag-ul json:"-" sau fă-l neexportat (literă mică). Explicația completă → Mediu Repară tu invalid character '{' after top-level value JSON-ul are, după o valoare completă, încă ceva: alt obiect (mai multe obiecte unul după altul, ca în fișierele NDJSON), o acoladă în plus sau text rămas. json.Unmarshal acceptă o singură valoare; pentru mai multe folosește json.NewDecoder și Decode într-o buclă, sau elimină caracterele în plus. Explicația completă → Mediu Repară tu json: unknown field "price" Ai activat DisallowUnknownFields pe json.Decoder, iar JSON-ul conține o cheie care nu corespunde niciunui câmp din struct (de multe ori o greșeală de nume sau un tag json diferit). Corectează cheia, adaugă câmpul cu tag-ul potrivit, sau renunță la verificarea strictă. Explicația completă → Mediu Repară tu illegal base64 data at input byte 15 Textul nu e base64 valid pentru codificarea folosită. Cel mai des decodezi cu StdEncoding un text în varianta pentru URL (cu - și _ în loc de + și /, de obicei fără = la final, ca în JWT), sau textul are spații, linii noi ori un prefix ca data:image/png;base64,. Alege codificarea potrivită (RawURLEncoding) sau curăță textul. Explicația completă → Mediu Repară tu json: error calling MarshalJSON for type *main.Pret: preț negativ Metoda ta MarshalJSON a întors o eroare (sau un JSON invalid), iar json.Marshal ți-o raportează cu tipul în față. Partea de după două puncte e cauza reală: repară datele care încalcă regula (aici un preț negativ) sau JSON-ul pe care îl construiește metoda. Explicația completă → Ușor Repară tu encoding/hex: invalid byte: U+0078 'x' hex.DecodeString a găsit un caracter care nu e cifră hexazecimală (0-9, a-f, A-F): de obicei prefixul 0x, un # de culoare, spații sau două puncte între octeți. Curăță textul înainte (strings.TrimPrefix, strings.ReplaceAll) și decodează doar cifrele. Explicația completă → Mediu Repară tu binary.Write: some values are not fixed-sized in type int encoding/binary scrie și citește doar tipuri cu dimensiune fixă (int32, uint16, float64, array-uri și struct-uri din ele). int, string și slice-urile nu au dimensiune fixă. Folosește tipuri explicite (int32, int64) și scrie textele separat, cu lungimea în față. Explicația completă → Ușor Repară tu strconv.ParseBool: parsing "da": invalid syntax strconv.ParseBool acceptă doar 1, t, T, TRUE, true, True și 0, f, F, FALSE, false, False. Orice altceva (da, nu, yes, on, un spațiu în plus) dă invalid syntax. Curăță textul cu strings.TrimSpace și tratează tu valorile proprii (da/nu) cu un switch. Explicația completă → Goroutine și canale
fatal error: all goroutines are asleep - deadlock! Toate goroutinele (inclusiv main) așteaptă la un canal sau la un WaitGroup și niciuna nu mai poate continua. Cauze tipice: trimitere fără receptor pe un canal fără buffer, range peste un canal pe care nu îl închide nimeni, wg.Wait() fără Done() suficiente. Dă fiecărei trimiteri un receptor și închide canalul la final. Explicația completă → Mediu Repară tu panic: sync: negative WaitGroup counter Ai apelat wg.Done() de mai multe ori decât wg.Add(...). Contorul WaitGroup a scăzut sub zero. Apelează wg.Add(1) o dată pentru fiecare goroutină pornită și wg.Done() o singură dată în fiecare, de preferat cu defer wg.Done(). Explicația completă → Mediu Repară tu panic: send on closed channel Ai trimis o valoare pe un canal după ce a fost închis cu close. Un canal închis poate fi citit, dar nu mai acceptă trimiteri. Închide canalul o singură dată, doar după ce toți cei care trimit au terminat (de regulă de către cel care trimite, sau după wg.Wait()). Explicația completă → Mediu Repară tu panic: close of closed channel Ai apelat close pe un canal deja închis. Un canal se poate închide o singură dată. Lasă închiderea în grija unei singure goroutine (cea care trimite) sau protejeaz-o cu sync.Once dacă mai multe locuri ar putea-o face. Explicația completă → Greu Repară tu fatal error: concurrent map writes Mai multe goroutine scriu în același map fără sincronizare. Map-urile din Go nu sunt sigure pentru acces concurent, iar runtime-ul oprește programul (nu se poate prinde cu recover). Protejează map-ul cu un sync.Mutex sau folosește sync.Map. Explicația completă → Mediu Repară tu fatal error: sync: unlock of unlocked mutex Ai apelat Unlock pe un mutex care nu era blocat, de obicei pentru că ai deblocat de două ori (un defer mu.Unlock() plus un mu.Unlock() explicit). Păstrează o singură deblocare pentru fiecare Lock, ideal cu defer imediat după Lock. Explicația completă → Mediu Repară tu context deadline exceeded Operația a durat mai mult decât termenul (timeout) al contextului, iar contextul a fost anulat. Verifică dacă timeout-ul e realist pentru operație, dacă serviciul apelat răspunde lent și tratează eroarea (reîncercare, mesaj clar), în loc să oprești programul. Explicația completă → Mediu Repară tu invalid operation: cannot send to receive-only channel <-chan int ch (variable of type <-chan int) Parametrul e declarat ca un canal doar pentru citire (<-chan T), iar funcția încearcă să trimită pe el (ch <- v) sau să-l închidă. Inversează direcția: producătorul primește chan<- T, consumatorul <-chan T. Explicația completă → Ușor Repară tu invalid operation: cannot send to non-channel []int rezultate (variable of type []int) Ai folosit <- (trimitere sau primire) pe o valoare care nu e canal, de obicei un slice. Fie declari un canal (make(chan int)), fie, dacă ai vrut un slice, folosești append în loc de <-. Explicația completă → Mediu Repară tu select case must be send or receive (possibly with assignment) Într-un select, fiecare case trebuie să fie o operație pe canal: primire (v := <-ch, <-ch) sau trimitere (ch <- v). Ai scris o condiție (len(ch) > 0, x == 5), ca într-un switch. Pune operația pe canal în case, iar condițiile le verifici în corpul ramurii sau cu un switch separat. Explicația completă → Greu Repară tu panic: sync/atomic: store of inconsistently typed value into Value Un atomic.Value poate ține un singur tip: după primul Store, toate Store-urile trebuie să fie cu exact același tip concret. Ai pus o dată Config și apoi *Config (sau int și apoi string). Păstrează același tip sau, mai simplu, folosește atomic.Pointer[Config]. Explicația completă → Fișiere, timp și rețea
open config.json: no such file or directory Fișierul pe care încerci să-l deschizi nu există la calea dată, de cele mai multe ori pentru că o cale relativă e căutată în folderul din care rulezi programul, nu lângă fișierul .go. Verifică directorul curent și calea, iar pentru fișiere opționale tratează errors.Is(err, fs.ErrNotExist). Explicația completă → Mediu Repară tu parsing time "15.03.2025" as "2006-01-02": cannot parse "15.03.2025" as "2006" Textul datei nu are formatul dat lui time.Parse. În Go, formatul se scrie cu data de referință 2006-01-02 15:04:05 (nu cu YYYY-MM-DD). Pentru o dată românească 15.03.2025, layout-ul corect este "02.01.2006". Explicația completă → Ușor Repară tu Get "localhost:8080/api": unsupported protocol scheme "localhost" URL-ul dat clientului HTTP nu începe cu http:// sau https://. Fără schemă, Go interpretează "localhost:" ca schemă (sau găsește o schemă goală) și refuză cererea. Adaugă http:// în fața adresei. Explicația completă → Ușor Repară tu listen tcp :8080: bind: address already in use Portul pe care vrei să pornești serverul e deja ocupat: de o instanță veche a programului tău, de alt server sau de un al doilea Listen pe același port în același program. Oprește procesul care ține portul (lsof -i :8080) sau alege alt port. Explicația completă → Ușor Repară tu dial tcp 127.0.0.1:8080: connect: connection refused Pe adresa și portul la care te conectezi nu ascultă niciun server. Verifică dacă serverul (aplicația, baza de date, containerul) chiar rulează, pe ce port ascultă și dacă te conectezi la hostul corect; în Docker, localhost din container nu e mașina ta. Explicația completă → Mediu Repară tu EOF EOF (io.EOF) înseamnă „s-au terminat datele”, nu o defecțiune. Îl primești de la Read, ReadString, Decode când nu mai e nimic de citit, inclusiv pe ultima linie fără \n. Verifică errors.Is(err, io.EOF) și oprește bucla, după ce procesezi ce s-a citit deja. Explicația completă → Mediu Repară tu bufio.Scanner: token too long O linie din date e mai lungă decât limita implicită a lui bufio.Scanner (64 KB), așa că Scan() se oprește și s.Err() întoarce eroarea. Mărește bufferul cu s.Buffer(make([]byte, 0, 1024*1024), 10*1024*1024) înainte de prima citire, sau folosește bufio.Reader pentru linii foarte lungi. Explicația completă → Ușor Repară tu time: missing unit in duration "30" time.ParseDuration a primit un număr fără unitate ("30"). Durata are nevoie de unitate lipită de număr: "30s", "500ms", "5m", "1h30m". Unitățile valide sunt ns, us (µs), ms, s, m, h; zile ("2d") sau "sec" nu există. Explicația completă → Ușor Repară tu panic: non-positive interval for NewTicker time.NewTicker (sau time.Tick, ticker.Reset) a primit o durată zero sau negativă, de obicei o valoare de configurare necitită sau un număr fără unitate (time.Duration(5) înseamnă 5 nanosecunde, dar 0 dacă lipsește). Validează intervalul și folosește o valoare implicită pozitivă. Explicația completă → Ușor Repară tu flag provided but not defined: -port Programul a primit în linia de comandă un flag (-port) pe care nu l-a declarat cu pachetul flag înainte de flag.Parse(). Declară-l (flag.Int("port", 8080, "...")) înainte de Parse sau verifică numele scris în comandă. Explicația completă → Ușor Repară tu mkdir rapoarte: file exists os.Mkdir încearcă să creeze un director care există deja (de la o rulare anterioară). Folosește os.MkdirAll, care nu dă eroare dacă directorul există, sau tratează errors.Is(err, fs.ErrExist). Explicația completă → Ușor Repară tu read rapoarte: is a directory Ai încercat să citești ca fișier o cale care e director, de obicei pentru că numele fișierului a lipsit din cale (filepath.Join(dir, "")). Verifică cum construiești calea; pentru conținutul unui director folosește os.ReadDir. Explicația completă → Mediu Repară tu write raport.txt: file already closed Ai scris sau citit dintr-un *os.File după ce a fost închis cu Close(), de obicei pentru că o funcție ajutătoare are defer f.Close() sau Close e în buclă. Închide fișierul o singură dată, după ultima operație, în funcția care l-a deschis. Explicația completă → Ușor Repară tu sql: no rows in result set QueryRow(...).Scan nu a găsit niciun rând pentru interogare. Nu e o defecțiune a bazei, ci răspunsul „nu există”: verifică errors.Is(err, sql.ErrNoRows) și tratează cazul separat (404, mesaj, valoare implicită). Explicația completă → Mediu Repară tu sql: unknown driver "postgres" (forgotten import?) sql.Open nu găsește un driver înregistrat cu acel nume. Driverul se înregistrează când îi imporți pachetul, de obicei doar pentru efect: import _ "github.com/lib/pq" (postgres) sau _ "github.com/go-sql-driver/mysql" (mysql). Verifică și că numele din sql.Open e exact cel al driverului. Explicația completă → Mediu Repară tu io: read/write on closed pipe Ai scris într-un io.Pipe (sau ai citit din el) după ce capătul respectiv a fost închis. Închide PipeWriter-ul abia după ultima scriere, de obicei cu defer pw.Close() în goroutine-ul care scrie, și nu închide cititorul cât timp mai vin date. Explicația completă → fmt, CSV, XML și template-uri
%!d(string=00042) Nu e o eroare de compilare, ci textul pe care fmt îl pune în rezultat când verbul nu se potrivește cu tipul: %d (număr întreg) a primit un string. Folosește verbul potrivit tipului (%s pentru string, %d pentru int, %v pentru orice) sau convertește valoarea. Explicația completă → Ușor Repară tu %!(EXTRA int=2) Numărul de verbe din șirul de format nu se potrivește cu numărul de argumente. EXTRA înseamnă argumente în plus (verb lipsă), MISSING înseamnă verb fără argument. Numără verbele (%s, %d, %v...) și argumentele și potrivește-le unul la unul. Explicația completă → Mediu Repară tu record on line 2: wrong number of fields Un rând din CSV are alt număr de coloane decât primul rând. Cel mai des fișierul folosește ; ca separator (exporturile Excel în română) sau o valoare conține virgule fără ghilimele. Setează r.Comma = ';' pentru exporturi cu punct și virgulă, ori r.FieldsPerRecord = -1 dacă rândurile pot varia. Explicația completă → Mediu Repară tu parse error on line 2, column 9: bare " in non-quoted-field O valoare din CSV conține ghilimele (de exemplu Monitor 24") fără să fie pusă ea însăși între ghilimele. Corect ar fi "Monitor 24""". Dacă nu controlezi fișierul, setează r.LazyQuotes = true ca cititorul să accepte ghilimelele rătăcite. Explicația completă → Mediu Repară tu expected element type <comanda> but have <order> xml.Unmarshal a găsit alt element rădăcină decât cel cerut de câmpul XMLName al struct-ului. Potrivește tag-ul (xml:"order") cu documentul primit sau scoate XMLName dacă nu vrei verificarea numelui. Explicația completă → Ușor Repară tu input does not match format fmt.Sscanf a găsit în text alt caracter decât cel din format, de exemplu / în loc de . la o dată. Formatul trebuie să copieze exact separatorii textului: "%d/%d/%d" pentru 15/03/2025. Pentru date calendaristice folosește mai bine time.Parse. Explicația completă → Mediu Repară tu template: eticheta:1: function "upper" not defined Șablonul (text/template sau html/template) apelează o funcție pe care nu ai înregistrat-o. Adaugă-o cu .Funcs(template.FuncMap{"upper": strings.ToUpper}) înainte de Parse; ordinea contează. Explicația completă → Mediu Repară tu template: eticheta:1:2: executing "eticheta" at <.Name>: can't evaluate field Name in type main.Produs Șablonul cere un câmp care nu există în datele primite (de obicei nume în engleză față de struct-ul în română, sau litere mici). Câmpurile folosite în șabloane trebuie să existe și să fie exportate (cu literă mare): {{.Nume}} pentru Nume string. Explicația completă → Ușor Repară tu %!s(<nil>) Ai dat lui Printf/Sprintf o valoare nil (de obicei o eroare nil sau un pointer nil) pentru %s. fmt nu dă panică, ci scrie %!s(<nil>) în text. Verifică err != nil înainte să construiești mesajul de eroare sau tratează separat cazul nil. Explicația completă → Mediu Repară tu %!w(*errors.errorString=&{fișier lipsă}) Directiva %w funcționează doar în fmt.Errorf. În Sprintf, Printf sau errors.New(fmt.Sprintf(...)) apare %!w(...) în text, iar eroarea originală nu mai e împachetată (errors.Is nu o mai găsește). Folosește fmt.Errorf("context: %w", err) pentru împachetare și %v pentru simpla afișare. Explicația completă → Mediu Repară tu %!v(PANIC=String method: runtime error: index out of range [0] with length 0) Metoda String() (sau Error()) a tipului tău a dat panică în timpul afișării, iar fmt a prins panica și a scris-o în text. Repară metoda ca să meargă și pentru valoarea zero (slice gol, câmpuri goale, pointer nil): verifică lungimea sau nil înainte să accesezi elemente. Explicația completă → Ușor Repară tu type not a pointer: int fmt.Sscan, Sscanf, Scan și Fscan scriu rezultatul în variabilele tale, deci au nevoie de adresele lor. Ai trimis valoarea (n) în loc de pointer (&n). Pune & în fața fiecărei variabile: fmt.Sscan(text, &n). Explicația completă → HTTP și URL-uri
listen tcp: address 8080: missing port in address Adresa dată lui http.ListenAndServe sau net.Listen trebuie să aibă forma host:port, iar tu ai dat doar numărul portului. Pune două puncte în față: ":8080" (toate interfețele) sau "127.0.0.1:8080" (doar local). Explicația completă → Ușor Repară tu http: named cookie not present r.Cookie("nume") nu a găsit cookie-ul în cererea primită: e prima vizită, a expirat sau are alt nume / altă cale. Nu e o eroare de server: verifică errors.Is(err, http.ErrNoCookie) și folosește o valoare implicită sau redirecționează la login. Explicația completă → Mediu Repară tu invalid URL escape "%" Un text cu % (sau alte caractere speciale) a fost pus într-un URL fără codificare, iar la citire % trebuie urmat de două cifre hex (%20, %25). Construiește parametrii cu url.Values{...}.Encode() sau url.QueryEscape, nu prin concatenare. Explicația completă → Ușor Repară tu parse "https://api.exemplu.ro/produse\n": net/url: invalid control character in URL URL-ul conține un caracter de control, aproape mereu un \n sau \r rămas la final după citirea dintr-un fișier, din stdin sau dintr-o variabilă de mediu. Curăță valoarea cu strings.TrimSpace înainte de url.Parse sau http.NewRequest. Explicația completă → Nicio eroare nu se potrivește căutării. Încearcă doar partea fixă a mesajului (fără numele variabilelor).
Erori explicate la alte tehnologii
Î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.
