feof()

Introduzione alla funzione PHP feof()

La funzione feof() in PHP verifica se è stata raggiunta la fine del file (EOF) su un puntatore a file aperto. Mentre si legge un file con funzioni come fgets() o fread(), PHP mantiene un cursore interno che avanza ad ogni lettura. feof() restituisce true una volta che una lettura ha tentato di superare l'ultimo byte.

Questa pagina tratta la sintassi di feof(), la sottigliezza che trae in inganno la maggior parte delle persone (esattamente quando restituisce true), il pattern di ciclo consigliato e un errore comune da evitare.

Se non hai esperienza con l'apertura e la lettura di file, inizia da Aprire e leggere un file in PHP.

Sintassi

La sintassi della funzione feof() è la seguente:

La sintassi PHP di feof()

bool feof ( resource $stream )

• $stream: il puntatore al file (una risorsa) da verificare.
• Restituisce: bool — true se il puntatore al file è alla fine del file oppure si è verificato un errore, false altrimenti.

Parametri

La funzione feof() accetta un parametro obbligatorio:

1. $stream: Il puntatore al file che si desidera verificare. Deve essere una risorsa valida aperta con fopen() (o una funzione stream simile) e ancora aperta — passare un puntatore che è già stato chiuso con fclose(), o qualsiasi cosa che non sia una risorsa, genera un avviso.

Come viene rilevato l'EOF (l'insidia principale)

feof() non guarda avanti. Restituisce true solo dopo che una funzione di lettura come fgets() o fread() ha già tentato di leggere oltre la fine del file:

• Verificare feof() immediatamente dopo fopen(), prima di qualsiasi lettura, restituisce sempre false — anche su un file vuoto.
• Un file che termina con un a capo viene consumato completamente solo quando la lettura dopo l'ultima riga non restituisce nulla; è quella lettura finale a far passare feof() a true.

Per questo motivo, il modo più robusto di leggere un file è verificare il valore restituito dalla funzione di lettura, non feof() da solo. Su uno stream non ricercabile (un socket di rete o una pipe), feof() può anche restituire true solo dopo la chiusura della connessione, quindi affidarsi al risultato della lettura è più sicuro anche in quel caso.

Esempi

Ecco alcuni esempi di utilizzo della funzione feof():

Esempio 1: Verificare se la fine di un file è stata raggiunta dopo una lettura

Il seguente esempio legge la prima riga del file, poi verifica se la fine è stata raggiunta:

Verificare in PHP se la fine di un file è stata raggiunta

<?php

$fileHandle = fopen("example.txt", "r");
// Read the first line
$firstLine = fgets($fileHandle);

// Now check if we've reached the end
if (feof($fileHandle)) {
  echo "End of file reached";
} else {
  echo "End of file not reached";
}
fclose($fileHandle);
?>

Esempio 2: Pattern di ciclo standard (consigliato)

Il modo più pulito e sicuro per leggere un file riga per riga è eseguire il ciclo sul valore restituito da fgets() — restituisce false alla fine del file, quindi non è nemmeno necessario chiamare feof() esplicitamente. Questo pattern evita anche la trappola del ciclo infinito descritta di seguito:

Ciclo di lettura standard in PHP

<?php

$fileHandle = fopen("example.txt", "r");
if ($fileHandle === false) {
  die("Error: Could not open file.");
}

while (($line = fgets($fileHandle)) !== false) {
  echo $line;
}
fclose($fileHandle);
?>

Questo stampa ogni riga del file fino al raggiungimento della fine.

Esempio 3: Una demo autonoma ed eseguibile

Questo esempio crea un file temporaneo, scrive tre righe, poi lo rilegge con feof() in modo da poter vedere esattamente quando l'EOF passa a true:

Dimostrazione del comportamento di feof()

<?php

$path = tempnam(sys_get_temp_dir(), "demo");
file_put_contents($path, "line 1\nline 2\nline 3\n");

$fh = fopen($path, "r");
var_dump(feof($fh)); // false — nothing read yet

while (!feof($fh)) {
  $line = fgets($fh);
  if ($line === false) {
    break; // read failed / past EOF
  }
  echo "Read: " . trim($line) . "\n";
}

var_dump(feof($fh)); // true — last read passed EOF
fclose($fh);
unlink($path);
?>

Output atteso:

bool(false)
Read: line 1
Read: line 2
Read: line 3
bool(true)

Errore comune: il ciclo infinito

Chiamare fgets() senza verificare il suo valore restituito all'interno di un ciclo while (!feof($fh)) è rischioso. Se si verifica un errore di lettura (o lo stream non segnala mai l'EOF), feof() non diventa mai true e il ciclo gira all'infinito. Combina sempre il controllo dell'EOF con il risultato della lettura — o, più semplicemente, esegui il ciclo direttamente su fgets() come nell'Esempio 2.

Funzioni correlate

• fopen() — aprire il file e ottenere il puntatore che feof() verifica.
• fgets() — leggere una riga alla volta.
• fread() — leggere un numero fisso di byte.
• fclose() — chiudere il puntatore al termine.

Conclusione

La funzione feof() indica se una lettura ha superato la fine di un file aperto. La regola più importante è che diventa true solo dopo un tentativo di lettura, quindi i cicli di lettura più sicuri verificano direttamente il valore restituito da fgets() o fread(). Con questo pattern si evitano sia le uscite premature sia i cicli infiniti.

Pratica