Lua Academy · Lekcja

Odczytywanie zawartości plików

Proszę odczytywać wiersze, bajty i całą zawartość za pomocą metod file:read().

Lekcja 2 z 412 kroki

Odczytywanie zawartości plików to bezpłatna lekcja Lua Academy na CoddyKit. To lekcja 2 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.

Odczyt całego pliku

Użyj f:read("a") (lub "*a"), aby wczytać cały plik do jednego łańcucha znaków. To proste rozwiązanie, odpowiednie dla małych i średnich plików. W przypadku bardzo dużych plików należy odczytywać dane partiami lub wierszami, aby uniknąć problemów z pamięcią.

local f = io.open("config.txt", "r")
if f then
  local content = f:read("a")
  f:close()
  print("Size:", #content, "bytes")
  print(content)
end

Odczyt wiersz po wierszu

f:read("l") odczytuje następny wiersz, usuwając znak nowego wiersza. Zwraca nil po osiągnięciu końca pliku. Do przetwarzania kolejnych wierszy należy użyć pętli while. f:lines() to idiomatyczny skrót wykonujący tę samą operację.

local f = io.open("data.txt", "r")
if f then
  local line = f:read("l")
  while line ~= nil do
    print(line)
    line = f:read("l")
  end
  f:close()
end

-- Equivalent with for loop:
-- for line in io.lines("data.txt") do print(line) end

Odczyt stałej liczby bajtów

Przekaż liczbę do f:read(n), aby odczytać dokładnie n bajtów. Funkcja zwraca łańcuch zawierający do n bajtów (mniej, jeśli osiągnięto koniec pliku) albo nil po osiągnięciu końca pliku. To rozwiązanie służy do obsługi protokołów binarnych lub ustrukturyzowanych formatów plików.

local f = io.open("binary.dat", "rb")
if f then
  -- Read 4-byte header
  local header = f:read(4)
  if header then
    print("Header bytes:", #header)
    for i = 1, #header do
      io.write(string.format("%02X ", header:byte(i)))
    end
    print()
  end
  f:close()
end

Odczyt liczby

f:read("n") odczytuje następną liczbę z pliku, pomijając białe znaki. Zwraca liczbę Lua albo nil, jeśli następny token nie jest liczbą. Jest przydatne podczas odczytywania ustrukturyzowanych plików z danymi liczbowymi.

-- File contains: "10 20 30.5 40"
local f = io.open("nums.txt", "r")
if f then
  local total = 0
  local n = f:read("n")
  while n do
    total = total + n
    n = f:read("n")
  end
  f:close()
  print("Sum:", total)
end

Przemieszczanie się po plikach

f:seek(whence, offset) zmienia bieżącą pozycję w pliku. whence przyjmuje wartość "set" (od początku), "cur" (od bieżącej pozycji) albo "end" (od końca). Funkcja zwraca nową pozycję bezwzględną. Użyj jej, aby ponownie odczytać dane lub przeskoczyć do innego miejsca w pliku.

local f = io.open("test.txt", "r")
if f then
  -- Jump to end, get file size
  local size = f:seek("end")
  print("File size:", size, "bytes")
  
  -- Seek back to start
  f:seek("set", 0)
  local first_line = f:read("l")
  print("First line:", first_line)
  f:close()
end

Odczyt plików CSV

Analizuj dane CSV wiersz po wierszu: odczytaj każdy wiersz, a następnie podziel go po przecinku za pomocą string.gmatch. W zastosowaniach produkcyjnych należy obsłużyć pola ujęte w cudzysłowy oraz przecinki występujące wewnątrz takich pól, ale w przypadku prostych danych podstawowy podział wystarczy.

local function parseCSV(path)
  local rows = {}
  for line in io.lines(path) do
    local row = {}
    for field in string.gmatch(line, "([^,]+)") do
      row[#row+1] = field
    end
    rows[#rows+1] = row
  end
  return rows
end

-- Example: "Alice,30,Engineer"
-- => {{"Alice","30","Engineer"}}

Odczyt plików konfiguracyjnych

Prosty format konfiguracji key=value: odczytuj dane wiersz po wierszu, pomijaj komentarze i puste wiersze, a następnie analizuj pary key=value za pomocą string.match.

local function loadConfig(path)
  local cfg = {}
  for line in io.lines(path) do
    -- Skip comments and blank lines
    if not line:match("^%s*#") and line:match("%S") then
      local k, v = line:match("^%s*(%w+)%s*=%s*(.-)%s*$")
      if k then cfg[k] = v end
    end
  end
  return cfg
end

local config = loadConfig("app.conf")
print(config.host, config.port)

Odczyt partiami

W przypadku dużych plików odczytuj dane w partiach o stałym rozmiarze, aby uniknąć wczytywania wszystkiego do pamięci. Przetwarzaj każdą partię zaraz po jej otrzymaniu. Jest to niezbędne w przypadku plików większych niż dostępna pamięć RAM.

local function processLarge(path, chunkSize)
  chunkSize = chunkSize or 4096
  local f, err = io.open(path, "rb")
  if not f then return nil, err end
  local totalBytes = 0
  local chunk = f:read(chunkSize)
  while chunk do
    totalBytes = totalBytes + #chunk
    -- process chunk here
    chunk = f:read(chunkSize)
  end
  f:close()
  return totalBytes
end

Odczyt wielu wartości w wierszu

Jeśli każdy wiersz zawiera wiele wartości oddzielonych spacjami lub tabulatorami, użyj string.match albo string.gmatch, aby je wyodrębnić. Ten wzorzec obsługuje proste ustrukturyzowane pliki tekstowe.

-- File: "Alice 95 A\nBob 87 B"
local results = {}
for line in io.lines("grades.txt") do
  local name, score, grade = line:match("(%S+)%s+(%d+)%s+(%S+)")
  if name then
    results[#results+1] = {
      name=name,
      score=tonumber(score),
      grade=grade
    }
  end
end

for _, r in ipairs(results) do
  print(r.name, r.score, r.grade)
end

Skrót io.lines

io.lines(filename) otwiera plik, zwraca iterator wierszy i zamyka plik po zakończeniu pracy. To najbardziej zwięzły sposób odczytywania pliku wiersz po wierszu bez jawnego zarządzania uchwytem.

-- Count non-empty lines
local count = 0
for line in io.lines("data.txt") do
  if line:match("%S") then
    count = count + 1
  end
end
print("Non-empty lines:", count)

-- Collect all lines into a table
local lines = {}
for line in io.lines("data.txt") do
  lines[#lines+1] = line
end
print("Total lines:", #lines)

Szybkie sprawdzenie

Co zwraca f:read("a"), gdy wskaźnik pliku znajduje się już na końcu pliku?

Podsumowanie: odczyt plików

Podsumowanie:

  • f:read("a") — cały plik jako łańcuch znaków
  • f:read("l") — jeden wiersz bez znaku nowego wiersza
  • f:read(n) — dokładnie n bajtów
  • f:read("n") — następna liczba
  • io.lines(path) — iterator wierszy, automatyczne zamykanie
  • f:seek() — przejście do określonej pozycji
Bezpłatny start

Ucz się Lua dzięki korepetycjom AI — za darmo

Pisz i uruchamiaj kod w przeglądarce, otrzymuj natychmiastową pomoc od korepetytora AI dostępnego 24/7 i kontynuuj naukę w sieci lub w aplikacji.

Kursy
40
Lekcje
159

Często zadawane pytania

Czy lekcja „Odczytywanie zawartości plików” jest bezpłatna?

Tak — pełny tekst „Odczytywanie zawartości 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 „Odczytywanie zawartości plików”?

Proszę odczytywać wiersze, bajty i całą zawartość za pomocą metod file:read(). Ć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 2 z 4.

Ile czasu zajmuje lekcja „Odczytywanie zawartości 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

  1. Otwieranie plików za pomocą io.open
  2. Odczytywanie zawartości plików
  3. Zapisywanie i dopisywanie do plików
  4. Zamykanie plików i obsługa błędów
← Powrót do Lua Academy