PHP file_get_contents(): leggere un file in una stringa

file_get_contents('notes.txt') legge l'intero file e lo restituisce come un'unica stringa. Se il file non si può leggere restituisce false. Per scrivere, usa file_put_contents('notes.txt', $text), che crea il file o ne sostituisce il contenuto.

<?php
file_put_contents('notes.txt', "Buy milk\nCall Ada\nWrite docs\n");

$text = file_get_contents('notes.txt');

echo $text;
echo strlen($text), " bytes\n";
echo substr_count($text, "\n"), " lines\n";

Output:

Buy milk
Call Ada
Write docs
29 bytes
3 lines

Il blocco scrive prima notes.txt e poi lo rilegge, così ha un file su cui lavorare. Un percorso come 'notes.txt' è relativo alla cartella di lavoro corrente; in un'applicazione web, costruisci il percorso a partire dalla cartella dello script con __DIR__ . '/notes.txt'.

Scrivere e aggiungere con file_put_contents()

file_put_contents() restituisce il numero di byte scritti, oppure false in caso di errore. Di default sovrascrive il file. Il flag FILE_APPEND aggiunge invece in fondo, ed è così che funzionano i log semplici, e LOCK_EX impedisce a due richieste di scrivere nello stesso momento:

<?php
$bytes = file_put_contents('log.txt', "started\n");
echo "Wrote $bytes bytes\n";

file_put_contents('log.txt', "step 1 done\n", FILE_APPEND | LOCK_EX);
file_put_contents('log.txt', "step 2 done\n", FILE_APPEND | LOCK_EX);
echo file_get_contents('log.txt'), "\n";

file_put_contents('log.txt', "replaced\n");   // no flag: the old content is gone
echo file_get_contents('log.txt'), "\n";

// An array is written with its elements joined, with nothing between them
file_put_contents('list.txt', ['a', 'b', 'c']);
echo file_get_contents('list.txt'), "\n";
echo file_put_contents('list.txt', implode("\n", ['a', 'b', 'c'])), " bytes\n";

Output:

Wrote 8 bytes
started
step 1 done
step 2 done

replaced

abc
5 bytes

Per salvare un array e riaverlo come array, scrivilo come JSON con json_encode() e leggilo con json_decode().

Leggere un file riga per riga con file()

file() legge un file in un array con una riga per elemento. Ogni riga mantiene l'a capo finale a meno che tu non passi FILE_IGNORE_NEW_LINES, e FILE_SKIP_EMPTY_LINES scarta le righe vuote (funziona solo insieme a FILE_IGNORE_NEW_LINES):

<?php
file_put_contents('todo.txt', "Buy milk\nCall Ada\n\nWrite docs\n");

$lines = file('todo.txt');
var_dump($lines[0]);   // the newline is still there

$lines = file('todo.txt', FILE_IGNORE_NEW_LINES | FILE_SKIP_EMPTY_LINES);
foreach ($lines as $i => $line) {
    echo $i + 1, ". $line\n";
}

echo count($lines), " tasks\n";

Output:

string(9) "Buy milk
"
1. Buy milk
2. Call Ada
3. Write docs
3 tasks

file() e file_get_contents() caricano l'intero file in memoria. Va bene per file di configurazione e log di qualche megabyte. Per un file di centinaia di megabyte, leggilo invece una riga alla volta con fopen() e fgets().

Verificare se un file esiste prima di leggerlo

Quando il file manca, file_get_contents() restituisce false e PHP stampa un warning:

Warning: file_get_contents(missing.txt): Failed to open stream: No such file or directory in /home/index.php on line 2

Verifica prima con is_file() (un file che esiste e non è una cartella) o file_exists() (un file o una cartella), e confronta sempre il risultato con === false, perché un file vuoto restituisce "", che è anch'esso falsy:

<?php
file_put_contents('empty.txt', '');

foreach (['empty.txt', 'missing.txt', '.'] as $path) {
    echo str_pad($path, 12);
    echo file_exists($path) ? 'exists ' : 'missing ';
    echo is_file($path) ? 'file ' : '';
    echo is_dir($path) ? 'directory ' : '';
    echo "\n";
}

$path = 'missing.txt';
if (!is_file($path) || !is_readable($path)) {
    echo "Cannot read $path, using defaults\n";
} else {
    $text = file_get_contents($path);
}

$text = file_get_contents('empty.txt');
var_dump($text === false, $text == false);   // not a failure, just empty
echo filesize('empty.txt'), " bytes\n";

Output:

empty.txt   exists file 
missing.txt missing 
.           exists directory 
Cannot read missing.txt, using defaults
bool(false)
bool(true)
0 bytes

Non nascondere il warning con @file_get_contents(). Verificare prima, o gestire false, mantiene visibile l'errore quando qualcos'altro va storto.

Leggere una parte di un file

Il quarto e il quinto argomento sono l'offset in byte da cui partire e il numero di byte da leggere. Un offset negativo conta dalla fine del file. Gli argomenti con nome permettono di saltare i due argomenti intermedi:

<?php
file_put_contents('data.txt', "HEADER\nline 2\nline 3\nlast line\n");

echo file_get_contents('data.txt', false, null, 0, 6), "\n";   // first 6 bytes
echo file_get_contents('data.txt', offset: 7, length: 6), "\n";
echo file_get_contents('data.txt', offset: -10);                 // last 10 bytes

Output:

HEADER
line 2
last line

Gli offset contano i byte, non i caratteri. In UTF-8 un carattere giapponese occupa 3 byte, quindi un offset nel mezzo di uno lo taglia a metà. Per lavorare con i caratteri, leggi l'intera stringa e usa mb_substr().

Mostrare un file di testo in una pagina web

Il contenuto di un file è testo, e il testo stampato nell'HTML deve passare per l'escape, altrimenti un < nel file diventa un tag. htmlspecialchars() applica l'escape e nl2br() trasforma gli a capo in tag <br>. Eseguilo e guarda la scheda Page:

<?php
file_put_contents('changelog.txt', <<<TXT
v1.2: Fixed <title> encoding
v1.1: Added "export" & "import"
v1.0: First release
TXT);

$text = file_get_contents('changelog.txt');
?>
<h3>Changelog</h3>
<p style="font-family: monospace"><?= nl2br(htmlspecialchars($text)) ?></p>
<p><?= count(file('changelog.txt')) ?> entries, <?= filesize('changelog.txt') ?> bytes</p>

Togli htmlspecialchars() ed eseguilo di nuovo: ora la pagina termina a "v1.2: Fixed", perché il browser legge <title> come un vero tag e inghiotte tutto ciò che segue come titolo della pagina. La pagina su htmlspecialchars() spiega perché conta per tutto ciò che un utente può scrivere.

Leggere un URL con file_get_contents()

Con allow_url_fopen attivo (il default in php.ini), file_get_contents() legge anche gli URL e restituisce il corpo della risposta. Un contesto di stream aggiunge un metodo, intestazioni, un corpo e un timeout:

<?php
$html = file_get_contents('https://example.com/');

$context = stream_context_create([
    'http' => [
        'method'  => 'POST',
        'header'  => "Content-Type: application/json\r\n",
        'content' => json_encode(['name' => 'Ada']),
        'timeout' => 5,
        'ignore_errors' => true,   // return the body of 4xx/5xx responses too
    ],
]);

$response = file_get_contents('https://api.example.com/users', false, $context);
if ($response === false) {
    // DNS failure, timeout, or a refused connection
}

Per tentativi ripetuti, redirect con limiti e codici di errore chiari, cURL o una libreria client HTTP come Guzzle sono lo strumento migliore.

file_get_contents vs file() vs fopen()

Le funzioni a chiamata singola aprono, leggono o scrivono e chiudono il file per te, quindi sono la scelta di default giusta. Usa fopen() quando il file è troppo grande per stare in memoria o devi tenerlo aperto tra un'operazione e l'altra.