Lua Academy · Lekcja

Zapisywanie i dopisywanie do plików

Proszę zapisywać ciągi znaków do plików i dopisywać dane bez nadpisywania zawartości.

Zapisywanie i dopisywanie do plików to bezpłatna lekcja Lua Academy na CoddyKit. To lekcja 3 z 4. Możesz przeczytać całą lekcję poniżej za darmo — a potem ćwiczyć ją interaktywnie w przeglądarce z wbudowanym edytorem kodu i tutorem AI dostępnym 24/7. To część ścieżki edukacyjnej Lua Academy, a Twój postęp synchronizuje się między webem a aplikacją CoddyKit. Kurs Lua Academy zawiera 4 lekcji w sumie.

Podstawy f:write()

f:write(...) zapisuje w pliku jeden lub więcej łańcuchów znaków (albo liczb). Nie dodaje automatycznie znaków nowego wiersza. Po pomyślnym wykonaniu zwraca uchwyt pliku (co umożliwia łączenie wywołań), a w przypadku błędu zwraca 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

Zapis wielu wartości

f:write() przyjmuje wiele argumentów i zapisuje je kolejno. Wartości muszą być łańcuchami znaków lub liczbami — przekazanie innych typów powoduje błąd. Użyj tostring(), aby przekonwertować wartości logiczne, tabele itp.

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

Zapis sformatowany

Połącz string.format z f:write, aby precyzyjnie określić format wyjścia. Ten wzorzec jest często używany do generowania raportów, plików dziennika i eksportów danych o określonych wymaganiach dotyczących formatowania.

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

Tryb dopisywania

Tryb "a" zawsze zapisuje na końcu pliku. Pozycja pliku podczas odczytu znajduje się na początku, ale zapis zawsze odbywa się na końcu. Używaj tego trybu do dzienników, ścieżek audytowych i wszędzie tam, gdzie chcesz dodawać dane bez usuwania istniejącej zawartości.

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

Operacje wejścia-wyjścia na plikach w Lua są buforowane. Dane zapisane za pomocą f:write() mogą przez pewien czas pozostawać w buforze, zanim trafią na dysk. f:flush() wymusza zapisanie bufora na dysku bez zamykania pliku. Zawsze opróżniaj bufor, zanim inny proces będzie musiał zobaczyć zapisane dane.

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

Zapis danych binarnych

W binarnym trybie zapisu ("wb") zapisuj surowe bajty za pomocą string.char(). W ten sposób tworzy się binarne formaty plików, obrazy lub komunikaty protokołów. Do ustrukturyzowanych danych binarnych użyj string.pack (Lua 5.3+).

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 a f:write

io.write() zapisuje dane do bieżącego domyślnego wyjścia (początkowo stdout). f:write() zapisuje dane do określonego uchwytu pliku. W przeciwieństwie do print() żadna z tych funkcji nie dodaje znaku nowego wiersza ani separatorów tabulacji, zapewniając pełną kontrolę nad formatowaniem wyjścia.

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

Wzorzec zapisu atomowego

Dla bezpieczeństwa zapisuj dane do pliku tymczasowego, a następnie zmień jego nazwę. Eliminuje to sytuację, w której plik wyjściowy jest częściowo zapisany. Jeśli proces ulegnie awarii w trakcie zapisu, oryginalny plik pozostanie nietknięty.

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

Zapis tabel jako CSV

Serializuj tabelę rekordów do formatu CSV: zapisz wiersz nagłówka, a następnie po jednym wierszu dla każdego rekordu, konwertując wszystkie wartości na łańcuchy znaków i łącząc je przecinkami.

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

Wartość zwracana przez f:write()

f:write() po pomyślnym wykonaniu zwraca uchwyt pliku, co umożliwia łączenie wywołań metod. W przypadku błędu zwraca nil, komunikat błędu i kod błędu. W kodzie produkcyjnym należy zawsze sprawdzać błędy, szczególnie podczas zapisu na systemach z ograniczoną przestrzenią dyskową.

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

Szybkie sprawdzenie

Jaka jest różnica między trybami "w" i "a" funkcji io.open?

Podsumowanie: zapis plików

Podsumowanie:

f:write(...) — zapisuje łańcuchy znaków/liczby; nie dodaje automatycznie znaku nowego wiersza
"w" skraca plik, a "a" dopisuje dane
f:flush() wymusza zapisanie bufora na dysku
io.write() zapisuje do domyślnego wyjścia (stdout)
Zapis atomowy: zapis do pliku tymczasowego, a następnie zmiana nazwy
W kodzie produkcyjnym należy sprawdzać wartości zwracane przez operacje zapisu

Często zadawane pytania

Czy lekcja „Zapisywanie i dopisywanie do plików” jest bezpłatna?

Tak — pełny tekst „Zapisywanie i dopisywanie do plików” jest dostępny za darmo tutaj w sieci. Aby ćwiczyć ją interaktywnie (wbudowany edytor kodu i tutor AI dostępny 24/7) i odblokować resztę kursu Lua Academy, przejdź na CoddyKit PRO. Kurs Lua Academy zawiera 4 lekcji w sumie.

Co nauczysz się w „Zapisywanie i dopisywanie do plików”?

Proszę zapisywać ciągi znaków do plików i dopisywać dane bez nadpisywania zawartości. Ćwiczysz Lua Academy z praktycznym kodem, który uruchamiasz bezpośrednio w przeglądarce, a tutor AI dostępny 24/7 odpowiada na Twoje pytania podczas pracy nad lekcją.

Czy potrzebuję doświadczenia, aby zacząć Lua Academy?

Nie wymagamy żadnego doświadczenia. Lua Academy w CoddyKit jest strukturyzowany dla początkujących i zaawansowanych użytkowników, więc możesz zacząć tutaj lub od początku i uczyć się w swoim tempie. To lekcja 3 z 4.

Ile czasu zajmuje lekcja „Zapisywanie i dopisywanie do plików”?

Większość lekcji CoddyKit trwa około 5–10 minut. Każda lekcja to mały, interaktywny krok, dzięki czemu robisz systematyczne postępy i zawsze wracasz dokładnie do tego samego miejsca — na webie i w aplikacji.

Czy mogę pisać i uruchamiać kod w tej lekcji Lua Academy?

Tak. Każda lekcja Lua Academy zawiera wbudowany edytor kodu, więc piszesz i uruchamiasz prawdziwy kod bezpośrednio w przeglądarce i od razu otrzymujesz sprzężenie zwrotne od AI — bez konfiguracji na komputerze.

Wszystkie lekcje w tym kursie

← Powrót do Lua Academy