Lua Academy · Lektion

Aritmetiska och relationella operatorer

Använd effektivt +, -, *, /, //, %, ^ och jämförelseoperatorer.

Lektion 3 av 412 steg

Aritmetiska och relationella operatorer är en gratis lektion i Lua Academy på CoddyKit. Detta är lektion 3 av 4. Du kan läsa vilka 3 lektioner som helst i den här lärvägen kostnadsfritt i sin helhet – därefter låser CoddyKit PRO upp alla lektioner, plus praktisk övning med en inbyggd kodredigerare och en AI-lärare dygnet runt. Den ingår i lärvägen för Lua Academy, och Era framsteg synkroniseras mellan webben och CoddyKit-appen. Kursen i Lua Academy innehåller totalt 4 lektioner.

Översikt över aritmetiska operatorer

Lua tillhandahåller en komplett uppsättning aritmetiska operatorer: + (addition), - (subtraktion), * (multiplikation), / (flyttalsdivision), // (heltalsdivision med avrundning nedåt), % (modulo), ^ (exponentiering) och unärt - (negation). I Lua 5.3+ är det viktigt att förstå när varje operator returnerar ett heltal respektive ett flyttal.

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

Division med heltal kontra flyttal

Operatorn / returnerar alltid ett flyttal, även när två heltal divideras utan rest. Operatorn // för heltalsdivision med avrundning nedåt returnerar ett heltal endast när båda operanderna är heltal. Om någon operand är ett flyttal blir resultatet ett flyttal, men det avrundas fortfarande nedåt.

Operatorn ^ för exponentiering omvandlar alltid resultatet till ett flyttal, så 2^3 ger 8.0, inte 8. Använd math.tointeger() för att konvertera tillbaka vid behov.

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)

Modulooperatorn

Luas operator % definieras som a % b == a - floor(a/b) * b. Det innebär att resultatet följer tecknet hos divisorn, inte dividenden. Detta skiljer sig från C/Java, där resultatet följer dividendens tecken.

Modulooperatorn är användbar för att låta värden gå runt, gå igenom arrayer cykliskt och implementera ringbuffertar. Ett vanligt användningsområde är att i % n går igenom värdena 0 till 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

Relationella operatorer

Luas relationella operatorer returnerar booleska värden: == (lika med), ~= (inte lika med), <, >, <=, >=. Observera att Lua använder ~= för olikhet, till skillnad från != i de flesta språk.

Om värden av olika typer jämförs med == returneras alltid false — ingen implicit typkonvertering sker vid likhetskontroller. 1 == "1" är false i Lua.

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

Logiska operatorer: and, or, not

Lua har de logiska operatorerna and, or och not. Till skillnad från många andra språk returnerar and och or inte booleska värden – de returnerar en av sina operander. Det möjliggör idiomatiska mönster som standardvärden och villkorlig tilldelning.

a and b returnerar a om a är falskt, annars returneras b
a or b returnerar a om a är sant, annars returneras 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

Det ternära idiomet

Lua har ingen ternär operator (?:), men Ni kan efterlikna en sådan med and/or. Mönstret condition and value_if_true or value_if_false fungerar så länge value_if_true inte är nil eller false.

Detta är ett mycket vanligt Lua-idiom. Var uppmärksam på specialfallet: om den sanna grenen bokstavligen är false misslyckas mönstret – använd i stället en if-sats.

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!)

Operatorprioritet

Lua-operatorernas prioritet från lägst till högst är: or, and, jämförelser (< > <= >= == ~=), |, ~, &, skiftoperatorer, .., + -, * / // %, unära operatorer (not # - ~), ^. Operatorerna ^ och .. är högerassociativa; alla andra är vänsterassociativa.

-- 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

Bitvisa operatorer (Lua 5.3+)

Lua 5.3 lade till inbyggda bitvisa operatorer som fungerar på heltal: & (AND), | (OR), ~ (XOR när den är binär, NOT när den är unär), << (vänsterskift), >> (högerskift). Dessa är inte tillgängliga i Lua 5.1/5.2 utan ett bibliotek.

Bitvisa operatorer kräver heltalsoperander. Om ett flyttal skickas in uppstår ett körningsfel, såvida flyttalet inte har ett exakt heltalsvärde.

-- 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)

Stränglängd och konkatenering

Operatorn # returnerar längden på en sträng i byte, och operatorn .. konkatenerar två strängar. När Ni använder .. på tal konverterar Lua dem automatiskt till strängar. Om Ni däremot blandar typer med + följer detta reglerna för typkonvertering – en sträng som ser ut som ett tal kan användas i aritmetik.

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!)

Vanliga misstag med operatorer

Flera operatorrelaterade buggar är vanliga i Lua: att glömma att / alltid returnerar ett flyttal; att använda != i stället för ~= (syntaxfel); att förvänta sig att 0 eller "" ska vara falska (de är sanna); samt att förlita sig på and/or när den sanna grenen kan vara false.

Testa alltid gränsfall, särskilt vid heltalsdivision med negativa tal, där // avrundar nedåt mot negativ oändlighet.

-- 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!)

Snabbkontroll

Vilket resultat ger -7 // 2 i Lua?

Besvara frågan i den interaktiva lektionen

Sammanfattning: aritmetiska och relationella operatorer

Viktiga punkter:

/ returnerar alltid ett flyttal; // avrundar nedåt mot negativ oändlighet
^ returnerar alltid ett flyttal och är högerassociativ
~= är operatorn för inte lika med (inte !=)
and/or returnerar operander, inte booleska värden – detta möjliggör idiomet för standardvärden
Endast nil och false är falska – 0 och "" är sanna
Bitvisa operatorer (& | ~ << >>) kräver heltal i Lua 5.3 eller senare

Nästa avsnitt: typkonvertering och explicita konverteringsfunktioner.

Gratis att börja

Lär dig Lua med en AI-lärare – gratis

Skriv och kör riktig kod i webbläsaren, få omedelbar hjälp av en AI-lärare dygnet runt och fortsätt där du slutade – på webben eller i appen.

Kurser: 40
Lektioner: 159

Börja lära dig gratis Visa hela kursen

Vanliga frågor

Är lektionen ”Aritmetiska och relationella operatorer” gratis?

Ja – du kan läsa vilka 3 lektioner som helst i lärvägen Lua Academy, inklusive ”Aritmetiska och relationella operatorer”, kostnadsfritt i sin helhet här på webben. Därefter låser CoddyKit PRO upp alla lektioner, plus interaktiv övning med en inbyggd kodredigerare och en AI-lärare dygnet runt. Kursen i Lua Academy innehåller totalt 4 lektioner.

Vad lär jag mig i ”Aritmetiska och relationella operatorer”?

Använd effektivt +, -, *, /, //, %, ^ och jämförelseoperatorer. Ni övar på Lua Academy med praktisk kod som körs direkt i webbläsaren, medan en AI-handledare som är tillgänglig dygnet runt svarar på Era frågor under lektionen.

Behöver jag någon erfarenhet för att börja lära mig Lua Academy?

Du behöver inga förkunskaper. Utbildningen i Lua Academy på CoddyKit är upplagd för allt från nybörjare till avancerade elever, så att du kan börja här eller från början och gå fram i din egen takt. Detta är lektion 3 av 4.

Hur lång tid tar lektionen ”Aritmetiska och relationella operatorer”?

De flesta CoddyKit-lektioner tar cirka 5–10 minuter. Varje lektion är kort och interaktiv, så att du gör stadiga framsteg och kan fortsätta precis där du slutade – på webben eller i appen.

Kan jag skriva och köra kod i den här Lua Academy-lektionen?

Ja. Varje Lua Academy-lektion innehåller en inbyggd kodredigerare, så att du kan skriva och köra riktig kod direkt i webbläsaren och få omedelbar AI-feedback – utan lokal installation.

Alla lektioner i den här kursen

← Tillbaka till Lua Academy