Lua Academy · Lekcja

for ogólne i break

Proszę używać ogólnej pętli for z pairs/ipairs oraz sterować przebiegiem pętli za pomocą break.

Lekcja 4 z 412 kroki

for ogólne i break to bezpłatna lekcja Lua Academy na CoddyKit. To lekcja 4 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.

Protokół generycznej pętli for

Generyczna pętla for w Lua działa z funkcją iteratora. Składnia ma postać for vars in iter_func, state, init do. W każdej iteracji Lua wywołuje iter_func(state, lastVar) i przypisuje zwracane wartości do zmiennych vars. Pętla kończy się, gdy pierwsza zwrócona wartość to nil.

-- Manual use of next() iterator
local t = {a=1, b=2, c=3}
local key, val = next(t, nil)   -- first entry
while key ~= nil do
  print(key, val)
  key, val = next(t, key)       -- advance
end

pairs() dla wszystkich kluczy

pairs(t) zwraca iterator przechodzący przez wszystkie pary klucz-wartość w tabeli, w tym klucze napisowe, całkowite i mieszane. Kolejność iteracji kluczy niecałkowitych jest nieokreślona (kolejność haszowania). Uwzględniane są zarówno część tablicowa, jak i haszowana.

local config = {
  host = "localhost",
  port = 8080,
  debug = true,
  [1] = "first",
}

for key, value in pairs(config) do
  print(key, value)
end
-- Prints all 4 entries in any order

ipairs() dla kluczy tablicy

ipairs(t) iteruje po kluczach całkowitych, zaczynając od 1, i zatrzymuje się przy pierwszej wartości nil. Jest bezpieczne, przewidywalne i zachowuje kolejność. Używaj ipairs dla tabel przypominających tablice, gdy kolejność ma znaczenie i chcesz zatrzymać się przy pierwszej luce.

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

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

-- stops at first nil
local t = {10, 20, nil, 40}
for i, v in ipairs(t) do
  print(i, v)  -- only 1,10 and 2,20
end

pairs a ipairs

Warto wiedzieć, kiedy używać każdej z tych funkcji: ipairs służy do uporządkowanych, sekwencyjnych tablic, a pairs do słowników lub tabel mieszanych. ipairs zatrzymuje się przy pierwszej luce oznaczonej wartością nil, natomiast pairs odwiedza każdy klucz o wartości innej niż nil. W przypadku czystych tablic bardziej idiomatyczne jest użycie ipairs.

local mixed = {10, 20, key="val", 30}

-- ipairs only sees array part in order
print("ipairs:")
for i, v in ipairs(mixed) do
  print(i, v)  -- 1:10, 2:20, 3:30
end

-- pairs sees everything
print("pairs:")
for k, v in pairs(mixed) do
  print(k, v)  -- 1:10, 2:20, 3:30, key:val
end

Własny iterator z domknięciem

Możesz napisać własny iterator jako domknięcie. Funkcja fabrykująca zwraca domknięcie przechowujące stan, które przy każdym wywołaniu przesuwa pozycję. Gdy nie ma już nic do zwrócenia, zwraca nil, aby zatrzymać generyczną pętlę for.

local function range(from, to, step)
  step = step or 1
  local i = from - step
  return function()
    i = i + step
    if i <= to then return i end
  end
end

for n in range(1, 10, 2) do
  io.write(n .. " ")
end
print()  -- 1 3 5 7 9

string.gmatch jako iterator

string.gmatch(s, pattern) zwraca iterator przechodzący przez wszystkie dopasowania wzorca w napisie s. Jest często używane do dzielenia napisów, wyodrębniania tokenów lub znajdowania wszystkich wystąpień wzorca.

local sentence = "the quick brown fox"

for word in string.gmatch(sentence, "%a+") do
  print(word)
end
-- the
-- quick
-- brown
-- fox

break w generycznej pętli for

Możesz wcześniej zakończyć generyczną pętlę for za pomocą break. Jest to przydatne podczas wyszukiwania: iteruj, aż znajdziesz dopasowanie, a następnie użyj break. Po jego wykonaniu program przechodzi do instrukcji znajdującej się za end.

local inventory = {
  {name="sword", damage=50},
  {name="shield", armor=30},
  {name="bow", damage=35},
}

local target = "shield"
for i, item in ipairs(inventory) do
  if item.name == target then
    print("Found at index", i)
    break
  end
end

Modyfikowanie tabel podczas iteracji

Nigdy nie dodawaj ani nie usuwaj kluczy z tabeli podczas iterowania za pomocą pairs() — zachowanie jest niezdefiniowane (niektóre zmiany mogą zostać zauważone, a inne pominięte). Jeśli musisz zmodyfikować tabelę, zapisz zmiany na tymczasowej liście i zastosuj je po zakończeniu pętli.

local t = {a=1, b=2, c=3, d=4}
local toDelete = {}

-- Collect keys to delete
for k, v in pairs(t) do
  if v % 2 == 0 then
    toDelete[#toDelete+1] = k
  end
end

-- Delete after iteration
for _, k in ipairs(toDelete) do
  t[k] = nil
end
-- t = {a=1, c=3}

Wzorzec enumeracji

Gdy potrzebujesz zarówno indeksu, jak i wartości, użyj ipairs, które udostępnia obie te informacje. Gdy potrzebujesz tylko wartości i indeks nie ma znaczenia, możesz użyć _ jako konwencjonalnej nazwy zmiennej oznaczającej „nieużywana” dla indeksu.

local colors = {"red", "green", "blue"}

-- With index
for i, color in ipairs(colors) do
  print(i .. ": " .. color)
end

-- Ignore index with _
for _, color in ipairs(colors) do
  print(color)  -- just the values
end

Bezpośrednie użycie next()

next(t, key) to podstawowa funkcja przechodzenia po tabeli. Zwraca następną parę klucz-wartość po key albo nil, jeśli nie ma już kolejnych elementów. next(t, nil) zwraca pierwszy wpis. Możesz użyć next(t) ~= nil, aby sprawdzić, czy tabela nie jest pusta — jest to szybsze niż zliczanie elementów.

local function isEmpty(t)
  return next(t) == nil
end

print(isEmpty({}))       -- true
print(isEmpty({1,2,3}))  -- false
print(isEmpty({a=1}))    -- false

Szybkie sprawdzenie

Który iterator zatrzymuje się przy pierwszej luce o wartości nil w tabeli?

Odpowiedz w interaktywnej lekcji

Podsumowanie: generyczna pętla for i break

Podsumowanie:

pairs(t) — wszystkie klucze, w dowolnej kolejności
ipairs(t) — klucze całkowite 1..n, w kolejności, zatrzymuje się przy nil
Własne iteratory: zwracają domknięcie, które zwraca nil w celu zatrzymania pętli
break kończy pętlę przed czasem
Nigdy nie modyfikuj tabeli podczas iterowania za pomocą pairs; zbierz zmiany i zastosuj je później
next(t) == nil — szybkie sprawdzenie, czy tabela jest pusta

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 „for ogólne i break” jest bezpłatna?

Tak — pełny tekst „for ogólne i break” 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 „for ogólne i break”?

Proszę używać ogólnej pętli for z pairs/ipairs oraz sterować przebiegiem pętli za pomocą break. Ć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 4 z 4.

Ile czasu zajmuje lekcja „for ogólne i break”?

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