Trabajar con ficheros en Ruby: leer y escribir con File
Trabajar con un fichero (o archivo) en Ruby tiene tres pasos: lo abres, lees o escribes y lo cierras. Si te lo dejas abierto, queda ocupado y, si el programa se cae, lo escrito puede no llegar al disco. En Ruby todo esto lo hace la clase File.
Lo más sencillo: leer y escribir de una vez
Si vas a leer o escribir el contenido completo, no necesitas abrir ni cerrar nada:
File.write("notas.txt", "Primera línea\n") # crea o sustituye
File.write("notas.txt", "Segunda línea\n", mode: "a") # añade al final
puts File.read("notas.txt")
# Primera línea
# Segunda línea
p File.readlines("notas.txt", chomp: true)
# ["Primera línea", "Segunda línea"]
Para ficheros grandes, lee línea a línea con File.foreach y así no cargas todo en memoria:
File.foreach("notas.txt") { |linea| puts "> #{linea}" }
# > Primera línea
# > Segunda línea
Sin bloque, File.foreach devuelve un enumerador, así que puedes encadenarle select, first o count como a un array. Es útil para buscar en un registro:
File.write("registro.log", "ok\nERROR disco\nok\nERROR red\n")
p File.foreach("registro.log").select { |linea| linea.start_with?("ERROR") }
# ["ERROR disco\n", "ERROR red\n"]
p File.foreach("registro.log").first(2)
# ["ok\n", "ERROR disco\n"]
File.write devuelve el número de bytes que ha escrito, no el texto. Si alguna vez ves un número inesperado en la consola, es eso.
File.open con bloque: la forma recomendada
Cuando vas a hacer varias operaciones sobre el mismo fichero, ábrelo con un bloque. Al terminar el bloque, Ruby lo cierra automáticamente, aunque ocurra un error dentro:
File.open("notas.txt", "a") do |fichero|
fichero.puts "Tercera línea" # puts añade el salto de línea
fichero.write "Cuarta línea\n" # write escribe tal cual
end
Si no sabes qué es un bloque, lo tienes en Bloques en Ruby.
Los modos de apertura
| Modo | Lee | Escribe | Si no existe | Si existe |
|---|---|---|---|---|
"r" |
Sí | No | Error | Lee desde el principio |
"w" |
No | Sí | Lo crea | Lo vacía |
"a" |
No | Sí, al final | Lo crea | Añade al final |
"r+" |
Sí | Sí | Error | Lee y escribe desde el principio |
"w+" |
Sí | Sí | Lo crea | Lo vacía |
"a+" |
Sí | Sí, al final | Lo crea | En Linux y macOS empieza a leer desde el principio; escribe siempre al final |
A cualquiera de ellos puedes añadirle b ("rb", "wb") para leer o escribir en modo binario: Ruby trata el contenido como bytes sueltos (codificación BINARY, también llamada ASCII-8BIT) y, en Windows, no convierte los saltos de línea. Úsalo con imágenes, PDF o ficheros comprimidos. Para leer o escribir el fichero entero en binario, tienes File.binread y File.binwrite.
La codificación: cuando salen caracteres raros
Un fichero de texto son bytes. La codificación es la tabla que dice qué letra es cada byte. Es como un mensaje cifrado: si lo lees con la tabla equivocada, salen símbolos raros. Hoy casi todo se guarda en UTF-8, pero aún aparecen ficheros en Latin-1 (ISO-8859-1), por ejemplo los que exportan algunos programas antiguos.
Ruby lee el fichero con su codificación externa por defecto, Encoding.default_external. Si no la cambias con la opción -E, en Linux y macOS sale de la configuración regional del sistema (el locale), y en Windows es UTF-8. En la imagen oficial de Docker es UTF-8, pero con LANG=C pasa a ser US-ASCII:
LANG=C ruby -e 'p Encoding.default_external'
#<Encoding:US-ASCII>
Si el fichero está en Latin-1 y lo lees como UTF-8, Ruby no se queja al leerlo: el problema aparece después, al trabajar con el texto. Por eso conviene decirle la codificación al abrirlo, con el formato "externa:interna": «está en Latin-1 y lo quiero en UTF-8».
# Simula un fichero guardado en Latin-1
File.binwrite("latin1.txt", "año\n".encode("ISO-8859-1"))
texto = File.read("latin1.txt")
p texto.encoding # => #<Encoding:UTF-8>
p texto.valid_encoding? # => false
bien = File.read("latin1.txt", encoding: "ISO-8859-1:UTF-8")
p bien # => "año\n"
p bien.encoding # => #<Encoding:UTF-8>
valid_encoding? es la forma rápida de saber si un texto leído tiene sentido en la codificación que Ruby cree que tiene.
Otro clásico son los CSV que empiezan por una marca invisible, el BOM (byte order mark), que algunos programas añaden al guardar en UTF-8. Con "bom|utf-8", Ruby la detecta y la quita:
File.binwrite("bom.csv", "\xEF\xBB\xBFnombre,edad\n")
p File.read("bom.csv").start_with?("nombre") # => false
p File.read("bom.csv", encoding: "bom|utf-8").start_with?("nombre") # => true
Sin esa opción, la primera columna no es exactamente "nombre": lleva delante un carácter invisible (U+FEFF). Ni siquiera p lo muestra, así que cualquier búsqueda por ese nombre falla sin que se vea por qué.
Si el fichero no existe
Leer un fichero que no existe lanza Errno::ENOENT. Puedes comprobarlo antes o capturar el error:
File.exist?("no-existe.txt") # false
begin
File.read("no-existe.txt")
rescue Errno::ENOENT => e
puts "Error: #{e.message}"
end
# Error: No such file or directory @ rb_sysopen - no-existe.txt
Más sobre begin y rescue en Excepciones en Ruby.
Sin bloque: ciérralo tú
Si abres el fichero sin bloque, eres responsable de cerrarlo. Usa ensure, que se ejecuta siempre, haya error o no:
fichero = File.open("manual.txt", "w")
begin
fichero.write("texto")
ensure
fichero.close
end
Abrirlo antes del begin evita tener que comprobar si la variable es nil: si File.open falla, no hay nada que cerrar. Aun así, en la mayoría de los casos el bloque es más corto y más seguro.
Con bloque, el fichero se cierra solo.
Errores frecuentes
Los mensajes son reales, de Ruby 4.0.9; Ruby 3.4.12 da exactamente los mismos.
1. Escribir en un fichero abierto para leer. Sin modo, File.open abre en "r":
# notas.txt ya existe: lo crearon los ejemplos anteriores
File.open("notas.txt") { |f| f.write("otra") }
err_r.rb:2:in 'IO#write': not opened for writing (IOError)
Abre con "a" para añadir o con "w" para sustituir.
2. Usar el fichero después del bloque. Al salir del bloque, el fichero está cerrado, aunque guardes la variable:
# notas.txt ya existe: lo crearon los ejemplos anteriores
f = File.open("notas.txt") { |fichero| fichero }
f.read
err_closed.rb:3:in 'IO#read': closed stream (IOError)
Haz todo el trabajo dentro del bloque, o devuelve desde él lo que hayas leído: texto = File.open("notas.txt") { |f| f.read }.
3. Escribir en una carpeta que no existe. "w" crea el fichero, pero no las carpetas:
File.write("informes/2026.txt", "datos")
err_dir.rb:1:in 'IO.write': No such file or directory @ rb_sysopen - informes/2026.txt (Errno::ENOENT)
Es el mismo Errno::ENOENT que al leer un fichero que no existe, lo que despista. Crea antes la carpeta:
require "fileutils"
FileUtils.mkdir_p("informes")
File.write("informes/2026.txt", "datos")
4. Leer una carpeta como si fuera un fichero.
File.read(".")
err_isdir.rb:1:in 'IO.read': Is a directory @ io_fread - . (Errno::EISDIR)
Para recorrer lo que hay dentro de una carpeta, usa Dir.children(".") o Dir.glob("*.txt").
5. No tener permiso. Con un usuario normal, intentar escribir en un fichero del sistema:
File.write("/etc/passwd", "x", mode: "a")
err_acces.rb:1:in 'IO.write': Permission denied @ rb_sysopen - /etc/passwd (Errno::EACCES)
Cómo se leen y cambian los permisos está en permisos en Linux.
6. Trabajar con un texto en otra codificación. Leer no falla, pero partir el texto sí:
File.binwrite("latin1.txt", "año\n".encode("ISO-8859-1"))
File.read("latin1.txt").split(" ")
enc_err.rb:2:in 'String#split': invalid byte sequence in UTF-8 (ArgumentError)
La solución es la de la sección anterior: indicar encoding: "ISO-8859-1:UTF-8" al leer.
Compruébalo con un test
Para probar código que escribe ficheros, usa una carpeta temporal: Dir.mktmpdir la crea y la borra al terminar el bloque, así el test no deja basura ni depende de lo que haya en tu disco. Fichero notas.rb:
module Notas
def self.anota(ruta, texto)
File.write(ruta, "#{texto}\n", mode: "a")
end
def self.lee(ruta)
return [] unless File.exist?(ruta)
File.readlines(ruta, chomp: true)
end
end
Fichero notas_test.rb, con Minitest, que viene con Ruby:
require "minitest/autorun"
require "tmpdir"
require_relative "notas"
class NotasTest < Minitest::Test
def test_anota_añade_al_final_sin_borrar
Dir.mktmpdir do |dir|
ruta = File.join(dir, "notas.txt")
Notas.anota(ruta, "comprar pan")
Notas.anota(ruta, "llamar a Ana")
assert_equal ["comprar pan", "llamar a Ana"], Notas.lee(ruta)
end
end
def test_lee_un_fichero_que_no_existe_como_lista_vacia
Dir.mktmpdir do |dir|
assert_equal [], Notas.lee(File.join(dir, "no-existe.txt"))
end
end
end
ruby notas_test.rb
2 runs, 2 assertions, 0 failures, 0 errors, 0 skips
Si quitas mode: "a", File.write usa "w" y el primer test falla, porque cada nota borra la anterior:
NotasTest#test_anota_añade_al_final_sin_borrar [notas_test.rb:13]:
--- expected
+++ actual
@@ -1 +1 @@
-["comprar pan", "llamar a Ana"]
+["llamar a Ana"]
Es justo el despiste de la advertencia sobre "w". Para empezar con tests en Ruby, lee la introducción al testing en Ruby.
Límites y cuándo no usarlo
File.read con ficheros enormes. Carga todo el contenido en memoria. Si el fichero ocupa varios gigas, recórrelo con File.foreach.
Formatos con estructura. Para un CSV o un JSON no partas las líneas a mano: las comas dentro de comillas o los saltos de línea dentro de un campo te romperán el código. Usa la gema csv o la librería json.
Comprobar y luego abrir. Entre el File.exist? y la escritura, otro programa puede crear el fichero. Si no quieres pisar uno existente, pide que falle al crearlo con el modo "x":
File.write("informe.txt", "primera versión", mode: "wx") # lo crea
File.write("informe.txt", "segunda versión", mode: "wx") # ya existe: error
wx.rb:2:in 'IO.write': File exists @ rb_sysopen - informe.txt (Errno::EEXIST)
Ficheros que no pueden quedar a medias. Si el programa se corta mientras escribe con "w", el fichero queda vacío o incompleto. Para una configuración, escribe en un fichero temporal y renómbralo al final. En Linux y macOS, rename sustituye el fichero de una vez si los dos están en el mismo sistema de ficheros; entre sistemas distintos falla con Errno::EXDEV:
def escribe_atomico(ruta, contenido)
temporal = "#{ruta}.tmp"
File.write(temporal, contenido)
File.rename(temporal, ruta) # sustituye el fichero de una vez
end
escribe_atomico("config.txt", "modo=oscuro\n")
puts File.read("config.txt") # modo=oscuro
Dos límites de este ejemplo sencillo. Para resistir también un corte de luz, fuerza la escritura al disco con fsync antes de renombrar (abre el temporal con File.open y llama a fichero.fsync antes de cerrarlo). Y un nombre fijo como config.txt.tmp choca si dos procesos escriben a la vez: dale a cada uno un nombre distinto, por ejemplo con el PID ("#{ruta}.#{Process.pid}.tmp").
Ejercicio
- Copia
Notasy su test. AñadeNotas.borra(ruta, texto), que quite esa nota y conserve las demás, con su test primero. - Escribe un test que guarde una nota con eñe en un fichero Latin-1 (con
File.binwriteyencode, como en el ejemplo) y compruebe queNotas.leela devuelve bien. Hará falta cambiarlee. - Usa
File.foreachpara contar cuántas líneas de un registro empiezan porERRORsin cargarlo entero.
Fuentes
- Documentación oficial de Ruby 4.0: File (
File.open,File.exist?,File.rename, modos de acceso, modo binariob, modoxy codificaciónBOM|UTF-8), IO (read,write,readlines,foreachy la opciónencoding: "externa:interna"), Encoding (de dónde saledefault_external), FileUtils (mkdir_p) y Dir (mktmpdir,children,glob). - Que
renamesustituye el fichero de una vez es una garantía del sistema operativo, no de Ruby: rename(2) en el manual de Linux, que también documenta el errorEXDEV. - Desacuerdo con la documentación: la tabla de modos de
File(Ruby 4.0) indica que"a+"empieza en el final. Ejecutado en Linux con Ruby 3.4.12 y 4.0.9, la primera lectura devuelve el fichero desde el principio y la escritura va al final; el artículo describe lo ejecutado y lo limita a Linux y macOS. - Los ejemplos del artículo original se ejecutaron el 7 de noviembre de 2026 con Ruby 4.0.9. El 12 de noviembre de 2026 se han ejecutado todos los ejemplos, incluidos los nuevos (codificación, errores frecuentes, modo
x, escritura atómica y el test), en Docker con las imágenes oficialesruby:3.4(Ruby 3.4.12, Minitest 5.25.4) yruby:4.0(Ruby 4.0.9, Minitest 6.0.0), con la misma salida en las dos. El error de permisos se ha obtenido con el usuario sin privilegiosnobody. Las salidas de error están recortadas a las líneas que importan.