En esta lección vamos a aprender cómo leer y escribir en archivos. Puede ser muy útil a la hora de hacer juegos. Puedes usarlo para ejecutar código de otros archivos, al igual que para guardar información en ficheros, tal como mejores marcas, partidas guardadas, estadísticas de jugadores, etc. ¡Empecemos!

Uso de la lectura y escritura de ficheros

Lo primero es mirar un sencillo comando llamado dofile. Este comando leerá código de otro fichero e inmediatamente lo ejecutará.

dofile("./test.lua")

El comando es tan simple como eso. Fíjate que "./" significa que el archivo está en el mismo directorio. Si estuviera en un subdirectorio usaríamos esto:
dofile("./archivos/test.lua")

Así, si nuestro archivo test.lua contiene este código:

jugadorx = 10
jugadory = 20
enemigox = 40
enemigoy = 50

entonces tan pronto como llamamos al archivo con el comando dofile, esas variables serán declaradas. No es necesario usar archivos con extensión "lua", también valdrían archivos "txt" u otros.

Leer una sola línea de un archivo

Imaginemos que tenemos un archivo con varias líneas de texto y tú quieres leer sólo una y mostrarla por pantalla. Podemos usar el comando io.open() para abrir el archivo y leer de él. Este comando se escribe así: io.open(nombre_archivo, modo). El modo que usaremos para leer será r. Como referencia muestro la lista de todos los modos disponibles:

• r -> modo lectura.
• w -> modo escritura (sobreescribe el texto existente).
• a -> modo añadir (añade al texto existente).
• b -> modo binario.
• r+ -> modo actualizar (preserva el texto existente).
• w+ -> modo actualizar (elimina el texto existente).
• a+ -> modo añadir actualizado (preserva el texto existente, añade al final del texto).

Lo primero que haremos será abrir el archivo y almacenarlo en una variable.
archivo = io.open("testLectura.txt","r")

Nuestro archivo testLectura.txt ha sido abierto y está listo para el modo lectura. Ahora usaremos el comando read() para leer una sola línea del archivo y la guardaremos en otra variable.

nuestraLinea = archivo:read()

Esto leerá la primera línea de nuestro archivo de texto. La próxima vez que usemos el comando read() leerá la segunda línea y así sucesivamente. Fíjate que usamos el nombre de nuestra variable con la que hemos abierto el fichero. También hay argumentos que puedes usar con archivo.read(). IMPORTANTE: fíjate que antes hemos visto archivo:read() y ahora estamos hablando de archivo.read(). Puedes poner cualquiera de los siguientes argumentos dentro de los paréntesis con comillas.

• *n -> lee un número y lo devuelve. Ej: archivo.read("*n").
• *a -> lee el archivo entero desde la posición actual. Ej: archivo.read("*a").
• *| -> (opción por defecto) lee la siguiente línea, devuelve "nil" si es final de fichero (EOF). Ej: archivo.read("*|").
• número - devuelve una cadena de tantos caracteres como se indique o devuelve nil si es final de fichero. Ej: archivo.read(5).

Después de leer nuestra línea, tenemos que cerrar el fichero abierto así:

archivo:close()

Ahora para mostrar nuestra línea por pantalla, simplemente usaremos:

screen:print(10,10,nuestraLinea,blanco)

Leer todas las líneas

Para leer todas las líneas de un archivo podemos usar la misma técnica con un for. Fíjate:

y = 10
archivo = io.open("testLectura.txt","r")
 
for linea in archivo:lines() do
y = y + 10
screen:print(100,y,linea,blanco)
end
 
archivo:close()

Escribir en archivos (sobreescribir)

Escribir en archivos se hace de la misma manera. Nuestro primer método será sobreescribiendo cualquier cosa que estuviera en el archivo anteriormente:

archivo = io.open("testLectura.txt","w")
archivo:write("hola")
archivo:close()

Fíjate que usamos el modo w en vez del r ya que estamos escribiendo, no leyendo. Usamos archivo:write() con el texto que queremos escribir en el archivo dentro del paréntesis entrecomillado. También puedes usar una variable en vez del texto, en este caso no llevaría comillas. Ej:

archivo = io.open("testLectura.txt","w")
miTexto = "hola de nuevo"
archivo:write(miTexto)
archivo:close()

Escribir en archivos (añadir)

Puedes usar el modo añadir y así el texto será añadido al final del texto existente, en vez de borrarlo todo. Se hace exactamente igual que el modo w excepto que hay que poner a. Mira:

archivo = io.open("testLectura.txt","a")
miTexto = "\nhola una vez más"
archivo:write(miTexto)
archivo:close()

¿Notas algo distinto? En la variable miTexto hemos añadido \n dentro de la cadena de texto. Este comando es un salto de línea y hace que el texto vaya a la siguiente línea cuando lo escribimos en nuestro archivo. Puede aparecer en tu archivo un pequeño cuadrado, pero técnicamente eso es una nueva línea. Este comando se usa también en C/C++.

Intenta usar lo que acabas de aprender aquí haciendo un pequeño programa por tu cuenta.