Lua Academy · Lekcja

Otwieranie plików za pomocą io.open

Proszę otwierać pliki w trybie odczytu, zapisu i dopisywania za pomocą io.open.

Otwieranie plików za pomocą io.open to bezpłatna lekcja Lua Academy na CoddyKit. To lekcja 1 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.

Składnia io.open

io.open(filename, mode) otwiera plik i zwraca uchwyt pliku albo nil wraz z komunikatem błędu w razie niepowodzenia. Ciągi trybów: "r" — odczyt (domyślny), "w" — zapis (z wyczyszczeniem zawartości), "a" — dopisywanie, "r+" — odczyt/zapis, "b" — przyrostek oznaczający tryb binarny.

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

Tryb odczytu

Otwórz plik w trybie "r", aby odczytać istniejący plik. Zawsze sprawdzaj wartość nil — jeśli plik nie istnieje, io.open zwraca nil i komunikat błędu. Nigdy nie zakładaj, że plik istnieje.

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)

Tryby zapisu i dopisywania

"w" tworzy plik lub usuwa jego dotychczasową zawartość. "a" tworzy plik w razie potrzeby i zawsze dopisuje dane na końcu. Używaj trybu dopisywania w przypadku plików dziennika, gdy nie chcesz utracić wcześniejszej zawartości.

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

Tryb binarny

Dodaj "b" do dowolnego trybu, aby odczytywać lub zapisywać dane binarne. W systemie Unix tryb tekstowy i binarny są identyczne. W systemie Windows tryb tekstowy tłumaczy \n na \r\n, natomiast tryb binarny wyłącza tę konwersję. W przypadku plików nietekstowych zawsze używaj trybu binarnego.

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

Metody uchwytu pliku

Uchwyt pliku (zwracany przez io.open) udostępnia metody: f:read(...), f:write(...), f:lines(), f:seek(whence, offset), f:flush(), f:close(). Wywołuj je za pomocą składni dwukropka na uchwycie.

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 i io.output

io.input(f) ustawia domyślny plik wejściowy, a io.output(f) ustawia domyślny plik wyjściowy. io.read() odczytuje dane z bieżącego wejścia, a io.write() zapisuje je do bieżącego wyjścia. Domyślnym wejściem jest stdin, a domyślnym wyjściem — 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

Sprawdzanie istnienia pliku

Lua nie ma funkcji file.exists(), ale można użyć io.open w trybie odczytu — jeśli operacja się nie powiedzie, plik nie istnieje (lub jest niedostępny). Alternatywnie w systemach POSIX można użyć os.execute albo biblioteki 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

Odczyt z użyciem trybów

f:read() przyjmuje formaty: "l" lub "*l" odczytuje jeden wiersz (usuwając znak nowego wiersza); "L" zachowuje znak nowego wiersza; "n" odczytuje liczbę; "a" lub "*a" odczytuje dane do końca pliku; liczba oznacza odczytanie określonej liczby bajtów.

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

Pliki tymczasowe

io.tmpfile() otwiera plik tymczasowy w trybie odczytu i zapisu. Plik jest automatycznie usuwany po zakończeniu programu lub zebraniu uchwytu przez garbage collector. Należy go używać do przetwarzania pośredniego bez konieczności zarządzania nazwami plików.

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

Iterowanie po wierszach za pomocą lines()

f:lines() zwraca iterator odczytujący po jednym wierszu. Automatycznie zamyka plik po wyczerpaniu iteratora. Jest oszczędny pod względem pamięci w przypadku dużych plików — nigdy nie wczytuje całego pliku naraz.

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)

Szybkie sprawdzenie

Co robi io.open("file.txt", "a"), jeśli plik nie istnieje?

Podsumowanie: io.open

Podsumowanie:

io.open(path, mode) zwraca uchwyt albo nil i błąd
Tryby: r w a r+ b
Przed użyciem uchwytu należy zawsze sprawdzić, czy nie ma wartości nil
Po zakończeniu pracy należy wywołać f:close()
f:lines() służy do oszczędnego pod względem pamięci iterowania po wierszach
io.tmpfile() służy do tworzenia automatycznie usuwanych plików tymczasowych

Często zadawane pytania

Czy lekcja „Otwieranie plików za pomocą io.open” jest bezpłatna?

Tak — pełny tekst „Otwieranie plików za pomocą io.open” 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 „Otwieranie plików za pomocą io.open”?

Proszę otwierać pliki w trybie odczytu, zapisu i dopisywania za pomocą io.open. Ć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 1 z 4.

Ile czasu zajmuje lekcja „Otwieranie plików za pomocą io.open”?

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