Lua Academy · Lekcja

Iterowanie po tabelach za pomocą pairs i ipairs

Proszę bezpiecznie przechodzić po tabelach za pomocą pairs() i ipairs().

Lekcja 3 z 412 kroki

Iterowanie po tabelach za pomocą pairs i ipairs 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.

ipairs: uporządkowana iteracja po tablicy

ipairs(t) iteruje po sekwencji liczb całkowitych zaczynającej się od indeksu 1, zwracając pary (index, value). Zatrzymuje się przy pierwszej wartości nil. Jest to bezpieczny i przewidywalny wybór w przypadku tabel przypominających tablice, gdy kolejność ma znaczenie.

local fruits = {"apple","banana","cherry"}

for i, fruit in ipairs(fruits) do
  print(i, fruit)
end
-- 1  apple
-- 2  banana
-- 3  cherry

pairs: wszystkie klucze

pairs(t) iteruje po każdej niepustej parze klucz-wartość w tabeli, w nieokreślonej kolejności. Wewnętrznie korzysta z funkcji next(). Należy używać pairs w przypadku słowników, tabel mieszanych lub gdy trzeba odwiedzić wszystkie klucze niezależnie od ich typu.

local info = {name="Lua", version=5.4, embedded=true}

for k, v in pairs(info) do
  print(k, v)
end
-- name  Lua
-- version  5.4
-- embedded  true  (order may vary)

Wybór między pairs a ipairs

Należy używać ipairs dla sekwencyjnych tablic (gwarantowana kolejność, zatrzymanie przy nil). pairs służy do słowników, tabel mieszanych lub sytuacji, w których potrzebne są wszystkie klucze. Użycie pairs dla tablicy działa, ale nie gwarantuje kolejności. Użycie ipairs dla słownika pomija klucze niebędące liczbami całkowitymi.

local mixed = {10, 20, label="hello", 30}

-- ipairs: only sees 10, 20, 30 in order
for i, v in ipairs(mixed) do
  io.write(v .. " ")
end
print()  -- 10 20 30

-- pairs: sees everything
for k, v in pairs(mixed) do
  print(k, v)
end

Zliczanie elementów

W przypadku sekwencji #t podaje liczbę elementów. W przypadku słowników #t jest niewiarygodne — należy iterować za pomocą pairs i zliczać elementy ręcznie. To ważne rozróżnienie pomaga uniknąć błędów podczas pracy z tabelami mieszanymi lub z kluczami tekstowymi.

local arr = {10, 20, 30}
print("#arr:", #arr)        -- 3 (reliable)

local dict = {a=1, b=2, c=3}
print("#dict:", #dict)      -- 0 (unreliable for dicts!)

local count = 0
for _ in pairs(dict) do count = count + 1 end
print("count:", count)       -- 3

Modyfikowanie wartości podczas iteracji

Podczas iteracji za pomocą pairs można bezpiecznie aktualizować wartość istniejącego klucza. Dodawanie lub usuwanie kluczy w trakcie iteracji ma jednak niezdefiniowane zachowanie. Należy zebrać zmiany i zastosować je po zakończeniu pętli.

local prices = {apple=1.0, banana=0.5, cherry=2.0}

-- Safe: update existing values
for k, v in pairs(prices) do
  prices[k] = v * 1.1  -- 10% markup
end

for k, v in pairs(prices) do
  print(k, string.format("%.2f", v))
end

Zbieranie kluczy

Częstą operacją jest zebranie wszystkich kluczy w posortowanej tablicy, aby uzyskać deterministyczny wynik. Należy iterować za pomocą pairs, aby zebrać klucze, a następnie użyć table.sort do ich uporządkowania.

local config = {host="localhost", port=8080, debug=true}
local keys = {}

for k in pairs(config) do
  keys[#keys+1] = k
end
table.sort(keys)

for _, k in ipairs(keys) do
  print(k, "=", config[k])
end
-- debug = true
-- host = localhost
-- port = 8080

Iteracja po zagnieżdżonych tabelach

W przypadku zagnieżdżonych tabel (tabeli tabel) należy połączyć dwie pętle: pętla zewnętrzna iteruje po najwyższym poziomie, a wewnętrzna po każdej zagnieżdżonej tabeli. Ten wzorzec obsługuje dowolną głębokość, a rekurencja pozwala radzić sobie z naprawdę dowolnym zagnieżdżeniem.

local matrix = {
  {1,2,3},
  {4,5,6},
  {7,8,9},
}

for i, row in ipairs(matrix) do
  for j, val in ipairs(row) do
    io.write(string.format("%3d", val))
  end
  print()
end

Filtrowanie za pomocą ipairs

Aby utworzyć przefiltrowaną listę, należy iterować za pomocą ipairs i dodawać elementy spełniające predykat. Wynikiem jest nowa tablica zawierająca tylko pasujące elementy.

local function filter(t, pred)
  local result = {}
  for _, v in ipairs(t) do
    if pred(v) then result[#result+1] = v end
  end
  return result
end

local nums = {1,2,3,4,5,6,7,8,9,10}
local evens = filter(nums, function(n) return n % 2 == 0 end)
print(table.concat(evens, " "))  -- 2 4 6 8 10

Mapowanie za pomocą ipairs

Aby zastosować transformację do każdego elementu, należy wykonać iterację i zbudować nową tablicę z przekształconymi wartościami. Jest to odpowiednik funkcji map() z języków funkcyjnych w Lua.

local function map(t, fn)
  local result = {}
  for i, v in ipairs(t) do
    result[i] = fn(v)
  end
  return result
end

local nums = {1, 2, 3, 4, 5}
local doubled = map(nums, function(n) return n * 2 end)
print(table.concat(doubled, " "))  -- 2 4 6 8 10

local words = {"hello","world"}
local upper = map(words, string.upper)
print(table.concat(upper, " "))    -- HELLO WORLD

pairs z własnymi iteratorami

Można sprawić, aby własny obiekt był iterowalny, zwracając z funkcji iterator i stan. Wzorzec ten odzwierciedla wewnętrzne działanie pairs: funkcja zwraca next, t, nil. Fabryka iteratora podobnie zwraca funkcję oraz opcjonalny stan.

local function values(t)
  local i = 0
  return function()
    i = i + 1
    return t[i]
  end
end

for v in values({"x","y","z"}) do
  print(v)
end
-- x
-- y
-- z

Szybkie sprawdzenie

Które stwierdzenie dotyczące pairs() i ipairs() jest prawdziwe?

Odpowiedz w interaktywnej lekcji

Podsumowanie: pairs i ipairs

Podsumowanie:

ipairs: uporządkowana iteracja, klucze całkowitoliczbowe zaczynające się od 1, zatrzymuje się przy nil
pairs: wszystkie klucze, dowolna kolejność, nigdy nie zatrzymuje się przedwcześnie
Należy używać pairs dla słowników, a ipairs dla tablic
Nie należy nigdy dodawać ani usuwać kluczy w trakcie iteracji za pomocą pairs; bezpieczna jest aktualizacja istniejących wartości
Aby uzyskać deterministyczny wynik, należy zebrać i posortować klucze

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

Zacznij naukę bezpłatnie Wyświetl pełny kurs

Często zadawane pytania

Czy lekcja „Iterowanie po tabelach za pomocą pairs i ipairs” jest bezpłatna?

Tak — pełny tekst „Iterowanie po tabelach za pomocą pairs i ipairs” 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 „Iterowanie po tabelach za pomocą pairs i ipairs”?

Proszę bezpiecznie przechodzić po tabelach za pomocą pairs() i ipairs(). Ć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 „Iterowanie po tabelach za pomocą pairs i ipairs”?

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

Tabele jako tablice
Tabele jako słowniki
Iterowanie po tabelach za pomocą pairs i ipairs
Zagnieżdżone tabele i dane strukturalne

← Powrót do Lua Academy