0Pricing
Lua Academy · Lección

Apertura de archivos con io.open

Abra archivos en modo de lectura, escritura o adición mediante io.open.

Apertura de archivos con io.open es una lección gratuita de Lua Academy en CoddyKit. Esta es la lección 1 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de Lua Academy, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de Lua Academy incluye 4 lecciones en total.

Sintaxis de io.open

io.open(filename, mode) abre un archivo y devuelve un controlador de archivo, o bien nil y un mensaje de error si se produce un error. Modos: "r", lectura (predeterminado); "w", escritura (trunca); "a", adición; "r+", lectura/escritura; "b", sufijo para archivos binarios.

local f, err = io.open("test.txt", "w")
if not f then
  print("Error:", err)
  return
end
f:write("Hello, Lua!\n")
f:close()
print("Written successfully")

Modo de lectura

Abra el archivo en modo "r" para leer un archivo existente. Compruebe siempre si el resultado es nil: si el archivo no existe, io.open devuelve nil y un mensaje de error. Nunca dé por sentado que el archivo existe.

local f, err = io.open("test.txt", "r")
if not f then
  print("Cannot open:", err)
  return
end
local content = f:read("*a")  -- read all
f:close()
print(content)

Modos de escritura y adición

"w" crea el archivo o lo trunca. "a" crea el archivo si es necesario y siempre añade contenido al final. Use el modo de adición para archivos de registro cuyo contenido anterior no quiera perder.

-- Write (creates/truncates)
local f = io.open("log.txt", "w")
f:write("Session started\n")
f:close()

-- Append (adds to end)
local g = io.open("log.txt", "a")
g:write("Event: login\n")
g:write("Event: action\n")
g:close()

Modo binario

Añada "b" a cualquier modo para leer o escribir en binario. En Unix, los modos de texto y binario son idénticos. En Windows, el modo de texto traduce \n a \r\n; el modo binario desactiva esta conversión. Use siempre el modo binario para archivos que no sean de texto.

-- Binary read
local f = io.open("image.png", "rb")
if f then
  local header = f:read(8)   -- read 8 bytes
  f:close()
  -- Check PNG magic number: \137PNG\r\n\26\n
  print("Read", #header, "bytes")
end

-- Binary write
local g = io.open("out.bin", "wb")
if g then
  g:write(string.char(0x89, 0x50, 0x4E, 0x47))
  g:close()
end

Métodos del controlador de archivo

Un controlador de archivo (devuelto por io.open) tiene los métodos: f:read(...), f:write(...), f:lines(), f:seek(whence, offset), f:flush() y f:close(). Llámelos con la sintaxis de dos puntos sobre el controlador.

local f = io.open("data.txt", "w")
f:write("line 1\n")
f:write("line 2\n")
f:write("line 3\n")
f:flush()   -- force write to disk
f:close()

local g = io.open("data.txt", "r")
for line in g:lines() do
  print(line)
end
g:close()

io.input e io.output

io.input(f) establece el archivo de entrada predeterminado; io.output(f) establece el de salida predeterminado. io.read() lee de la entrada actual; io.write() escribe en la salida actual. La entrada predeterminada es stdin; la salida predeterminada es stdout.

-- Read from stdin (default input)
local line = io.read()  -- reads one line
print("You entered:", line)

-- Set default output to a file
io.output("out.txt")
io.write("This goes to out.txt\n")
io.output(io.stdout)  -- restore stdout

Comprobar si existe un archivo

Lua no tiene file.exists(), pero puede usar io.open en modo de lectura; si falla, el archivo no existe o no se puede acceder a él. Como alternativa, en sistemas POSIX puede usar os.execute o la biblioteca lfs.

local function fileExists(path)
  local f = io.open(path, "r")
  if f then f:close(); return true end
  return false
end

print(fileExists("test.txt"))     -- true/false
print(fileExists("noexist.txt"))  -- false

Leer con modos

f:read() acepta cadenas de formato: "l" o "*l" lee una línea (elimina el salto de línea); "L" conserva el salto de línea; "n" lee un número; "a" o "*a" lee hasta EOF; un número lee esa cantidad de bytes.

local f = io.open("data.txt", "r")
if f then
  local line1 = f:read("l")   -- first line, no newline
  local num   = f:read("n")   -- next number in file
  local rest  = f:read("a")   -- rest of file
  f:close()
  print(type(line1), type(num))
end

Archivos temporales

io.tmpfile() abre un archivo temporal en modo de lectura y escritura. El archivo se elimina automáticamente cuando termina el programa o cuando el recolector de basura libera el handle. Úselo para el procesamiento intermedio sin tener que administrar nombres de archivo.

local tmp = io.tmpfile()
tmp:write("temporary data\n")
tmp:write("more data\n")

-- Seek back to start and read
tmp:seek("set", 0)
local content = tmp:read("a")
print(content)
-- File auto-deleted when tmp is collected

Iterar líneas con lines()

f:lines() devuelve un iterador que lee una línea cada vez. Cierra automáticamente el archivo cuando el iterador se agota. Es eficiente en cuanto al uso de memoria para archivos grandes: nunca carga todo el archivo de una sola vez.

local function countLines(path)
  local count = 0
  local f, err = io.open(path, "r")
  if not f then return nil, err end
  for _ in f:lines() do
    count = count + 1
  end
  -- f is closed automatically by lines()
  return count
end

local n, err = countLines("data.txt")
print("Lines:", n)

Comprobación rápida

¿Qué hace io.open("file.txt", "a") si el archivo no existe?

Resumen: io.open

Resumen:

  • io.open(path, mode) devuelve un handle o nil+error
  • Modos: r w a r+ b
  • Compruebe siempre si el valor es nil antes de usar el handle
  • Llame a f:close() cuando termine
  • f:lines() permite iterar líneas usando poca memoria
  • io.tmpfile() permite crear archivos temporales que se eliminan automáticamente

Preguntas frecuentes

¿La lección «Apertura de archivos con io.open» es gratis?

Sí — el texto completo de «Apertura de archivos con io.open» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de Lua Academy, actualiza a CoddyKit PRO. El curso de Lua Academy incluye 4 lecciones en total.

¿Qué aprenderé en «Apertura de archivos con io.open»?

Abra archivos en modo de lectura, escritura o adición mediante io.open. Practicas Lua Academy con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.

¿Necesito experiencia previa para empezar Lua Academy?

No se requiere experiencia previa. Lua Academy en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 1 de 4.

¿Cuánto tiempo toma la lección «Apertura de archivos con io.open»?

La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.

¿Puedo escribir y ejecutar código en esta lección de Lua Academy?

Sí. Cada lección de Lua Academy incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.

Todas las lecciones de este curso

  1. Apertura de archivos con io.open
  2. Lectura del contenido de archivos
  3. Escritura y adición en archivos
  4. Cierre de archivos y gestión de errores
← Volver a Lua Academy