PHP file_get_contents(): leer un archivo en un string

file_get_contents('notes.txt') lee el archivo entero y lo devuelve como una cadena. Si el archivo no se puede leer, devuelve false. Para escribir, usa file_put_contents('notes.txt', $text), que crea el archivo o sustituye lo que había en él.

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

Salida:

Buy milk
Call Ada
Write docs
29 bytes
3 lines

El bloque escribe primero notes.txt y luego lo vuelve a leer, así que tiene un archivo con el que trabajar. Una ruta como 'notes.txt' es relativa al directorio de trabajo actual; en una aplicación web, construye la ruta a partir de la carpeta del propio script con __DIR__ . '/notes.txt'.

Escribir y añadir con file_put_contents()

file_put_contents() devuelve el número de bytes escritos, o false si falla. Por defecto sobrescribe el archivo. La opción FILE_APPEND añade al final en su lugar, que es como funcionan los logs sencillos, y LOCK_EX impide que dos peticiones escriban en el mismo 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";

Salida:

Wrote 8 bytes
started
step 1 done
step 2 done

replaced

abc
5 bytes

Para guardar un array y recuperarlo como array, escríbelo como JSON con json_encode() y léelo con json_decode().

Leer un archivo línea a línea con file()

file() lee un archivo en un array con una línea por elemento. Cada línea conserva su salto de línea al final salvo que pases FILE_IGNORE_NEW_LINES, y FILE_SKIP_EMPTY_LINES descarta las líneas en blanco (solo funciona junto con 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";

Salida:

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

file() y file_get_contents() cargan el archivo entero en memoria. Eso está bien para archivos de configuración y logs de unos pocos megabytes. Para un archivo de cientos de megabytes, léelo línea a línea con fopen() y fgets().

Comprobar si un archivo existe antes de leerlo

Cuando falta el archivo, file_get_contents() devuelve false y PHP imprime un warning:

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

Comprueba antes con is_file() (un archivo que existe y no es un directorio) o file_exists() (un archivo o un directorio), y compara siempre el resultado con === false, porque un archivo vacío devuelve "", que también es 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";

Salida:

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

No ocultes el warning con @file_get_contents(). Comprobar antes, o manejar el false, mantiene visible el error cuando falla otra cosa.

Leer una parte de un archivo

El cuarto y el quinto argumento son el desplazamiento en bytes desde el que empezar y el número de bytes que leer. Un desplazamiento negativo cuenta desde el final del archivo. Los argumentos con nombre te permiten saltarte los dos argumentos intermedios:

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

Salida:

HEADER
line 2
last line

Los desplazamientos cuentan bytes, no caracteres. En UTF-8 un carácter japonés ocupa 3 bytes, así que un desplazamiento en mitad de uno lo parte por la mitad. Para trabajar con caracteres, lee la cadena entera y usa mb_substr().

Mostrar un archivo de texto en una página web

El contenido de un archivo es texto, y el texto que se imprime en HTML debe escaparse, o un < del archivo se convierte en una etiqueta. htmlspecialchars() lo escapa y nl2br() convierte los saltos de línea en etiquetas <br>. Ejecútalo y mira la pestaña Página:

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

Quita htmlspecialchars() y vuelve a ejecutarlo: ahora la página termina en "v1.2: Fixed", porque el navegador lee <title> como una etiqueta real y se traga todo lo que va después como título de la página. La página de htmlspecialchars() explica por qué eso importa con cualquier cosa que pueda escribir un usuario.

Leer una URL con file_get_contents()

Con allow_url_fopen activado (el valor por defecto en php.ini), file_get_contents() también lee URLs y devuelve el cuerpo de la respuesta. Un contexto de stream añade un método, cabeceras, un cuerpo y 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
}

Para reintentos, redirecciones con límites y códigos de error claros, cURL o una librería cliente HTTP como Guzzle es la mejor herramienta.

file_get_contents vs file() vs fopen()

Las funciones de una sola llamada abren, leen o escriben y cierran el archivo por ti, así que son la opción por defecto adecuada. Recurre a fopen() cuando el archivo sea demasiado grande para tenerlo en memoria o necesites mantenerlo abierto entre operaciones.