Lua Academy · Lekcja

Tabele jako słowniki

Proszę używać kluczy tekstowych i mieszanych do przechowywania par klucz-wartość.

Lekcja 2 z 412 kroki

Tabele jako słowniki 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.

Klucze tekstowe

Tabele z kluczami tekstowymi działają jak słowniki (mapy haszujące). Do uzyskiwania dostępu do pól należy używać notacji kropkowej t.key (dla prawidłowych identyfikatorów) lub notacji nawiasowej t["key"] (dla dowolnego tekstu). Obie formy są równoważne, ale notacja nawiasowa obsługuje klucze dynamiczne.

local user = {}
user.name = "Alice"
user["age"] = 30
user.role = "admin"

print(user.name)        -- Alice
print(user["age"])      -- 30

local field = "role"
print(user[field])      -- admin (dynamic key)

Literały tabel

Słowniki można inicjalizować za pomocą literału tabeli z użyciem składni key = value. Jest to najczęstszy sposób tworzenia rekordów w Lua. W jednym literale można łączyć wpisy w stylu tablicowym i słownikowym.

local config = {
  host = "localhost",
  port = 3306,
  database = "myapp",
  debug = false,
  tags = {"web", "api"},  -- nested array
}

print(config.host)        -- localhost
print(config.port)        -- 3306
print(config.tags[1])     -- web

Zliczanie za pomocą słowników

Klasycznym zastosowaniem słownika jest zliczanie częstotliwości występowania. Należy iterować po liście, używając każdego elementu jako klucza i zwiększając licznik. Przed zwiększeniem licznika trzeba sprawdzić, czy wartość nie wynosi nil — jako wartość początkową należy użyć count[word] or 0.

local words = {"lua","is","fast","lua","is","lua"}
local freq = {}

for _, w in ipairs(words) do
  freq[w] = (freq[w] or 0) + 1
end

for word, count in pairs(freq) do
  print(word, count)
end
-- lua 3, is 2, fast 1

Grupowanie za pomocą słowników

Aby pogrupować dane według właściwości, należy iterować po liście i używać klucza grupowania do dodawania elementów do listy w słowniku. Jest to odpowiednik SQL-owego GROUP BY lub wzorca defaultdict z języka Python w Lua.

local people = {
  {name="Alice", dept="eng"},
  {name="Bob",   dept="hr"},
  {name="Carol", dept="eng"},
  {name="Dave",  dept="hr"},
}
local groups = {}

for _, p in ipairs(people) do
  local d = p.dept
  groups[d] = groups[d] or {}
  groups[d][#groups[d]+1] = p.name
end

print(table.concat(groups.eng, ", "))  -- Alice, Carol

Sprawdzanie istnienia klucza

Istnienie klucza należy sprawdzać, porównując jego wartość z nil. Należy zachować ostrożność: jeśli wartość przechowywana pod kluczem jest równa nil, klucz jest uznawany za nieobecny. W przypadku flag obecności jako wartość należy przechowywać true, a nie nil.

local cache = {result=42, mode="fast"}

if cache.result ~= nil then
  print("cached:", cache.result)  -- 42
end

-- Key not present:
if cache.timeout == nil then
  print("no timeout set")
end

-- Membership set pattern
local allowed = {admin=true, editor=true}
if allowed["admin"] then
  print("access granted")
end

Usuwanie kluczy

Aby usunąć klucz z tabeli, należy przypisać mu wartość nil. Para klucz-wartość znika, a garbage collector może odzyskać pamięć zajmowaną przez wartość. W ten sposób nie można usunąć zmiennej lokalnej — dotyczy to tylko wpisów tabeli.

local session = {token="abc123", user="Alice", expires=3600}
print(session.token)   -- abc123

session.token = nil
print(session.token)   -- nil (removed)

-- Count remaining keys
local count = 0
for _ in pairs(session) do count = count + 1 end
print(count)   -- 2

Scalanie słowników

Dwie tabele można scalić, iterując po jednej z nich i kopiując jej wpisy do drugiej. Jeśli obie mają ten sam klucz, wygrywa wartość z drugiej tabeli. Jest to odpowiednik Object.assign z JavaScriptu w Lua.

local defaults = {color="blue", size=12, bold=false}
local overrides = {color="red", italic=true}

local function merge(base, over)
  local result = {}
  for k, v in pairs(base) do result[k] = v end
  for k, v in pairs(over) do result[k] = v end
  return result
end

local opts = merge(defaults, overrides)
print(opts.color, opts.size, opts.italic)  -- red 12 true

Dowolny typ klucza

Kluczami tabel mogą być dowolne wartości inne niż nil i NaN: teksty, liczby, wartości logiczne, funkcje, a nawet inne tabele. Klucze całkowitoliczbowe i tekstowe są wewnętrznie przechowywane w różny sposób, ale dostęp do obu uzyskuje się jednolicie za pomocą notacji nawiasowej.

local t = {}
local function myKey() end

t["string"] = 1
t[42] = 2
t[true] = 3
t[myKey] = 4

print(t["string"])  -- 1
print(t[42])        -- 2
print(t[true])      -- 3
print(t[myKey])     -- 4

Iteracja w określonej kolejności

Funkcja pairs() w Lua nie gwarantuje kolejności iteracji. Aby iterować w określonej kolejności, należy zebrać klucze w tablicy, posortować ją, a następnie wykonać iterację.

local scores = {Alice=95, Bob=87, Carol=91, Dave=78}

local names = {}
for name in pairs(scores) do
  names[#names+1] = name
end
table.sort(names)

for _, name in ipairs(names) do
  print(name, scores[name])
end
-- Alice 95, Bob 87, Carol 91, Dave 78 (sorted)

Wzorzec wartości domyślnych

Przydatnym wzorcem jest tabela „defaults” udostępniana za pomocą metatabeli __index. Gdy klucz nie zostanie znaleziony w głównej tabeli, Lua szuka go w tabeli wartości domyślnych. Umożliwia to tworzenie warstwowej konfiguracji bez scalania tabel.

local defaults = {timeout=30, retries=3, verbose=false}
local config = {timeout=60}

setmetatable(config, {__index = defaults})

print(config.timeout)  -- 60  (overridden)
print(config.retries)  -- 3   (from defaults)
print(config.verbose)  -- false (from defaults)

Szybkie sprawdzenie

Jak usunąć klucz "x" z tabeli t w Lua?

Odpowiedz w interaktywnej lekcji

Podsumowanie: tabele jako słowniki

Najważniejsze informacje:

Notacja kropkowa i nawiasowa: t.key == t["key"]
Kluczem może być dowolna wartość inna niż nil i NaN
Aby usunąć klucz, należy przypisać mu nil
Zliczanie częstotliwości: t[k] = (t[k] or 0) + 1
Iteracja w określonej kolejności: zebranie kluczy → sortowanie → iteracja
Do wartości domyślnych należy używać metatabeli __index

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 „Tabele jako słowniki” jest bezpłatna?

Tak — pełny tekst „Tabele jako słowniki” 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 słowniki”?

Proszę używać kluczy tekstowych i mieszanych do przechowywania par klucz-wartość. Ć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 „Tabele jako słowniki”?

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