Lua Academy · Lektion

Dateien schreiben und erweitern

Schreiben Sie Zeichenketten in Dateien und hängen Sie Daten an, ohne vorhandene Inhalte zu überschreiben

Dateien schreiben und erweitern ist eine kostenlose Lua Academy-Lektion auf CoddyKit. Dies ist Lektion 3 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des Lua Academy-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der Lua Academy-Kurs umfasst insgesamt 4 Lektionen.

Grundlagen von f:write()

f:write(...) schreibt eine oder mehrere Zeichenfolgen (oder Zahlen) in die Datei. Zeilenumbrüche werden nicht automatisch hinzugefügt. Bei Erfolg wird der Datei-Handle zurückgegeben, sodass Aufrufe verkettet werden können; bei einem Fehler nil, errMessage, errCode.

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

Mehrere Werte schreiben

f:write() akzeptiert mehrere Argumente und schreibt sie nacheinander. Die Werte müssen Zeichenfolgen oder Zahlen sein – die Übergabe anderer Typen löst einen Fehler aus. Verwenden Sie tostring(), um boolesche Werte, Tabellen usw. umzuwandeln.

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

Formatierte Ausgabe schreiben

Kombinieren Sie string.format mit f:write, um die Ausgabe präzise zu formatieren. Dieses Muster wird häufig zum Erstellen von Berichten, Protokolldateien und Datenexporten mit bestimmten Formatierungsanforderungen verwendet.

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

Anhänge-Modus

Der Modus "a" schreibt immer am Ende der Datei. Die Dateiposition für Lesevorgänge befindet sich am Anfang, Schreibvorgänge erfolgen jedoch immer am Ende. Verwenden Sie diesen Modus für Protokolle, Audit-Trails und alle Dateien, deren vorhandener Inhalt nicht gelöscht werden soll.

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

Datei-E/A ist in Lua gepuffert. Mit f:write() geschriebene Daten können zunächst in einem Puffer verbleiben, bevor sie auf die Festplatte geschrieben werden. f:flush() schreibt den Puffer auf die Festplatte, ohne die Datei zu schließen. Führen Sie immer einen Flush durch, bevor ein anderer Prozess die Daten sehen muss.

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

Binärdaten schreiben

Schreiben Sie im binären Schreibmodus ("wb") rohe Bytes mit string.char(). So erstellen Sie Binärdateiformate, Bilder oder Protokollnachrichten. Verwenden Sie string.pack (Lua 5.3+) für strukturierte Binärdaten.

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 im Vergleich zu f:write

io.write() schreibt in die aktuelle Standardausgabe (anfänglich stdout). f:write() schreibt in einen bestimmten Datei-Handle. Anders als print() fügt keine der beiden Funktionen Zeilenumbrüche oder Tabulatortrennzeichen hinzu. Dadurch haben Sie die vollständige Kontrolle über die Formatierung der Ausgabe.

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

Muster für atomisches Schreiben

Schreiben Sie aus Sicherheitsgründen zunächst in eine temporäre Datei und benennen Sie diese anschließend um. So vermeiden Sie den Zeitraum, in dem die Ausgabedatei nur teilweise geschrieben ist. Wenn der Prozess während des Schreibens abstürzt, bleibt die ursprüngliche Datei unverändert.

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

Tabellen als CSV schreiben

Serialisieren Sie eine Tabelle mit Datensätzen in das CSV-Format: Schreiben Sie eine Kopfzeile und anschließend eine Zeile pro Datensatz, wandeln Sie alle Werte in Zeichenfolgen um und verbinden Sie sie mit Kommas.

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

Rückgabewert von f:write

f:write() gibt bei Erfolg den Datei-Handle zurück, sodass Methodenaufrufe verkettet werden können. Bei einem Fehler gibt die Funktion nil, eine Fehlermeldung und einen Fehlercode zurück. Prüfen Sie in produktivem Code immer auf Fehler, insbesondere bei Schreibvorgängen auf Systemen mit begrenztem Speicherplatz.

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

Kurze Verständnisfrage

Was ist der Unterschied zwischen den Modi "w" und "a" in io.open?

Zusammenfassung: Dateien schreiben

Zusammenfassung:

f:write(...) — Zeichenfolgen/Zahlen schreiben; kein automatischer Zeilenumbruch
"w" leert die Datei, "a" hängt Daten an
f:flush() schreibt den Puffer auf die Festplatte
io.write() schreibt in die Standardausgabe (stdout)
Atomisches Schreiben: in eine temporäre Datei schreiben, dann umbenennen
Rückgabewerte von Schreibvorgängen im produktiven Einsatz prüfen

Häufig gestellte Fragen

Ist die Lektion „Dateien schreiben und erweitern“ kostenlos?

Ja — der vollständige Text von „Dateien schreiben und erweitern“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des Lua Academy-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der Lua Academy-Kurs umfasst insgesamt 4 Lektionen.

Was lerne ich in „Dateien schreiben und erweitern“?

Schreiben Sie Zeichenketten in Dateien und hängen Sie Daten an, ohne vorhandene Inhalte zu überschreiben Du übst Lua Academy mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.

Brauche ich Erfahrung, um Lua Academy zu starten?

Keine Vorkenntnisse erforderlich. Lua Academy auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 3 von 4.

Wie lange dauert die Lektion „Dateien schreiben und erweitern“?

Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.

Kann ich in dieser Lua Academy-Lektion Code schreiben und ausführen?

Ja. Jede Lua Academy-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.

Alle Lektionen in diesem Kurs

← Zurück zu Lua Academy