PHP file_get_contents(): eine Datei in einen String lesen

file_get_contents('notes.txt') liest die ganze Datei und liefert sie als einen String. Lässt sich die Datei nicht lesen, liefert es false. Zum Schreiben verwendest du file_put_contents('notes.txt', $text), das die Datei anlegt oder ersetzt, was darin stand.

<?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";

Ausgabe:

Buy milk
Call Ada
Write docs
29 bytes
3 lines

Der Block schreibt zuerst notes.txt und liest es dann zurück, damit es eine Datei zum Arbeiten gibt. Ein Pfad wie 'notes.txt' ist relativ zum aktuellen Arbeitsverzeichnis; in einer Webanwendung baust du den Pfad aus dem eigenen Ordner des Skripts mit __DIR__ . '/notes.txt'.

Mit file_put_contents() schreiben und anhängen

file_put_contents() liefert die Anzahl der geschriebenen Bytes oder false bei einem Fehler. Standardmäßig überschreibt es die Datei. Das Flag FILE_APPEND hängt stattdessen ans Ende an, so funktionieren einfache Logs, und LOCK_EX verhindert, dass zwei Anfragen im selben Moment schreiben:

<?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";

Ausgabe:

Wrote 8 bytes
started
step 1 done
step 2 done

replaced

abc
5 bytes

Um ein Array zu speichern und als Array zurückzubekommen, schreibst du es mit json_encode() als JSON und liest es mit json_decode().

Eine Datei mit file() Zeile für Zeile lesen

file() liest eine Datei in ein Array mit einer Zeile pro Element. Jede Zeile behält ihren Zeilenumbruch am Ende, außer du übergibst FILE_IGNORE_NEW_LINES, und FILE_SKIP_EMPTY_LINES lässt leere Zeilen weg (es funktioniert nur zusammen mit 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";

Ausgabe:

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

file() und file_get_contents() laden die ganze Datei in den Speicher. Für Konfigurationsdateien und Logs von ein paar Megabyte ist das in Ordnung. Für eine Datei von Hunderten Megabyte liest du sie stattdessen mit fopen() und fgets() Zeile für Zeile.

Prüfen, ob eine Datei existiert, bevor du sie liest

Fehlt die Datei, liefert file_get_contents() false, und PHP gibt eine Warnung aus:

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

Prüfe vorher mit is_file() (eine Datei, die existiert und kein Verzeichnis ist) oder file_exists() (eine Datei oder ein Verzeichnis), und vergleiche das Ergebnis immer mit === false, denn eine leere Datei liefert "", das ebenfalls falsy ist:

<?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";

Ausgabe:

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

Versteck die Warnung nicht mit @file_get_contents(). Vorher zu prüfen oder false zu behandeln, hält den Fehler sichtbar, wenn etwas anderes schiefgeht.

Einen Teil einer Datei lesen

Das vierte und fünfte Argument sind der Byte-Offset, an dem begonnen wird, und die Anzahl der zu lesenden Bytes. Ein negativer Offset zählt vom Ende der Datei. Mit benannten Argumenten überspringst du die zwei Argumente dazwischen:

<?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

Ausgabe:

HEADER
line 2
last line

Offsets zählen Bytes, keine Zeichen. In UTF-8 ist ein japanisches Zeichen 3 Bytes lang, also schneidet ein Offset mitten darin es durch. Um mit Zeichen zu arbeiten, liest du den ganzen String und verwendest mb_substr().

Eine Textdatei auf einer Webseite anzeigen

Dateiinhalt ist Text, und Text, der in HTML ausgegeben wird, muss escapt werden, sonst wird ein < in der Datei zu einem Tag. htmlspecialchars() escapt ihn, und nl2br() macht aus den Zeilenumbrüchen <br>-Tags. Führe es aus und schau dir den Tab Page an:

<?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>

Entferne htmlspecialchars() und führe es erneut aus: Die Seite endet jetzt bei „v1.2: Fixed“, weil der Browser <title> als echtes Tag liest und alles danach als Seitentitel verschluckt. Die Seite zu htmlspecialchars() erklärt, warum das bei allem zählt, was ein Nutzer schreiben kann.

Eine URL mit file_get_contents() lesen

Mit aktiviertem allow_url_fopen (der Standard in der php.ini) liest file_get_contents() auch URLs und liefert den Body der Antwort. Ein Stream-Kontext fügt eine Methode, Header, einen Body und einen Timeout hinzu:

<?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
}

Für Wiederholungen, Weiterleitungen mit Limits und klare Fehlercodes ist cURL oder eine HTTP-Client-Bibliothek wie Guzzle das bessere Werkzeug.

file_get_contents vs file() vs fopen()

Die Funktionen mit einem Aufruf öffnen, lesen oder schreiben und schließen die Datei für dich, also sind sie der richtige Standard. Greif zu fopen(), wenn die Datei zu groß für den Speicher ist oder du sie zwischen Operationen offen halten musst.