PHP fopen(): abrir, leer y escribir archivos (los modos)

fopen('data.txt', 'r') abre un archivo y devuelve un manejador, un recurso de stream que las demás funciones de archivos reciben como primer argumento. Lee con fgets() (una línea) o fread() (un número de bytes), escribe con fwrite() y cierra con fclose(). El segundo argumento es el modo: 'r' para leer, 'w' para escribir, 'a' para añadir.

<?php
$fh = fopen('fruits.txt', 'w');          // create or empty the file
fwrite($fh, "apple\n");
fwrite($fh, "banana\n");
fwrite($fh, "cherry\n");
fclose($fh);

$fh = fopen('fruits.txt', 'r');
if ($fh === false) {
    exit("Cannot open fruits.txt\n");
}

while (($line = fgets($fh)) !== false) {
    echo 'Got: ', rtrim($line), "\n";
}
fclose($fh);

Salida:

Got: apple
Got: banana
Got: cherry

fopen() devuelve false cuando no puede abrir el archivo (no existe en modo r, falta una carpeta, no hay permiso), y PHP imprime un warning como:

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

Así que comprueba si es false antes de usar el manejador. Para leer o escribir un archivo pequeño entero en una llamada, file_get_contents() y file_put_contents() son más cortas; fopen() es para archivos que lees por partes o mantienes abiertos.

Modos de fopen

Dos filas sorprenden. r+ escribe sobre los bytes existentes en el sitio, sin insertar, y a+ siempre escribe al final, incluso después de mover el puntero con fseek() (moverlo solo afecta a las lecturas):

<?php
file_put_contents('letters.txt', "abc\n");

$fh = fopen('letters.txt', 'r+');
fwrite($fh, 'X');                  // overwrites the "a"
fclose($fh);
echo file_get_contents('letters.txt');

$fh = fopen('letters.txt', 'a+');
fseek($fh, 0);                     // back to the start...
fwrite($fh, "end\n");              // ...but the write still goes to the end
rewind($fh);
echo fgets($fh);                   // reads do start at the beginning
fclose($fh);
echo file_get_contents('letters.txt');

Salida:

Xbc
Xbc
Xbc
end

En Windows puedes ver 'rb' o 'wb': la opción b significa binario e impide que Windows traduzca los finales de línea. No hace nada en Linux ni en macOS, así que añadirla es inofensivo y portable.

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

fgets() devuelve la siguiente línea incluido su \n, y false al final del archivo. Como solo hay una línea en memoria cada vez, este bucle maneja un archivo de log de cualquier tamaño, y puedes parar antes con break:

<?php
file_put_contents('app.log', <<<LOG
2026-03-14 09:00:01 INFO  server started
2026-03-14 09:00:05 ERROR database timeout
2026-03-14 09:01:12 INFO  request /home
2026-03-14 09:02:40 ERROR disk full
2026-03-14 09:03:00 INFO  request /about
LOG);

$fh = fopen('app.log', 'r');
$number = 0;
$errors = [];

while (($line = fgets($fh)) !== false) {
    $number++;
    if (str_contains($line, 'ERROR')) {
        $errors[] = "line $number: " . trim(substr($line, 26));
    }
}
fclose($fh);

echo count($errors), " errors in $number lines\n";
echo implode("\n", $errors), "\n";

Salida:

2 errors in 5 lines
line 2: database timeout
line 4: disk full

Compara con false usando !==, no con un simple while ($line = fgets($fh)): una línea que contenga solo "0" sin salto de línea (la última línea de un archivo puede serlo) es falsy y terminaría el bucle antes de tiempo.

Escribir y añadir con fwrite()

fwrite() escribe una cadena en la posición actual y devuelve el número de bytes escritos, o false si falla. fputs() es la misma función con otro nombre. Abre con 'a' para añadir al final de un archivo sin tocar lo que ya hay:

<?php
$fh = fopen('visits.log', 'a');
foreach (['/home', '/about', '/contact'] as $page) {
    $bytes = fwrite($fh, "visit $page" . PHP_EOL);
    echo "wrote $bytes bytes\n";
}
fclose($fh);

$fh = fopen('visits.log', 'a');      // open again: the old lines stay
fwrite($fh, 'visit /home' . PHP_EOL);
fclose($fh);

echo file_get_contents('visits.log');

Salida:

wrote 12 bytes
wrote 13 bytes
wrote 15 bytes
visit /home
visit /about
visit /contact
visit /home

PHP_EOL es el final de línea del sistema en el que se ejecuta PHP (\n en Linux y macOS, \r\n en Windows). Para archivos que leen otros programas, elige uno de forma explícita, normalmente "\n".

Leer y escribir archivos CSV con fgetcsv() y fputcsv()

fputcsv() escribe un array como una fila CSV y pone entre comillas los campos que contienen comas, comillas o saltos de línea. fgetcsv() vuelve a leer una fila como array. Pasa de forma explícita el separador, el delimitador y un carácter de escape vacío: eso da un CSV estándar, y PHP 8.4 imprime un aviso de obsolescencia cuando se omite el argumento de escape.

<?php
$rows = [
    ['name', 'city', 'note'],
    ['Ada', 'London', 'likes "math", a lot'],
    ['Linus', 'Helsinki', 'kernel'],
];

$fh = fopen('people.csv', 'w');
foreach ($rows as $row) {
    fputcsv($fh, $row, ',', '"', '');
}
fclose($fh);
echo file_get_contents('people.csv'), "\n";

// Read it back, using the first row as keys
$fh = fopen('people.csv', 'r');
$header = fgetcsv($fh, null, ',', '"', '');
while (($fields = fgetcsv($fh, null, ',', '"', '')) !== false) {
    $person = array_combine($header, $fields);
    echo "{$person['name']} lives in {$person['city']}: {$person['note']}\n";
}
fclose($fh);

Salida:

name,city,note
Ada,London,"likes ""math"", a lot"
Linus,Helsinki,kernel

Ada lives in London: likes "math", a lot
Linus lives in Helsinki: kernel

Dividir las líneas con explode(',', $line) falla en cuanto un campo contiene una coma; fgetcsv() se encarga de las comillas por ti. Para un archivo separado por punto y coma (habitual en las exportaciones de Excel en Europa), pasa ';' como separador.

Moverse por un archivo con fseek(), ftell() y rewind()

Un archivo abierto tiene una posición. Las lecturas y escrituras empiezan ahí y la hacen avanzar. ftell() te dice dónde está, fseek() la mueve a un desplazamiento en bytes y rewind() vuelve al principio. Con w+ puedes escribir un archivo y volver a leerlo con el mismo manejador:

<?php
$fh = fopen('message.txt', 'w+');
fwrite($fh, 'hello world');
echo ftell($fh), "\n";             // after the last byte written

fseek($fh, 6);
echo fread($fh, 5), "\n";          // 5 bytes from offset 6

rewind($fh);
echo stream_get_contents($fh), "\n";  // everything from the position to the end
fclose($fh);

Salida:

11
world
hello world

Bloquear un archivo con flock()

Dos peticiones que leen un contador, le suman uno y lo vuelven a escribir a la vez pueden leer las dos 41 y escribir las dos 42. flock() con LOCK_EX hace que la segunda espere hasta que la primera libere el bloqueo. Aquí el modo adecuado es c+: crea el archivo si hace falta y, a diferencia de w+, no lo vacía antes de que tengas el bloqueo.

<?php
function increment(string $path): int
{
    $fh = fopen($path, 'c+');
    flock($fh, LOCK_EX);               // wait for exclusive access

    $count = (int) stream_get_contents($fh);
    $count++;

    ftruncate($fh, 0);                 // empty the file
    rewind($fh);
    fwrite($fh, (string) $count);
    fflush($fh);

    flock($fh, LOCK_UN);
    fclose($fh);
    return $count;
}

for ($i = 0; $i < 3; $i++) {
    echo 'Visitor number ', increment('counter.txt'), "\n";
}

Salida:

Visitor number 1
Visitor number 2
Visitor number 3

Los bloqueos son orientativos: solo detienen a otro código que también llame a flock(). Para añadir una línea, file_put_contents($path, $line, FILE_APPEND | LOCK_EX) hace lo mismo en una llamada.

Error frecuente: while (!feof($fh))

Muchos tutoriales antiguos recorren el archivo con feof(). Solo devuelve true después de que una lectura ya haya llegado al final, así que el bucle se ejecuta una vez más que líneas hay y el último fgets() devuelve false:

<?php
file_put_contents('abc.txt', "a\nb\nc\n");

$fh = fopen('abc.txt', 'r');
$rounds = 0;
while (!feof($fh)) {
    $line = fgets($fh);
    $rounds++;
    var_dump($line);
}
fclose($fh);
echo "$rounds rounds for 3 lines\n";

Salida:

string(2) "a
"
string(2) "b
"
string(2) "c
"
bool(false)
4 rounds for 3 lines

Ese false de más se convierte en una fila vacía en un informe o en un elemento vacío en un array. Recorre el archivo con la propia lectura, while (($line = fgets($fh)) !== false), como hacen todos los demás ejemplos de esta página.