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.
Explicat de Tudor Andrei Dumitrescu, Senior Software Developer, fondatorul Academiei ProgramatorilorActualizat la
Ce înseamnă
io.EOF este eroarea pe care o întorc cititorii (io.Reader, bufio.Reader, json.Decoder, csv.Reader) când au ajuns la sfârșitul datelor. Afișată, arată doar EOF, iar dacă o tratezi ca pe o eroare fatală vezi panic: EOF sau log.Fatal: EOF.
Capcana cea mai frecventă este bufio.Reader.ReadString('\n'): pentru ultima linie fără \n la final întoarce și textul liniei, și io.EOF. Dacă ieși din buclă la orice eroare înainte de a procesa textul, pierzi ultima linie.
Alte surse: json.NewDecoder(r).Decode(&v) pe un corp de cerere gol (clientul n-a trimis nimic) întoarce EOF, iar un flux tăiat la mijloc dă unexpected EOF (io.ErrUnexpectedEOF), care chiar e o eroare.
De ce apare: cauzele frecvente
1Ultima linie fără \n pierdută
for {
linie, err := r.ReadString('\n')
if err != nil {
break
}
proceseaza(linie)
}for {
linie, err := r.ReadString('\n')
if linie != "" {
proceseaza(linie)
}
if errors.Is(err, io.EOF) {
break
}
if err != nil {
return err
}
}Procesezi întâi ce s-a citit, apoi decizi după eroare. Mai simplu: bufio.Scanner, care tratează singur sfârșitul.
2EOF tratat ca eroare fatală
for {
var c Comanda
if err := dec.Decode(&c); err != nil {
panic(err)
}
}for {
var c Comanda
err := dec.Decode(&c)
if err == io.EOF {
break
}
if err != nil {
panic(err)
}
}io.EOF este semnalul normal de oprire; doar celelalte erori sunt probleme reale.
3Corp de cerere gol
var p Produs
if err := json.NewDecoder(r.Body).Decode(&p); err != nil {
http.Error(w, err.Error(), 500)
}var p Produs
err := json.NewDecoder(r.Body).Decode(&p)
if errors.Is(err, io.EOF) {
http.Error(w, "corpul cererii lipsește", 400)
return
}Un corp gol este o greșeală a clientului (400), nu a serverului; răspunsul îi spune ce lipsește.
Repară eroarea, direct în pagină
Programul citește un inventar linie cu linie cu bufio.Reader, dar ultima linie nu are \n, iar codul tratează orice eroare ca fatală: programul se oprește cu panic: EOF. Tratează sfârșitul datelor ca programul să afișeze Produse: 3, bucăți: 17.
package main
import (
"bufio"
"fmt"
"strconv"
"strings"
)
func main() {
date := "mouse 5\ntastatura 8\ncablu 4"
r := bufio.NewReader(strings.NewReader(date))
n, total := 0, 0
for {
linie, err := r.ReadString('\n')
if err != nil {
panic(err)
}
campuri := strings.Fields(linie)
buc, _ := strconv.Atoi(campuri[1])
n++
total += buc
}
fmt.Printf("Produse: %d, bucăți: %d\n", n, total)
}Produse: 3, bucăți: 17
Indiciu
Procesează linia citită înainte să verifici eroarea, iar la io.EOF ieși din buclă.
Reparația
package main
import (
"bufio"
"errors"
"fmt"
"io"
"strconv"
"strings"
)
func main() {
date := "mouse 5\ntastatura 8\ncablu 4"
r := bufio.NewReader(strings.NewReader(date))
n, total := 0, 0
for {
linie, err := r.ReadString('\n')
if campuri := strings.Fields(linie); len(campuri) == 2 {
buc, _ := strconv.Atoi(campuri[1])
n++
total += buc
}
if errors.Is(err, io.EOF) {
break
}
if err != nil {
panic(err)
}
}
fmt.Printf("Produse: %d, bucăți: %d\n", n, total)
}De ce merge
Pentru ultima linie, fără \n, ReadString întoarce textul "cablu 4" împreună cu io.EOF. Codul vechi panica înainte să o proceseze. Acum fiecare linie citită e procesată întâi, iar io.EOF doar oprește bucla, ca semnal că datele s-au terminat. Totalul: 5 + 8 + 4 = 17 bucăți în 3 produse.
Alte forme ale mesajului
panic: EOF
Cum o eviți pe viitor
Pentru citirea pe linii folosește bufio.Scanner (for s.Scan() { ... } și apoi s.Err()), care nu întoarce io.EOF deloc. Când lucrezi direct cu Read/ReadString/Decode, scrie mereu cele trei ramuri: procesează datele citite, oprește-te la io.EOF, tratează restul erorilor. Compară cu errors.Is(err, io.EOF), care merge și când eroarea e împachetată.
Întrebări frecvente
Care e diferența dintre EOF și unexpected EOF?
EOF înseamnă că datele s-au terminat la o graniță normală (între valori). unexpected EOF înseamnă că s-au terminat la mijlocul unei valori (un JSON neînchis, un fișier trunchiat) și este o eroare reală.
De ce Read poate întoarce și date, și EOF?
Interfața io.Reader permite asta: ultimul apel poate întoarce n > 0 octeți împreună cu io.EOF. De aceea regula este să procesezi întâi cei n octeți și abia apoi să te uiți la eroare.
Erori înrudite
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. 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. 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. Î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.
