Lua Academy · Lekcja

Operatory arytmetyczne i relacyjne

Proszę skutecznie używać operatorów +, -, *, /, //, %, ^ oraz operatorów porównania.

Operatory arytmetyczne i relacyjne to bezpłatna lekcja Lua Academy na CoddyKit. To lekcja 3 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.

Przegląd operatorów arytmetycznych

Lua udostępnia pełny zestaw operatorów arytmetycznych: + (dodawanie), - (odejmowanie), * (mnożenie), / (dzielenie zmiennoprzecinkowe), // (dzielenie całkowite z zaokrągleniem w dół), % (reszta z dzielenia), ^ (potęgowanie) oraz jednoargumentowy - (negacja). W Lua 5.3+ kluczowe jest zrozumienie, kiedy wynik ma typ całkowity, a kiedy zmiennoprzecinkowy.

print(10 + 3)   -- 13
print(10 - 3)   -- 7
print(10 * 3)   -- 30
print(10 / 3)   -- 3.3333...  (always float)
print(10 // 3)  -- 3          (floor division)
print(10 % 3)   -- 1          (modulo)
print(2 ^ 10)   -- 1024.0     (always float)
print(-5)       -- -5

Dzielenie całkowite a zmiennoprzecinkowe

Operator / zawsze zwraca liczbę zmiennoprzecinkową, nawet gdy dzielimy dwie liczby całkowite bez reszty. Operator dzielenia całkowitego // zwraca liczbę całkowitą tylko wtedy, gdy oba operandy są całkowite; jeśli którykolwiek operand jest zmiennoprzecinkowy, wynik również jest zmiennoprzecinkowy, ale nadal zostaje zaokrąglony w dół.

Operator potęgowania ^ zawsze konwertuje wynik na liczbę zmiennoprzecinkową, dlatego 2^3 daje 8.0, a nie 8. W razie potrzeby można użyć math.tointeger(), aby przeprowadzić konwersję z powrotem.

print(6 / 2)        -- 3.0  (float!)
print(6 // 2)       -- 3    (integer)
print(6.0 // 2)     -- 3.0  (float floor)
print(7 // 2)       -- 3    (floor toward -inf)
print(-7 // 2)      -- -4   (floor, not truncate!)
print(2 ^ 3)        -- 8.0  (always float)

Operator modulo

Operator % w Lua jest zdefiniowany jako a % b == a - floor(a/b) * b. Oznacza to, że jego wynik ma znak dzielnika, a nie dzielnej. Różni się to od C/Java, gdzie wynik ma znak dzielnej.

Operator modulo jest przydatny do zawijania wartości, cyklicznego przechodzenia po tablicach i implementowania buforów pierścieniowych. Typowe zastosowanie: i % n daje kolejno wartości od 0 do n-1.

print(10 % 3)    --  1  (positive)
print(-10 % 3)   --  2  (sign of divisor!)
print(10 % -3)   -- -2  (sign of divisor)

-- Cycling 1..5 example
for i = 1, 8 do
  local idx = (i - 1) % 5 + 1
  io.write(idx .. " ")  -- 1 2 3 4 5 1 2 3
end

Operatory relacyjne

Operatory relacyjne Lua zwracają wartości logiczne: == (równe), ~= (różne), <, >, <=, >=. Należy zauważyć, że Lua używa ~= jako operatora nierówności, w przeciwieństwie do != stosowanego w większości języków.

Porównanie wartości różnych typów za pomocą == zawsze zwraca false — przy sprawdzaniu równości nie występuje niejawna konwersja typów. W Lua wyrażenie 1 == "1" ma wartość false.

print(3 == 3)    -- true
print(3 ~= 4)    -- true
print(3 < 4)     -- true
print(3 >= 3)    -- true

-- No cross-type equality coercion
print(1 == "1")  -- false
print(0 == false) -- false

-- Strings compare lexicographically
print("abc" < "abd")  -- true

Operatory logiczne: and, or, not

Operatorami logicznymi Lua są and, or i not. W przeciwieństwie do wielu języków and i or nie zwracają wartości logicznych — zwracają jeden ze swoich operandów. Umożliwia to typowe wzorce, takie jak wartości domyślne i przypisania warunkowe.

a and b zwraca a, jeśli a jest fałszywe, a w przeciwnym razie zwraca b
a or b zwraca a, jeśli a jest prawdziwe, a w przeciwnym razie zwraca b

-- and/or return operands, not booleans
print(1 and 2)        -- 2
print(false and 2)    -- false
print(1 or 2)         -- 1
print(false or 2)     -- 2

-- Default value idiom
local name = nil
local display = name or "Anonymous"
print(display)        -- Anonymous

Idiomat ternarny

Lua nie ma operatora ternarnego (?:), ale można go emulować za pomocą and/or. Wzorzec condition and value_if_true or value_if_false działa, o ile value_if_true nie jest równe nil ani false.

Jest to bardzo często stosowany idiom w Lua. Należy pamiętać o sytuacji brzegowej: jeśli gałąź prawdziwa ma dosłownie wartość false, wzorzec nie zadziała — należy wtedy użyć instrukcji if.

local x = 10
-- Ternary idiom
local label = x > 5 and "big" or "small"
print(label)   -- big

-- Works for non-false truthy values
local age = 20
local status = age >= 18 and "adult" or "minor"
print(status)  -- adult

-- Edge case: true branch is false -> use if
local val = true and false or "fallback"
print(val)  -- fallback (wrong!)

Priorytet operatorów

Priorytet operatorów Lua od najniższego do najwyższego: or, and, porównania (< > <= >= == ~=), |, ~, &, przesunięcia bitowe, .., + -, * / // %, jednoargumentowe (not # - ~), ^. Operatory ^ i .. są prawostronnie łączne; wszystkie pozostałe są lewostronnie łączne.

-- Precedence examples
print(2 + 3 * 4)     -- 14  (not 20)
print(2 ^ 3 ^ 2)     -- 512 (right assoc: 2^(3^2) = 2^9)
print(not 1 == 1)    -- false (not (1) == 1 => false == 1)
print(not (1 == 1))  -- false

-- Use parens to be explicit
print((2 + 3) * 4)   -- 20

Operatory bitowe (Lua 5.3+)

Lua 5.3 dodała natywne operatory bitowe działające na liczbach całkowitych: & (AND), | (OR), ~ (XOR w wersji dwuargumentowej, NOT w wersji jednoargumentowej), << (przesunięcie w lewo), >> (przesunięcie w prawo). Nie są one dostępne w Lua 5.1/5.2 bez użycia biblioteki.

Operatory bitowe wymagają operandów całkowitoliczbowych. Przekazanie liczby zmiennoprzecinkowej powoduje błąd wykonania, chyba że ma ona dokładną wartość całkowitą.

-- Bitwise operators (Lua 5.3+)
print(0xFF & 0x0F)   -- 15  (AND)
print(0xF0 | 0x0F)   -- 255 (OR)
print(0xFF ~ 0x0F)   -- 240 (XOR)
print(~0)            -- -1  (bitwise NOT)
print(1 << 4)        -- 16  (left shift)
print(256 >> 4)      -- 16  (right shift)

Długość i konkatenacja ciągów znaków

Operator # zwraca długość ciągu znaków w bajtach, a operator .. łączy dwa ciągi znaków. Po zastosowaniu .. do liczb Lua automatycznie konwertuje je na ciągi znaków. Jednak mieszanie typów z operatorem + podlega regułom konwersji — ciągu znaków wyglądającego jak liczba można użyć w działaniu arytmetycznym.

local s = "hello"
print(#s)            -- 5
print(s .. " world") -- hello world
print(1 .. 2)        -- 12  (number to string)

-- Length of table = array part length
local t = {10, 20, 30}
print(#t)   -- 3

-- Beware: # on tables with holes is undefined
local h = {1, nil, 3}
print(#h)   -- 1 or 3 (undefined behavior!)

Częste błędy związane z operatorami

W Lua często występuje kilka błędów związanych z operatorami: zapominanie, że / zawsze zwraca liczbę zmiennoprzecinkową; używanie != zamiast ~= (błąd składni); oczekiwanie, że 0 lub "" będzie wartością fałszywą (są wartościami prawdziwymi); oraz poleganie na and/or, gdy prawdziwa gałąź może mieć wartość false.

Zawsze należy testować warunki brzegowe, szczególnie przy dzieleniu całkowitoliczbowym przez // z liczbami ujemnymi, ponieważ // zaokrągla w kierunku ujemnej nieskończoności.

-- Common mistakes
-- 1. / is always float
local result = 10 / 2
print(math.type(result))  -- float, not integer!

-- 2. ~= not !=
-- if x != 5 then  -- SYNTAX ERROR!
if 3 ~= 5 then print("not equal") end

-- 3. 0 is truthy
if 0 then print("0 is truthy in Lua!") end

-- 4. Negative floor division
print(-7 // 2)  -- -4 (not -3!)

Szybkie sprawdzenie

Jaki jest wynik działania -7 // 2 w Lua?

Podsumowanie: operatory arytmetyczne i relacyjne

Najważniejsze omówione informacje:

/ zawsze zwraca liczbę zmiennoprzecinkową; // zaokrągla w kierunku ujemnej nieskończoności
^ zawsze zwraca liczbę zmiennoprzecinkową i jest prawostronnie łączny
~= jest operatorem nierówności (a nie !=)
and/or zwracają operandy, a nie wartości logiczne — umożliwia to idiom wartości domyślnej
Tylko nil i false są wartościami fałszywymi — 0 i "" są wartościami prawdziwymi
Operatory bitowe (& | ~ << >>) wymagają liczb całkowitych w Lua 5.3+

Następnie: konwersja typów i jawne funkcje konwersji.

Często zadawane pytania

Czy lekcja „Operatory arytmetyczne i relacyjne” jest bezpłatna?

Tak — pełny tekst „Operatory arytmetyczne i relacyjne” 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 „Operatory arytmetyczne i relacyjne”?

Proszę skutecznie używać operatorów +, -, *, /, //, %, ^ oraz operatorów porównania. Ć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 3 z 4.

Ile czasu zajmuje lekcja „Operatory arytmetyczne i relacyjne”?

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