Tabele jako tablice
Proszę tworzyć i modyfikować tablice indeksowane od 1 za pomocą table.insert i table.remove.
Tabele jako tablice 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.
Tablice indeksowane od 1
Tablice w Lua są tabelami z kolejnymi kluczami całkowitymi zaczynającymi się od 1. Różni je to od większości języków, w których indeksowanie zaczyna się od 0. Konwencja ta jest uniwersalna w Lua — wszystkie funkcje biblioteki standardowej zakładają indeksowanie od 1. Dostęp poza zakresem zwraca nil, a nie błąd.
local colors = {"red", "green", "blue"}
print(colors[1]) -- red
print(colors[2]) -- green
print(colors[3]) -- blue
print(colors[0]) -- nil (no index 0)
print(#colors) -- 3 (length operator)table.insert i table.remove
table.insert(t, val) dodaje element na końcu. table.insert(t, pos, val) wstawia element na określonej pozycji, przesuwając pozostałe elementy w prawo. table.remove(t, pos) usuwa element z pozycji pos (domyślnie: ostatni), przesuwa pozostałe elementy w lewo i zwraca usuniętą wartość.
local stack = {}
table.insert(stack, "first")
table.insert(stack, "second")
table.insert(stack, "third")
print(#stack) -- 3
table.insert(stack, 2, "inserted")
print(stack[2]) -- inserted
local removed = table.remove(stack, 1)
print(removed) -- first
print(stack[1]) -- insertedStos z użyciem tabel
Tabela Lua doskonale nadaje się do implementacji stosu. Użyj table.insert, aby odłożyć element, oraz table.remove, aby go pobrać. Obie operacje domyślnie działają na końcu tabeli, zapewniając zamortyzowaną złożoność czasową O(1).
local stack = {}
-- Push
table.insert(stack, 10)
table.insert(stack, 20)
table.insert(stack, 30)
-- Pop
print(table.remove(stack)) -- 30
print(table.remove(stack)) -- 20
print(#stack) -- 1Kolejka z użyciem tabel
Kolejkę (FIFO) można zaimplementować za pomocą tabeli, ale table.remove(t, 1) ma złożoność O(n), ponieważ przesuwa wszystkie elementy. Wydajne kolejki powinny używać dwóch wskaźników (indeksów początku i końca), aby uniknąć przesuwania.
local head, tail = 1, 0
local queue = {}
local function enqueue(v)
tail = tail + 1
queue[tail] = v
end
local function dequeue()
if head > tail then return nil end
local v = queue[head]
queue[head] = nil
head = head + 1
return v
end
enqueue("a"); enqueue("b"); enqueue("c")
print(dequeue()) -- a
print(dequeue()) -- bOperator długości #
Operator # zwraca „granicę” tabeli: indeks i, dla którego t[i] ~= nil oraz t[i+1] == nil. W przypadku sekwencji bez luk odpowiada to długości tablicy. Jeśli w środku znajdują się luki (wartości nil), # daje nieokreślone wyniki — należy użyć table.pack albo samodzielnie śledzić długość.
local t = {10, 20, 30, 40, 50}
print(#t) -- 5
-- Safe for dense arrays
for i = #t, 1, -1 do
io.write(t[i] .. " ")
end
print() -- 50 40 30 20 10Wycinanie fragmentów tablic
Lua nie ma wbudowanej operacji wycinania fragmentu, ale można wyodrębnić podtablicę za pomocą table.move (Lua 5.3+) lub pętli napisanej ręcznie. table.move(a1, f, e, t, a2) kopiuje elementy z a1[f..e] do a2, zaczynając od pozycji t.
local src = {10,20,30,40,50,60}
-- Manual slice
local function slice(t, from, to)
local result = {}
for i = from, to do
result[#result+1] = t[i]
end
return result
end
local sub = slice(src, 2, 4)
print(sub[1], sub[2], sub[3]) -- 20 30 40Odwracanie tablicy
Tablicę można odwrócić w miejscu, zamieniając elementy z obu końców i przesuwając się w kierunku środka. Jest to klasyczny algorytm, który działa na każdej tablicy Lua bez użycia dodatkowej pamięci.
local function reverse(t)
local n = #t
for i = 1, math.floor(n / 2) do
t[i], t[n - i + 1] = t[n - i + 1], t[i]
end
end
local arr = {1, 2, 3, 4, 5}
reverse(arr)
for _, v in ipairs(arr) do
io.write(v .. " ")
end
print() -- 5 4 3 2 1Łączenie tablic
Aby połączyć dwie tablice w jedną, iteruj po drugiej tablicy i dodawaj jej elementy na końcu. W Lua 5.3+ można wydajnie użyć table.move. Wynikiem jest nowa tabela zawierająca po kolei wszystkie elementy obu tablic.
local function concat(a, b)
local result = {}
for _, v in ipairs(a) do result[#result+1] = v end
for _, v in ipairs(b) do result[#result+1] = v end
return result
end
local merged = concat({1,2,3}, {4,5,6})
for i, v in ipairs(merged) do
io.write(v .. " ")
end
print() -- 1 2 3 4 5 6Spłaszczanie zagnieżdżonych tablic
Rekurencyjnie spłaszczaj zagnieżdżoną tablicę: jeśli element jest tabelą, wywołaj funkcję rekurencyjnie dla tego elementu; w przeciwnym razie dodaj go do wyniku. Jest to naturalne zastosowanie rekurencyjnego przechodzenia po tabeli.
local function flatten(t, result)
result = result or {}
for _, v in ipairs(t) do
if type(v) == "table" then
flatten(v, result)
else
result[#result+1] = v
end
end
return result
end
local nested = {1, {2, 3}, {4, {5, 6}}, 7}
local flat = flatten(nested)
print(table.concat(flat, ", ")) -- 1, 2, 3, 4, 5, 6, 7Tablica jako zbiór
Można zaimplementować zbiór za pomocą tabeli, w której wartości są kluczami, a przypisana do nich wartość to true. Sprawdzanie przynależności do zbioru ma złożoność O(1). Utworzenie zbioru z tablicy usuwa duplikaty. Aby ponownie uzyskać tablicę, należy iterować po tabeli za pomocą pairs.
local function toSet(arr)
local set = {}
for _, v in ipairs(arr) do set[v] = true end
return set
end
local nums = {3,1,4,1,5,9,2,6,5,3}
local set = toSet(nums)
local unique = {}
for k in pairs(set) do unique[#unique+1] = k end
table.sort(unique)
print(table.concat(unique, " ")) -- 1 2 3 4 5 6 9Szybkie sprawdzenie
Co robi table.remove(t), gdy wywołamy je tylko z jednym argumentem?
Podsumowanie: tabele jako tablice
Podsumowanie:
- Tablice w Lua to indeksowane od 1 tabele
table.insert/table.removesłużą do operacji push/pop#tpodaje długość sekwencji, która nie zawiera luk- Stos: wstawianie/usuwanie na końcu (O(1))
- Kolejka: należy używać wskaźników początku i końca, aby uniknąć przesuwania w O(n)
- Do testów przynależności w O(1) należy używać tabeli jako zbioru
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 „Tabele jako tablice” jest bezpłatna?
Tak — pełny tekst „Tabele jako tablice” 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 „Tabele jako tablice”?
Proszę tworzyć i modyfikować tablice indeksowane od 1 za pomocą table.insert i table.remove. Ć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 „Tabele jako tablice”?
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