Lua Academy · Lekcja

Deklarowanie zmiennych w Lua

Proszę poznać zmienne globalne i lokalne oraz konwencje nazewnicze.

Deklarowanie zmiennych w Lua 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.

Zmienne globalne a lokalne

W Lua zmienne są domyślnie globalne. Zapisanie x = 10 bez słowa kluczowego local tworzy zmienną globalną dostępną z dowolnego miejsca. Użycie local x = 10 ogranicza zmienną do bieżącego bloku i jego bloków zagnieżdżonych.

Należy zawsze preferować local ze względu na wydajność i bezpieczeństwo. Dostęp do zmiennej lokalnej jest szybszy niż do globalnej, ponieważ zmienne globalne wymagają wyszukania w tabeli mieszającej _G.

x = 100          -- global variable
local y = 200    -- local variable

do
  local z = 300  -- block-local
  print(x, y, z) -- 100  200  300
end

print(x, y)      -- 100  200
print(z)         -- nil  (out of scope)

Słowo kluczowe local

Słowo kluczowe local deklaruje zmienną, której zakres obejmuje najbliższy otaczający blok: ciało funkcji, blok do...end, ciało pętli lub fragment kodu pliku. Zmienne lokalne są tworzone w wierszu, w którym je zadeklarowano, i przestają istnieć na końcu swojego bloku.

Można zadeklarować wiele zmiennych lokalnych w jednym wierszu i jednocześnie je zainicjalizować. Niezainicjalizowane zmienne lokalne domyślnie mają wartość nil.

local a, b, c = 1, 2, 3
print(a, b, c)    -- 1  2  3

local d, e = 10   -- e is nil
print(d, e)       -- 10  nil

local f           -- nil until assigned
f = 42
print(f)          -- 42

Konwencje nazewnictwa zmiennych

Identyfikatory Lua podlegają następującym zasadom: muszą zaczynać się od litery lub podkreślenia, po których mogą występować litery, cyfry lub podkreślenia. Lua rozróżnia wielkość liter, dlatego Value, value i VALUE to trzy różne zmienne.

Zgodnie z konwencją: dla zwykłych zmiennych należy używać camelCase lub snake_case, dla stałych UPPER_CASE, a prywatne pola modułu poprzedzać podkreśleniem. Należy unikać nazw jednoliterowych, z wyjątkiem liczników pętli.

local myVariable = 1     -- camelCase
local my_variable = 2    -- snake_case
local MAX_SIZE = 100     -- constant convention
local _private = "hidden" -- private convention

-- Case sensitivity demo
local lua = "lower"
local Lua = "upper"
print(lua, Lua)  -- lower  upper

Globalna tabela _G

Wszystkie zmienne globalne w Lua znajdują się w specjalnej tabeli o nazwie _G. Zapis x = 10 jest równoważny zapisowi _G.x = 10. Można przejrzeć wszystkie zmienne globalne, iterując po _G, co jest przydatne podczas debugowania, ale niebezpieczne w kodzie produkcyjnym.

W Lua 5.2+ _ENV jest właściwą tabelą środowiska, a _G jest inicjalizowana tak, aby na nią wskazywać. Zrozumienie tej zależności pozwala izolować kod w piaskownicy przez zastąpienie _ENV.

myGlobal = 42
print(_G.myGlobal)   -- 42

-- Setting via _G is the same as direct assignment
_G.another = "hello"
print(another)        -- hello

-- Counting globals (many built-ins exist)
local count = 0
for k in pairs(_G) do count = count + 1 end
print("Globals:", count)

Wielokrotne przypisanie

Lua obsługuje wielokrotne przypisanie: można przypisać wartości kilku zmiennym w jednej instrukcji. Najpierw obliczana jest prawa strona, a następnie wartości są przypisywane od lewej do prawej. Jeśli zmiennych jest więcej niż wartości, nadmiarowe zmienne otrzymują nil. Jeśli wartości jest więcej niż zmiennych, nadmiarowe wartości są odrzucane.

Dzięki temu zamiana zmiennych jest prosta i nie wymaga zmiennej tymczasowej.

-- Swap without temp variable
local a, b = 10, 20
a, b = b, a
print(a, b)   -- 20  10

-- More variables than values
local x, y, z = 1, 2
print(x, y, z)  -- 1  2  nil

-- More values than variables
local p, q = 1, 2, 3  -- 3 is discarded
print(p, q)   -- 1  2

Zakres i granice bloków

W Lua wyróżnia się następujące ograniczniki bloków: do...end, ciała funkcji, if/elseif/else...end, while...end, repeat...until i for...end. Każdy z nich tworzy nowy poziom zakresu. Bloki do...end są przydatne wyłącznie do ograniczania zakresu, bez dodawania innej logiki.

Zmienna lokalna zadeklarowana w nagłówku pętli for ma zakres ograniczony do ciała pętli — nie jest dostępna poza nim.

for i = 1, 3 do
  local msg = "item " .. i
  print(msg)
end
-- print(i)   -- would be nil, i is gone
-- print(msg) -- would be nil, msg is gone

-- do...end for manual scoping
do
  local temp = expensive_computation or 0
  print(temp)
end
-- temp is nil here

Stałe: konwencja local

Lua nie ma wbudowanego słowa kluczowego const. Zgodnie z konwencją używa się nazw UPPER_CASE oraz local, aby zasygnalizować, że wartość nie powinna się zmieniać. Umieszczenie stałych na początku modułu jako zmiennych lokalnych podpowiada również kompilatorowi JIT, że wartości te są niezmienne.

Aby uzyskać prawdziwą niezmienność, można użyć tabeli proxy z __newindex, która zgłasza błąd przy modyfikacji — omówimy to w lekcji poświęconej metatabelom.

local MAX_RETRIES = 3
local PI = 3.14159265358979
local APP_VERSION = "1.0.0"

-- Use them as read-only by convention
local area = PI * 5 * 5
print(area)           -- 78.539...
print(MAX_RETRIES)    -- 3

Przesłanianie zmiennych

Przesłanianie występuje, gdy zakres wewnętrzny deklaruje zmienną lokalną o tej samej nazwie co zmienna zewnętrzna. Wewnętrzna deklaracja tworzy zupełnie nową zmienną, która ukrywa zewnętrzną w swoim zakresie. Zmienna zewnętrzna pozostaje niezmieniona i staje się ponownie widoczna po zakończeniu zakresu wewnętrznego.

Przesłanianie może być mylące; należy preferować unikatowe nazwy w zagnieżdżonych zakresach, choć czasami jest ono zamierzone, na przykład przy ponownym używaniu nazw zmiennych pętli w pętlach zagnieżdżonych.

local x = "outer"
do
  local x = "inner"  -- shadows outer x
  print(x)            -- inner
end
print(x)              -- outer (unchanged)

local n = 10
for n = 1, 3 do       -- loop n shadows outer n
  print(n)            -- 1, 2, 3
end
print(n)              -- 10 (outer unchanged)

Unikanie zaśmiecania zakresu globalnego

Przypadkowe zmienne globalne są częstym błędem w Lua: literówka w nazwie zmiennej lokalnej po cichu tworzy nową zmienną globalną. Moduł strict.lua (często dołączany do projektów) wykrywa odczyty i zapisy niezadeklarowanych zmiennych globalnych, dodając metatabelę do _G.

Prostsze rozwiązanie polega na tym, aby zawsze używać local oraz uruchamiać luac -p lub linter, taki jak luacheck, w celu wykrycia przypadkowych zmiennych globalnych przed uruchomieniem programu.

-- Dangerous: typo creates a global silently
local counter = 0
coutner = 5  -- typo! creates global 'coutner'
print(counter)  -- 0 (not 5!)
print(coutner)  -- 5 (the typo global)

-- Fix: always use local keyword
local score = 0
score = 10  -- assigns to existing local
print(score) -- 10

Przypisanie nil usuwa zmienne globalne

Ustawienie zmiennej globalnej na nil usuwa ją z _G, zwalniając pamięć. To właściwy sposób na „usunięcie” zmiennej globalnej. W przypadku zmiennych lokalnych taki sam efekt daje wyjście zmiennej poza zakres — moduł garbage collectora odzyskuje zajmowaną przez nią pamięć.

Należy zachować ostrożność podczas przekazywania nil w wielokrotnym przypisaniu: w niektórych kontekstach może ono skrócić listę argumentów, zwłaszcza gdy prawa strona zawiera wywołanie funkcji.

myGlobal = "exists"
print(myGlobal)   -- exists
print(_G.myGlobal ~= nil)  -- true

myGlobal = nil
print(myGlobal)   -- nil
print(_G.myGlobal ~= nil)  -- false
-- The entry is removed from _G

Szybkie sprawdzenie

Jaki jest zakres zmiennej zadeklarowanej za pomocą local x = 5 wewnątrz ciała pętli for?

Podsumowanie: deklarowanie zmiennych w Lua

Najważniejsze informacje z tej lekcji:

Zmienne są domyślnie globalne — zawsze należy używać local
Zmienne lokalne są szybsze (nie wymagają wyszukiwania w tabeli mieszającej) i bezpieczniejsze
Wielokrotne przypisanie: a, b = b, a zamienia wartości w jednym wierszu
Wszystkie zmienne globalne znajdują się w _G; ustawienie ich na nil usuwa je
Przesłanianie: wewnętrzna zmienna local ukrywa zewnętrzną bez jej zmieniania
Zgodnie z konwencją dla stałych należy używać UPPER_CASE

Następnie: operatory arytmetyczne, relacyjne i logiczne.

Często zadawane pytania

Czy lekcja „Deklarowanie zmiennych w Lua” jest bezpłatna?

Tak — pełny tekst „Deklarowanie zmiennych w Lua” 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 „Deklarowanie zmiennych w Lua”?

Proszę poznać zmienne globalne i lokalne oraz konwencje nazewnicze. Ć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 „Deklarowanie zmiennych w Lua”?

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