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.
Explicat de Tudor Andrei Dumitrescu, Senior Software Developer, fondatorul Academiei ProgramatorilorActualizat la
Ce înseamnă
Mesajul are două rânduri utile: panic: runtime error: invalid memory address or nil pointer dereference și [signal SIGSEGV: segmentation violation ... addr=0x0 ...]. addr=0x0 confirmă că pointerul era nil. Linia exactă e în stiva de dedesubt, la prima funcție din codul tău.
În Go, un pointer declarat fără valoare (var p *Produs) este nil. La fel, un câmp pointer dintr-un struct, o valoare lipsă dintr-un map[string]*Produs sau rezultatul unei funcții de căutare care întoarce nil, err. Accesul p.Nume printr-un pointer nil oprește programul.
Cel mai frecvent tipar: ignori eroarea unei funcții (p, _ := gaseste(...)) și folosești rezultatul, care e nil tocmai când a apărut eroarea.
De ce apare: cauzele frecvente
1Pointer declarat, dar neinițializat
var p *Produs
p.Nume = "Mouse"p := &Produs{}
p.Nume = "Mouse"var p *Produs doar declară pointerul (valoare nil). &Produs{} creează un struct și îi ia adresa.
2Rezultatul unei căutări folosit fără verificare
p, _ := gaseste(produse, "Webcam")
fmt.Println(p.Pret)p, err := gaseste(produse, "Webcam")
if err != nil {
fmt.Println("Eroare:", err)
return
}
fmt.Println(p.Pret)Funcția întoarce nil când nu găsește produsul. Verificarea erorii te oprește înainte să folosești pointerul nil.
3Cheie lipsă într-un map de pointeri
stoc := map[string]*Produs{"mouse": {Stoc: 20}}
fmt.Println(stoc["tastatura"].Stoc)stoc := map[string]*Produs{"mouse": {Stoc: 20}}
if p, ok := stoc["tastatura"]; ok {
fmt.Println(p.Stoc)
} else {
fmt.Println("produs inexistent")
}Pentru o cheie lipsă, un map întoarce valoarea zero a tipului, adică nil pentru pointeri. Forma v, ok := m[k] îți spune dacă cheia există.
4Câmp pointer dintr-un struct, nesetat
type Comanda struct{ Client *Client }
c := Comanda{}
fmt.Println(c.Client.Nume)type Comanda struct{ Client *Client }
c := Comanda{Client: &Client{Nume: "Ana"}}
if c.Client != nil {
fmt.Println(c.Client.Nume)
}Câmpurile pointer pornesc ca nil. Setează-le la creare sau verifică-le înainte de acces.
Repară eroarea, direct în pagină
Programul caută un client după email și afișează orașul, dar pentru un email inexistent se oprește cu panic: runtime error: invalid memory address or nil pointer dereference. Repară-l verificând rezultatul căutării, ca să afișeze:
ana@exemplu.ro: Cluj
ion@exemplu.ro: client inexistentpackage main
import "fmt"
type Client struct {
Email string
Oras string
}
func gaseste(clienti []Client, email string) *Client {
for i := range clienti {
if clienti[i].Email == email {
return &clienti[i]
}
}
return nil
}
func main() {
clienti := []Client{{"ana@exemplu.ro", "Cluj"}}
for _, e := range []string{"ana@exemplu.ro", "ion@exemplu.ro"} {
c := gaseste(clienti, e)
fmt.Printf("%s: %s\n", e, c.Oras)
}
}ana@exemplu.ro: Cluj ion@exemplu.ro: client inexistent
Indiciu
Funcția gaseste întoarce nil când nu găsește clientul; verifică if c == nil înainte de c.Oras.
Reparația
package main
import "fmt"
type Client struct {
Email string
Oras string
}
func gaseste(clienti []Client, email string) *Client {
for i := range clienti {
if clienti[i].Email == email {
return &clienti[i]
}
}
return nil
}
func main() {
clienti := []Client{{"ana@exemplu.ro", "Cluj"}}
for _, e := range []string{"ana@exemplu.ro", "ion@exemplu.ro"} {
c := gaseste(clienti, e)
if c == nil {
fmt.Printf("%s: client inexistent\n", e)
continue
}
fmt.Printf("%s: %s\n", e, c.Oras)
}
}De ce merge
gaseste întoarce un pointer spre client sau nil când emailul nu există. Pentru al doilea email c era nil, iar c.Oras încerca să citească de la adresa 0, de unde panica. Verificarea if c == nil tratează cazul „negăsit” înainte de acces. Observă și &clienti[i]: luăm adresa elementului din slice, nu a variabilei de buclă, ca pointerul să indice spre datele reale.
Alte forme ale mesajului
[signal SIGSEGV: segmentation violation code=0x1 addr=0x0 pc=0x...]panic: runtime error: invalid memory address or nil pointer dereference [recovered]
Cum o eviți pe viitor
Creează valorile cu constructori care întorc pointeri gata inițializați (func NewCont(...) *Cont). Nu ignora niciodată eroarea dintr-o funcție care întoarce (*T, error): dacă e eroare, pointerul este de obicei nil. La map-uri de pointeri folosește v, ok := m[k]. Preferă valori în loc de pointeri când nu ai nevoie să modifici datele sau să exprimi „lipsă”.
Întrebări frecvente
Care e diferența între var p *Produs și p := &Produs{}?
Prima declarație creează doar pointerul, cu valoarea nil (nu indică spre nimic). A doua creează un Produs cu valori zero și pointerul spre el, care poate fi folosit imediat.
Pot apela o metodă pe un pointer nil?
Da, apelul în sine e permis, iar metoda primește p == nil. Panica apare abia când metoda accesează un câmp (p.Nume). Unele tipuri tratează intenționat cazul nil în metode.
De ce scrie segmentation violation?
Este semnalul sistemului de operare când programul încearcă să citească de la adresa 0. Go îl transformă în panica pe care o vezi.
Erori înrudite
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. 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. 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]. Î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.
