Lua Academy · Les

Rekenkundige en relationele operatoren

Gebruik +, -, *, /, //, %, ^ en vergelijkingsoperatoren effectief

Les 3 van 412 stappen

Rekenkundige en relationele operatoren is een gratis Lua Academy-les op CoddyKit. Dit is les 3 van 4. Je kunt 3 lessen uit dit leerpad gratis volledig lezen — daarna ontgrendelt CoddyKit PRO alle lessen, plus praktische oefeningen met een ingebouwde code-editor en een AI-tutor die 24/7 beschikbaar is. Deze les maakt deel uit van het leertraject Lua Academy. Je voortgang wordt gesynchroniseerd op het web en in de CoddyKit-app. De cursus Lua Academy bevat in totaal 4 lessen.

Overzicht van rekenkundige operatoren

Lua biedt een volledige reeks rekenkundige operatoren: + (optellen), - (aftrekken), * (vermenigvuldigen), / (delen als float), // (gehele deling naar beneden), % (modulo), ^ (machtsverheffen) en unaire - (negatie). In Lua 5.3+ is het cruciaal om te begrijpen wanneer elke operator een geheel getal of een float retourneert.

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

Deling van gehele getallen en floats

De operator / retourneert altijd een float, zelfs wanneer je twee gehele getallen deelt die zonder rest deelbaar zijn. De operator // voor gehele deling naar beneden retourneert alleen een integer wanneer beide operanden integers zijn; als een van beide een float is, is het resultaat een float die nog steeds naar beneden wordt afgerond.

De machtsverheffingsoperator ^ converteert altijd naar een float, dus 2^3 levert 8.0 op en niet 8. Gebruik math.tointeger() om indien nodig terug te converteren.

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)

Modulo-operator

Lua's operator % is gedefinieerd als a % b == a - floor(a/b) * b. Dit betekent dat het resultaat het teken van de deler volgt, niet dat van het deeltal. Dit verschilt van C en Java, waar het resultaat het teken van het deeltal volgt.

De modulo-operator is nuttig om waarden te laten rondlopen, cyclisch door arrays te gaan en ringbuffers te implementeren. Een veelgebruikt voorbeeld: i % n doorloopt de waarden van 0 tot en met 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

Relationele operatoren

De relationele operatoren van Lua retourneren booleans: == (gelijk), ~= (niet gelijk), <, >, <= en >=. Let op: Lua gebruikt ~= voor ongelijkheid, in tegenstelling tot != in de meeste talen.

Het vergelijken van waarden van verschillende typen met == retourneert altijd false — voor gelijkheidscontroles vindt geen impliciete conversie plaats. 1 == "1" is in Lua 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

Logische operatoren: and, or, not

De logische operatoren van Lua zijn and, or en not. In tegenstelling tot veel andere talen geven and en or geen booleans terug — ze geven een van hun operandwaarden terug. Daardoor kun je gebruikelijke patronen toepassen, zoals standaardwaarden en voorwaardelijke toewijzing.

a and b geeft a terug als a onwaar is, en anders b
a or b geeft a terug als a waar is, en anders 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

De ternaire idiomatische schrijfwijze

Lua heeft geen ternaire operator (?:), maar je kunt er een nabootsen met and/or. Het patroon condition and value_if_true or value_if_false werkt zolang value_if_true niet nil of false is.

Dit is een zeer gebruikelijke Lua-idiomatische schrijfwijze. Let op het randgeval: als de ware tak letterlijk false is, werkt het patroon niet — gebruik dan een if-instructie.

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

Prioriteit van operatoren

De prioriteit van Lua-operatoren, van laag naar hoog: or, and, vergelijkingen (< > <= >= == ~=), |, ~, &, verschuivingen, .., + -, * / // %, unaire operatoren (not # - ~), ^. De operatoren ^ en .. zijn rechtsassociatief; alle andere zijn linksassociatief.

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

Bitsgewijze operatoren (Lua 5.3+)

Lua 5.3 voegde native bitsgewijze operatoren toe die op gehele getallen werken: & (EN), | (OF), ~ (XOR bij twee operanden, NIET als unaire operator), << (verschuiving naar links), >> (verschuiving naar rechts). Deze zijn zonder bibliotheek niet beschikbaar in Lua 5.1/5.2.

Bitsgewijze operatoren vereisen operanden die gehele getallen zijn. Als je een kommagetal doorgeeft, ontstaat er tijdens de uitvoering een fout, tenzij het kommagetal exact de waarde van een geheel getal heeft.

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

Lengte en samenvoeging van tekenreeksen

De operator # geeft de lengte van een tekenreeks in bytes terug, en de operator .. voegt twee tekenreeksen samen. Wanneer je .. op getallen toepast, converteert Lua ze automatisch naar tekenreeksen. Bij het mengen van typen met + gelden echter conversieregels — een tekenreeks die eruitziet als een getal kan in rekenkundige bewerkingen worden gebruikt.

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

Veelgemaakte fouten met operatoren

In Lua komen verschillende fouten met operatoren vaak voor: vergeten dat / altijd een kommagetal teruggeeft; != gebruiken in plaats van ~= (syntaxisfout); verwachten dat 0 of "" onwaar is (ze zijn waar); en vertrouwen op and/or wanneer de ware tak mogelijk false is.

Test altijd randvoorwaarden, vooral bij gehele deling met negatieve getallen, waarbij // naar negatieve oneindigheid afrondt.

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

Korte controle

Wat is het resultaat van -7 // 2 in Lua?

Beantwoord dit in de interactieve les

Samenvatting: rekenkundige en relationele operatoren

Belangrijkste punten:

/ geeft altijd een kommagetal terug; // rondt af naar negatieve oneindigheid
^ geeft altijd een kommagetal terug en is rechtsassociatief
~= is de operator voor ongelijkheid (niet !=)
and/or geven operandwaarden terug, geen booleans — dit maakt de idiomatische schrijfwijze met standaardwaarden mogelijk
Alleen nil en false zijn onwaar — 0 en "" zijn waar
Bitsgewijze operatoren (& | ~ << >>) vereisen gehele getallen van Lua 5.3+

Volgende onderwerp: typeconversie en expliciete conversiefuncties.

Gratis beginnen

Leer Lua met een AI-tutor — gratis

Schrijf echte code en voer die uit in je browser, krijg direct hulp van een AI-tutor die 24/7 beschikbaar is en ga verder waar je gebleven bent op het web of in de app.

Cursussen: 40
Lessen: 159

Gratis beginnen met leren Bekijk de volledige cursus

Veelgestelde vragen

Is de les “Rekenkundige en relationele operatoren” gratis?

Ja — je kunt hier op het web alle 3 lessen van het leerpad Lua Academy, waaronder “Rekenkundige en relationele operatoren”, gratis volledig lezen. Daarna ontgrendelt CoddyKit PRO alle lessen, plus interactieve oefeningen met een ingebouwde code-editor en een AI-tutor die 24/7 beschikbaar is. De cursus Lua Academy bevat in totaal 4 lessen.

Wat leer ik in “Rekenkundige en relationele operatoren”?

Gebruik +, -, *, /, //, %, ^ en vergelijkingsoperatoren effectief Je oefent met Lua Academy door code rechtstreeks in de browser uit te voeren. Een AI-begeleider die 24/7 beschikbaar is beantwoordt je vragen terwijl je de les doorwerkt.

Heb ik ervaring nodig om met Lua Academy te beginnen?

Ervaring vooraf is niet nodig. Lua Academy op CoddyKit is opgebouwd voor beginners tot gevorderden, zodat je hier of bij het begin kunt starten en in je eigen tempo kunt leren. Dit is les 3 van 4.

Hoe lang duurt de les “Rekenkundige en relationele operatoren”?

De meeste lessen van CoddyKit duren ongeveer 5–10 minuten. Elke les is kort en interactief, zodat je gestaag vooruitgaat en op het web en in de app precies verdergaat waar je was gebleven.

Kan ik code schrijven en uitvoeren in deze les over Lua Academy?

Ja. Elke les over Lua Academy bevat een ingebouwde code-editor, zodat je rechtstreeks in je browser echte code kunt schrijven en uitvoeren en direct feedback van AI krijgt — lokale installatie is niet nodig.

Alle lessen in deze cursus

← Terug naar Lua Academy