Lua Academy · Lekcja

Przegląd typów danych Lua

Proszę poznać typy nil, boolean, number, string, table, function i userdata.

Przegląd typów danych Lua 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.

Witamy w Lua

Lua to lekki, szybki i możliwy do osadzania język skryptowy używany w silnikach gier, serwerach internetowych i systemach wbudowanych. Zanim zaczną Państwo pisać rzeczywiste programy, należy zrozumieć, jak Lua reprezentuje dane.

Lua ma 8 podstawowych typów: nil, boolean, number, string, table, function, userdata i thread. Każda wartość w Lua należy dokładnie do jednego z tych typów.

-- Check the type of any value with type()
print(type(42))        -- number
print(type("hello"))   -- string
print(type(true))      -- boolean
print(type(nil))       -- nil

nil: brak wartości

nil to sposób Lua na reprezentowanie niczego lub braku wartości. Jest to jedyna wartość tego typu. Zmienne, którym nigdy nie przypisano wartości, automatycznie zawierają nil.

Przypisanie nil zmiennej globalnej skutecznie ją usuwa. W tabelach ustawienie klucza na nil całkowicie usuwa dany wpis.

-- Unassigned variables are nil
print(x)          -- nil

x = 10
print(x)          -- 10

x = nil
print(x)          -- nil (variable is gone)

boolean: true i false

Typ boolean ma dokładnie dwie wartości: true i false. Zasady określania wartości logicznych w Lua są proste, ale ważne: tylko nil i false są traktowane jako fałsz. Wszystkie pozostałe wartości — w tym liczba 0 i pusty ciąg znaków "" — są traktowane jako prawda.

Różni się to od wielu języków, w których 0 lub "" uznaje się za fałsz.

-- Lua truthiness examples
if 0 then print("0 is truthy!") end       -- prints!
if "" then print("empty str is truthy!") end -- prints!
if nil then print("nil") else print("nil is falsy") end
if false then print("false") else print("false is falsy") end

number: liczby całkowite i zmiennoprzecinkowe

Lua 5.3+ ma dwa podtypy number: integer i float. Liczby całkowite są dokładnymi wartościami 64-bitowymi, a liczby zmiennoprzecinkowe używają podwójnej precyzji IEEE 754. W Lua 5.1/5.2 wszystkie liczby są typu double.

Funkcja math.type() rozróżnia te dwa podtypy. Dzielenie za pomocą / zawsze zwraca liczbę zmiennoprzecinkową, a // (dzielenie całkowite z zaokrągleniem w dół) zwraca liczbę całkowitą, gdy oba operandy są całkowite.

print(type(10))       -- number
print(type(10.5))     -- number
print(math.type(10))  -- integer
print(math.type(10.5))-- float
print(10 / 3)         -- 3.3333...
print(10 // 3)        -- 3  (floor division)

string: tekst w Lua

Ciągi znaków w Lua są niezmiennymi sekwencjami bajtów. Można je ograniczać pojedynczymi lub podwójnymi cudzysłowami albo używać długich nawiasów [[...]] w przypadku ciągów wieloliniowych. Ciągi w długich nawiasach pomijają pierwszy znak nowej linii, a całą pozostałą zawartość zachowują dosłownie.

Ciągi znaków Lua są internowane, więc identyczne ciągi współdzielą pamięć. Operator długości # zwraca liczbę bajtów.

local s1 = 'single quotes'
local s2 = "double quotes"
local s3 = [[multi-line
long string]]

print(#s1)           -- 13
print(type(s1))      -- string
print(s1 .. " works") -- concatenation with ..

table: uniwersalny kontener

Typ table to jedyna złożona struktura danych w Lua, ale jest wystarczająco elastyczny, aby implementować tablice, słowniki, obiekty, zbiory i wiele innych struktur. Tabele są tablicami asocjacyjnymi: mapują klucze na wartości, przy czym kluczem może być dowolna wartość różna od nil i NaN.

Tabele tworzy się za pomocą nawiasów klamrowych {}. Tabele używane jak tablice korzystają z kluczy całkowitych zaczynających się od 1.

-- Array style
local fruits = {"apple", "banana", "cherry"}
print(fruits[1])   -- apple (1-indexed!)

-- Dictionary style
local person = {name = "Alice", age = 30}
print(person.name) -- Alice
print(person["age"]) -- 30

function: wartości pierwszej klasy

Funkcje w Lua są wartościami pierwszej klasy typu function. Można przechowywać je w zmiennych, przekazywać jako argumenty i zwracać z innych funkcji. Dzięki temu Lua naturalnie nadaje się do stosowania wzorców programowania funkcyjnego.

Funkcje można definiować za pomocą słowa kluczowego function albo przypisywać funkcje anonimowe do zmiennych. Obie formy są równoważne.

-- Two equivalent ways to define a function
function greet(name)
  return "Hello, " .. name
end

local greet2 = function(name)
  return "Hello, " .. name
end

print(type(greet))   -- function
print(greet("Lua"))  -- Hello, Lua

userdata i thread

userdata reprezentuje dowolne dane C zarządzane przez aplikację hostującą. Nie można tworzyć wartości userdata w czystym Lua — pochodzą one z rozszerzeń C lub środowisk osadzających, takich jak silniki gier. Umożliwiają kodowi C udostępnianie obiektów skryptom Lua.

thread reprezentuje korutyny — niezależne wątki wykonywania z własnymi stosami. Korutyny omówimy w osobnej lekcji. Na razie należy wiedzieć, że coroutine.create() zwraca wartość typu thread.

-- thread type via coroutine
local co = coroutine.create(function()
  print("coroutine body")
end)

print(type(co))  -- thread

-- userdata comes from C, not creatable in pure Lua
-- type(io.stdin) == "file" is a userdata variant

Używanie type() do sprawdzania wartości

Wbudowana funkcja type() zawsze zwraca ciąg znaków określający typ swojego argumentu. Jest to przydatne w programowaniu defensywnym i debugowaniu. Wynik można bezpośrednio porównywać z ciągami zawierającymi nazwy typów.

Należy pamiętać, że type(nil) zwraca ciąg "nil", a nie samą wartość nil. Dzięki temu można bezpiecznie sprawdzić, czy zmienna zawiera nil, bez powodowania błędów.

local values = {42, "hi", true, nil, {}, function() end}

-- Note: nil in table stops ipairs early
for i = 1, 3 do
  print(i, type(values[i]))
end
-- 1  number
-- 2  string
-- 3  boolean

Różnice między typami Lua a innymi językami

Jeśli znają Państwo JavaScript, Python lub Java, kilka zasad dotyczących typów w Lua może być zaskakujących. Nie ma osobnego typu całkowitoliczbowego widocznego dla funkcji type() — zarówno liczby całkowite, jak i zmiennoprzecinkowe zwracają "number". Tablice nie mają własnego typu — są po prostu tabelami. Klasy nie istnieją — obiekty to tabele z metatabelami.

Zrozumienie tych różnic pomaga zapobiegać typowym błędom podczas przechodzenia między językami.

-- No separate array type
local arr = {1, 2, 3}
print(type(arr))      -- table (not array!)

-- No separate integer type visible
print(type(1))        -- number
print(type(1.0))      -- number

-- math.type distinguishes
print(math.type(1))   -- integer
print(math.type(1.0)) -- float

Szybkie sprawdzenie

Co zwraca type(0) w Lua?

Podsumowanie: przegląd typów danych Lua

Znają już Państwo wszystkie 8 typów Lua:

nil — brak wartości; traktowany jako fałsz
boolean — true/false; tylko nil i false są traktowane jako fałsz
number — liczba całkowita lub zmiennoprzecinkowa; do ich rozróżnienia służy math.type()
string — niezmienne sekwencje bajtów; do łączenia służy ..
table — uniwersalny kontener dla tablic i słowników
function — wartości pierwszej klasy, które można przechowywać w zmiennych
userdata — dane C udostępniane językowi Lua
thread — uchwyty korutyn

Następnie: deklarowanie zmiennych — zakres globalny a lokalny.

Często zadawane pytania

Czy lekcja „Przegląd typów danych Lua” jest bezpłatna?

Tak — pełny tekst „Przegląd typów danych 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 „Przegląd typów danych Lua”?

Proszę poznać typy nil, boolean, number, string, table, function i userdata. Ć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 „Przegląd typów danych 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