Lua Academy · Les

Functies definiëren en aanroepen

Leer de syntaxis voor functiedeclaraties, aanroepconventies en lokale versus globale functies

Les 1 van 412 stappen

Functies definiëren en aanroepen is een gratis Lua Academy-les op CoddyKit. Dit is les 1 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.

Functiesyntaxis

Functies in Lua worden gedefinieerd met het sleutelwoord function. De body is een blok dat wordt afgesloten met end. Functies kunnen globaal of lokaal zijn. Je roept een functie aan door haakjes met argumenten toe te voegen. Als je argumenten weglaat, krijgen ontbrekende parameters de waarde nil.

function sayHello(name)
  print("Hello, " .. (name or "World") .. "!")
end

sayHello("Lua")   -- Hello, Lua!
sayHello()        -- Hello, World!

local function add(a, b)
  return a + b
end
print(add(3, 4))  -- 7

Retourwaarden

Functies retourneren waarden met return. In tegenstelling tot de meeste talen kunnen Lua-functies meerdere waarden retourneren. Als je niets expliciet retourneert, retourneert de functie niets (nul waarden). Overtollige retourwaarden worden verwijderd wanneer de aanroep niet de laatste expressie in een lijst is.

local function minMax(t)
  local lo, hi = t[1], t[1]
  for i = 2, #t do
    if t[i] < lo then lo = t[i] end
    if t[i] > hi then hi = t[i] end
  end
  return lo, hi
end

local lo, hi = minMax({5,2,8,1,9})
print(lo, hi)  -- 1  9

Functie als waarde

Functies zijn eersteklaswaarden in Lua. Je kunt ze opslaan in variabelen, ze als argumenten aan andere functies doorgeven en ze retourneren. Hierdoor kun je callbacks, functies van hogere orde en patronen voor functioneel programmeren gebruiken.

local ops = {
  add = function(a, b) return a + b end,
  sub = function(a, b) return a - b end,
  mul = function(a, b) return a * b end,
}

local function apply(op, a, b)
  return op(a, b)
end

print(apply(ops.add, 10, 3))  -- 13
print(apply(ops.mul, 4, 5))   -- 20

Lokale versus globale functies

Gebruik local function voor hulpm functies die privé blijven binnen een module. Globale functies vervuilen de globale naamruimte en zijn overal toegankelijk, wat naamconflicten kan veroorzaken. Geef in de meeste gevallen de voorkeur aan lokale functies en maak alleen via een moduletabel beschikbaar wat je nodig hebt.

-- Bad: pollutes global namespace
function helper() end

-- Good: module-local
local function helper()
  return "I am local"
end

-- Module export pattern
local M = {}
function M.publicFunc()
  return helper()  -- can call local
end
return M

Methoden met dubbelepuntnotatie

Lua biedt syntactische suiker voor het definiëren en aanroepen van methoden op tabellen. obj:method(arg) is gelijk aan obj.method(obj, arg). De dubbelepuntnotatie geeft de tabel impliciet door als eerste argument, dat conventioneel self wordt genoemd.

local Dog = {}
Dog.__index = Dog

function Dog.new(name)
  return setmetatable({name=name}, Dog)
end

function Dog:speak()
  print(self.name .. " says: Woof!")
end

local d = Dog.new("Rex")
d:speak()   -- Rex says: Woof!

Patroon voor optionele parameters

Lua heeft geen ingebouwde optionele parameters, maar je kunt ze nabootsen met controles op nil. Geef één optietabel door aan functies met veel optionele parameters; dat is overzichtelijker dan een lange argumentenlijst.

local function createUser(name, opts)
  opts = opts or {}
  return {
    name = name,
    role = opts.role or "user",
    active = opts.active ~= false,
    score = opts.score or 0,
  }
end

local u = createUser("Alice", {role="admin", score=100})
print(u.name, u.role, u.score)

Staartaanroepen

Een staartaanroep is een functieaanroep op de staartpositie (de laatste actie vóór het retourneren). Lua voert optimalisatie van staartaanroepen uit: een echte staartaanroep gebruikt geen extra stackruimte. Hierdoor is diepe recursie mogelijk zonder stackoverloop wanneer de recursieve aanroep op de staartpositie staat.

local function factorial(n, acc)
  acc = acc or 1
  if n <= 1 then return acc end
  return factorial(n - 1, n * acc)  -- tail call!
end

print(factorial(10))  -- 3628800
-- Can handle very large n without stack overflow

Onmiddellijk aangeroepen functies

Je kunt een functie definiëren en onmiddellijk aanroepen: (function() ... end)(). Dit is nuttig om een lokale scope te maken, instelcode precies één keer uit te voeren of te voorkomen dat tijdelijke variabelen de buitenste scope vervuilen.

local result = (function()
  local temp = 100
  local adjusted = temp * 1.5
  return math.floor(adjusted)
end)()

print(result)   -- 150
-- temp and adjusted not visible here

Functies in tabellen opslaan

Functies opslaan in tabellen is idiomatisch voor het ontwerpen van Lua-modules. De tabel fungeert als naamruimte. Je definieert functies door ze aan tabelvelden toe te wijzen of door punt- of dubbelepuntnotatie met de tabelnaam te gebruiken.

local math2 = {}

function math2.clamp(val, lo, hi)
  return math.max(lo, math.min(hi, val))
end

function math2.lerp(a, b, t)
  return a + (b - a) * t
end

print(math2.clamp(150, 0, 100))  -- 100
print(math2.lerp(0, 10, 0.5))   -- 5.0

Closures als callbacks

Functies van hogere orde accepteren callbacks. In Lua zijn callbacks gewoon functiewaarden. Closures zijn bijzonder nuttig als callbacks omdat ze de aanroepcontext vastleggen zonder dat je extra argumenten via de functie van hogere orde hoeft door te geven.

local function forEach(t, fn)
  for i, v in ipairs(t) do
    fn(v, i)
  end
end

local sum = 0
forEach({10, 20, 30}, function(v)
  sum = sum + v
end)
print(sum)   -- 60

forEach({"a","b","c"}, function(v, i)
  print(i, v)
end)

Korte controle

Wat is de uitvoer van: local function f() return 1, 2, 3 end; local a, b = f()?

Beantwoord dit in de interactieve les

Terugblik: Functies

Belangrijkste punten:

Gebruik local function om vervuiling van globale variabelen te voorkomen
Functies zijn eersteklas waarden: sla ze op in variabelen en tabellen en geef ze door als argumenten
De dubbelepuntnotatie geeft impliciet self door
Simuleer optionele parameters met opts or {}
Staartaanroepen voorkomen een stackoverflow bij diepe recursie
Direct aangeroepen functies maken geïsoleerde scopes

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 “Functies definiëren en aanroepen” gratis?

Ja — je kunt hier op het web alle 3 lessen van het leerpad Lua Academy, waaronder “Functies definiëren en aanroepen”, 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 “Functies definiëren en aanroepen”?

Leer de syntaxis voor functiedeclaraties, aanroepconventies en lokale versus globale functies 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 1 van 4.

Hoe lang duurt de les “Functies definiëren en aanroepen”?

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