Lua Academy · Lezione

Apertura dei file con io.open

Apra i file in modalità lettura, scrittura e aggiunta usando io.open.

Apertura dei file con io.open è una lezione Lua Academy gratuita su CoddyKit. Questa è la lezione 1 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento Lua Academy, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso Lua Academy include 4 lezioni in totale.

Sintassi di io.open

io.open(filename, mode) apre un file e restituisce un file handle oppure nil più un messaggio di errore in caso di fallimento. Stringhe di modalità: "r" lettura (predefinita), "w" scrittura (tronca), "a" aggiunta, "r+" lettura/scrittura, "b" suffisso per il binario.

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")

Modalità di lettura

Apra il file in modalità "r" per leggere un file esistente. Controlli sempre nil: se il file non esiste, io.open restituisce nil e un messaggio di errore. Non dia mai per scontato che il file sia presente.

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)

Modalità di scrittura e aggiunta

"w" crea il file oppure ne cancella il contenuto. "a" crea il file se necessario e aggiunge sempre i dati alla fine. Usi la modalità di aggiunta per i file di log, quando non vuole perdere il contenuto precedente.

-- 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()

Modalità binaria

Aggiunga "b" a qualsiasi modalità per la lettura o la scrittura binaria. In Unix, le modalità testo e binaria sono identiche. In Windows, la modalità testo converte \n in \r\n; la modalità binaria disattiva questa conversione. Usi sempre la modalità binaria per i file non testuali.

-- 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

Metodi del file handle

Un file handle (restituito da io.open) dispone dei metodi: f:read(...), f:write(...), f:lines(), f:seek(whence, offset), f:flush(), f:close(). Li chiami usando la sintassi con i due punti sul file handle.

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) imposta il file di input predefinito; io.output(f) imposta quello di output. io.read() legge dall'input corrente; io.write() scrive nell'output corrente. L'input predefinito è stdin; l'output predefinito è 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

Verificare l'esistenza di un file

Lua non dispone di file.exists(), ma è possibile usare io.open in modalità di lettura: se l'operazione non riesce, il file non esiste (oppure non è accessibile). In alternativa, sui sistemi POSIX si possono usare os.execute o la libreria 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

Lettura con le modalità

f:read() accetta stringhe di formato: "l" o "*l" leggono una riga (rimuovendo il carattere di nuova riga); "L" conserva il carattere di nuova riga; "n" legge un numero; "a" o "*a" legge fino a EOF; un numero legge quel numero di byte.

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

File temporanei

io.tmpfile() apre un file temporaneo in modalità di lettura/scrittura. Il file viene eliminato automaticamente quando il programma termina o quando l'handle viene raccolto dal garbage collector. Usatelo per l'elaborazione intermedia senza dover gestire i nomi dei file.

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

Iterare sulle righe con lines()

f:lines() restituisce un iteratore che legge una riga alla volta. Chiude automaticamente il file quando l'iteratore è esaurito. È efficiente in termini di memoria per i file grandi, perché non carica mai l'intero file in una volta sola.

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)

Verifica rapida

Che cosa fa io.open("file.txt", "a") se il file non esiste?

Riepilogo: io.open

Riepilogo:

io.open(path, mode) restituisce un handle oppure nil+errore
Modalità: r w a r+ b
Verifichi sempre che l'handle non sia nil prima di usarlo
Chiami f:close() al termine
f:lines() per iterare sulle righe con un uso efficiente della memoria
io.tmpfile() per i file temporanei eliminati automaticamente

Domande Frequenti

La lezione «Apertura dei file con io.open» è gratuita?

Sì — il testo completo di «Apertura dei file con io.open» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso Lua Academy, passa a CoddyKit PRO. Il corso Lua Academy include 4 lezioni in totale.

Cosa imparerò in «Apertura dei file con io.open»?

Apra i file in modalità lettura, scrittura e aggiunta usando io.open. Eserciti Lua Academy con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.

Ho bisogno di esperienza per iniziare Lua Academy?

Non è richiesta alcuna esperienza precedente. Lua Academy su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 1 di 4.

Quanto tempo richiede la lezione «Apertura dei file con io.open»?

La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.

Posso scrivere ed eseguire codice in questa lezione Lua Academy?

Sì. Ogni lezione Lua Academy include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.

Tutte le lezioni di questo corso

Apertura dei file con io.open
Lettura del contenuto dei file
Scrittura e aggiunta ai file
Chiusura dei file e gestione degli errori

← Torna a Lua Academy