Scrittura e aggiunta ai file
Scriva stringhe nei file e aggiunga dati senza sovrascrivere il contenuto esistente.
Scrittura e aggiunta ai file è una lezione Lua Academy gratuita su CoddyKit. Questa è la lezione 3 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.
Nozioni di base su f:write()
f:write(...) scrive nel file una o più stringhe (o numeri). Non aggiunge automaticamente caratteri di nuova riga. In caso di successo restituisce l'handle del file (permettendo il concatenamento delle chiamate), oppure nil, errMessage, errCode in caso di errore.
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()
endScrivere più valori
f:write() accetta più argomenti e li scrive tutti in sequenza. I valori devono essere stringhe o numeri: passare altri tipi genera un errore. Usi tostring() per convertire booleani, tabelle e così via.
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()Scrittura formattata
Combini string.format con f:write per ottenere un output preciso. Questo schema è comune per generare report, file di log ed esportazioni di dati con requisiti di formattazione specifici.
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()Modalità append
La modalità "a" scrive sempre alla fine del file. La posizione per la lettura è all'inizio, ma le scritture vengono sempre eseguite alla fine. La usi per i log, le tracce di controllo e qualsiasi file a cui desidera aggiungere dati senza cancellare quelli esistenti.
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() e il buffering
L'I/O sui file in Lua utilizza un buffer. I dati scritti con f:write() possono rimanere nel buffer prima di essere trasferiti sul disco. f:flush() forza la scrittura del buffer sul disco senza chiudere il file. Esegua sempre il flush prima che un altro processo debba poter vedere i dati.
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()Scrivere dati binari
In modalità di scrittura binaria ("wb"), scriva i byte grezzi con string.char(). È così che si creano formati di file binari, immagini o messaggi di protocollo. Usi string.pack (Lua 5.3+) per i dati binari strutturati.
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")
endio.write e f:write
io.write() scrive nell'output predefinito corrente (inizialmente stdout). f:write() scrive in uno specifico handle di file. A differenza di print(), nessuno dei due aggiunge un carattere di nuova riga o separatori di tabulazione, lasciando il pieno controllo sulla formattazione dell'output.
-- 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)Schema di scrittura atomica
Per maggiore sicurezza, scriva in un file temporaneo e poi lo rinomini. In questo modo si evita l'intervallo durante il quale il file di output è scritto solo parzialmente. Se il processo si arresta durante la scrittura, il file originale rimane intatto.
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
endScrivere tabelle come CSV
Serializzi una tabella di record nel formato CSV: scriva una riga di intestazione, quindi una riga per ogni record, convertendo tutti i valori in stringhe e unendoli con virgole.
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}}
)Valore restituito da f:write
f:write() restituisce l'handle del file in caso di successo, permettendo il concatenamento dei metodi. In caso di errore restituisce nil, un messaggio di errore e un codice di errore. Verifichi sempre la presenza di errori nel codice di produzione, soprattutto durante le scritture su sistemi con spazio di archiviazione limitato.
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()Verifica rapida
Qual è la differenza tra le modalità "w" e "a" di io.open?
Riepilogo: scrittura dei file
Riepilogo:
f:write(...)— scrive stringhe/numeri; non aggiunge automaticamente una nuova riga"w"tronca,"a"aggiungef:flush()forza la scrittura del buffer sul discoio.write()scrive nell'output predefinito (stdout)- Scrittura atomica: scrivere in un file temporaneo e poi rinominarlo
- Verificare i valori restituiti dalle scritture nel codice di produzione
Impara Lua con un tutor IA — gratis
Scrivi ed esegui vero codice nel tuo browser, ricevi aiuto istantaneo da un tutor IA disponibile 24/7, e riprendi da dove hai lasciato sul web o nell'app.
- Corsi
- 40
- Lezioni
- 159
Domande Frequenti
La lezione «Scrittura e aggiunta ai file» è gratuita?
Sì — il testo completo di «Scrittura e aggiunta ai file» è 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 «Scrittura e aggiunta ai file»?
Scriva stringhe nei file e aggiunga dati senza sovrascrivere il contenuto esistente. 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 3 di 4.
Quanto tempo richiede la lezione «Scrittura e aggiunta ai file»?
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