Nivel inicial9 min de lectura · Publicado el

Trabajar con ficheros en Ruby: leer y escribir con File

Trabajar con ficheros en Ruby: notas.txt con dos líneas y tres modos de File.open: r lee, w vacía y escribe, a añade al final. Ruby: el bloque cierra ficherosrubentejera.com notas.txtPrimera líneaSegunda línea"r"lee"w"vacía y escribe"a"añade al final
Al abrir notas.txt eliges el modo: «r» para leer, «w» para escribir desde cero (borra lo que hubiera) y «a» para añadir al final. Con File.open y un bloque, Ruby lo cierra por ti.

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

  1. Copia Notas y su test. Añade Notas.borra(ruta, texto), que quite esa nota y conserve las demás, con su test primero.
  2. Escribe un test que guarde una nota con eñe en un fichero Latin-1 (con File.binwrite y encode, como en el ejemplo) y compruebe que Notas.lee la devuelve bien. Hará falta cambiar lee.
  3. Usa File.foreach para contar cuántas líneas de un registro empiezan por ERROR sin cargarlo entero.

Fuentes

  • Documentación oficial de Ruby 4.0: File (File.open, File.exist?, File.rename, modos de acceso, modo binario b, modo x y codificación BOM|UTF-8), IO (read, write, readlines, foreach y la opción encoding: "externa:interna"), Encoding (de dónde sale default_external), FileUtils (mkdir_p) y Dir (mktmpdir, children, glob).
  • Que rename sustituye 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 error EXDEV.
  • 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 oficiales ruby:3.4 (Ruby 3.4.12, Minitest 5.25.4) y ruby: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 privilegios nobody. Las salidas de error están recortadas a las líneas que importan.