Lua Academy · Lección

Escritura y adición en archivos

Escriba strings en archivos y añada datos sin sobrescribirlos.

Escritura y adición en archivos es una lección gratuita de Lua Academy en CoddyKit. Esta es la lección 3 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.

Conceptos básicos de f:write()

f:write(...) escribe una o más cadenas (o números) en el archivo. No añade saltos de línea automáticamente. Devuelve el handle del archivo si la operación tiene éxito (lo que permite encadenar llamadas) o nil, errMessage, errCode si falla.

local f = io.open("output.txt", "w")
if f then
  f:write("Hello, ")
  f:write("World")
  f:write("!\n")
  f:write("Line 2\n")
  f:close()
end

Escribir varios valores

f:write() acepta varios argumentos y los escribe todos secuencialmente. Los valores deben ser cadenas o números; pasar otros tipos provoca un error. Use tostring() para convertir booleanos, tablas, etc.

local f = io.open("log.txt", "w")
f:write("Name: ", "Alice", "\n")
f:write("Age: ", 30, "\n")
f:write("Score: ", string.format("%.1f", 95.5), "\n")
f:close()

Escritura con formato

Combine string.format con f:write para obtener una salida precisa. Este patrón es habitual para generar informes, archivos de registro y exportaciones de datos con requisitos de formato específicos.

local data = {
  {name="Alice", score=95, grade="A"},
  {name="Bob",   score=87, grade="B"},
}

local f = io.open("report.txt", "w")
f:write(string.format("%-12s  %5s  %s\n","Name","Score","Grade"))
f:write(string.rep("-",25) .. "\n")
for _, r in ipairs(data) do
  f:write(string.format("%-12s  %5d  %s\n",r.name,r.score,r.grade))
end
f:close()

Modo de anexado

El modo "a" siempre escribe al final del archivo. La posición del archivo para las lecturas está al principio, pero las escrituras siempre se realizan al final. Úselo para registros, pistas de auditoría y cualquier archivo al que quiera añadir contenido sin borrar lo existente.

local function appendLog(msg)
  local f = io.open("app.log", "a")
  if f then
    local ts = os.date("%Y-%m-%d %H:%M:%S")
    f:write(string.format("[%s] %s\n", ts, msg))
    f:close()
  end
end

appendLog("Server started")
appendLog("User logged in: Alice")
appendLog("Request processed")

f:flush() y el almacenamiento en búfer

La E/S de archivos en Lua utiliza búferes. Los datos escritos con f:write() pueden permanecer en un búfer antes de llegar al disco. f:flush() fuerza la escritura del búfer en el disco sin cerrar el archivo. Vacíe siempre el búfer antes de necesitar que otro proceso vea los datos.

local f = io.open("stream.txt", "w")
for i = 1, 5 do
  f:write("Line " .. i .. "\n")
  f:flush()   -- ensure each line is on disk
  -- simulate work
end
f:close()

Escribir datos binarios

En el modo de escritura binaria ("wb"), escriba bytes sin procesar con string.char(). Así se crean formatos de archivo binarios, imágenes o mensajes de protocolo. Use string.pack (Lua 5.3+) para datos binarios estructurados.

local f = io.open("bytes.bin", "wb")
if f then
  -- Write raw bytes
  f:write(string.char(0xFF, 0x00, 0xAB, 0xCD))
  -- Write a 4-byte little-endian integer (Lua 5.3+)
  f:write(string.pack("<I4", 12345))
  f:close()
  print("Written binary file")
end

io.write frente a f:write

io.write() escribe en la salida predeterminada actual (inicialmente stdout). f:write() escribe en un handle de archivo específico. A diferencia de print(), ninguno de los dos añade saltos de línea ni separadores de tabulación, por lo que usted controla completamente el formato de salida.

-- io.write to stdout
io.write("Enter name: ")
-- (would read input here)

-- f:write to file
local f = io.open("out.txt", "w")
f:write("No auto newline")
f:write(" appended directly")
f:write("\n")  -- explicit newline
f:close()

-- print adds tabs and newline automatically
print("a", "b", "c")   -- a  b  c (tab-separated)

Patrón de escritura atómica

Por seguridad, escriba primero en un archivo temporal y después cámbiele el nombre. Así se evita el intervalo en el que el archivo de salida está escrito parcialmente. Si el proceso se bloquea durante la escritura, el archivo original permanece intacto.

local function atomicWrite(path, content)
  local tmp = path .. ".tmp"
  local f, err = io.open(tmp, "w")
  if not f then return nil, err end
  f:write(content)
  f:close()
  -- os.rename is atomic on most filesystems
  local ok, err2 = os.rename(tmp, path)
  if not ok then
    os.remove(tmp)
    return nil, err2
  end
  return true
end

Escribir tablas como CSV

Serialice una tabla de registros al formato CSV: escriba una fila de encabezado y, después, una fila por registro; convierta todos los valores en cadenas y únalos con comas.

local function writeCSV(path, headers, rows)
  local f = io.open(path, "w")
  if not f then return end
  f:write(table.concat(headers, ",") .. "\n")
  for _, row in ipairs(rows) do
    local fields = {}
    for _, h in ipairs(headers) do
      fields[#fields+1] = tostring(row[h] or "")
    end
    f:write(table.concat(fields, ",") .. "\n")
  end
  f:close()
end

writeCSV("data.csv",
  {"name","age","score"},
  {{name="Alice",age=30,score=95},{name="Bob",age=25,score=87}}
)

Valor devuelto por f:write

f:write() devuelve el handle del archivo si la operación tiene éxito, lo que permite encadenar métodos. Si falla, devuelve nil, un mensaje de error y un código de error. Compruebe siempre los errores en el código de producción, especialmente al escribir en sistemas con almacenamiento limitado.

local f = io.open("out.txt", "w")

-- Chaining writes
local ok, err = f:write("line1\n"):write("line2\n"):write("line3\n")
if not ok then
  print("Write failed:", err)
else
  print("All writes succeeded")
end
f:close()

Comprobación rápida

¿Cuál es la diferencia entre los modos "w" y "a" de io.open?

Resumen: escribir archivos

Resumen:

f:write(...) — escribe cadenas o números; no añade saltos de línea automáticamente
"w" trunca; "a" añade contenido
f:flush() fuerza la escritura del búfer en el disco
io.write() escribe en la salida predeterminada (stdout)
Escritura atómica: escribir en un archivo temporal y después cambiarle el nombre
Compruebe los valores devueltos por las escrituras en el código de producción

Preguntas frecuentes

¿La lección «Escritura y adición en archivos» es gratis?

Sí — el texto completo de «Escritura y adición en archivos» 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 «Escritura y adición en archivos»?

Escriba strings en archivos y añada datos sin sobrescribirlos. 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 3 de 4.

¿Cuánto tiempo toma la lección «Escritura y adición en archivos»?

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

← Volver a Lua Academy