Lua Academy · Lektion

Definition og kald af funktioner

Lær syntaksen til funktionsdeklarationer, kalderegler samt lokale og globale funktioner.

Lektion 1 af 412 trin

Definition og kald af funktioner er en gratis Lua Academy-lektion på CoddyKit. Dette er lektion 1 af 4. Du kan læse alle 3 lektioner i dette læringsspor gratis i deres fulde længde — derefter låser CoddyKit PRO alle lektioner op samt praktiske øvelser med en indbygget kodeeditor og en AI-underviser døgnet rundt. Den er en del af læringsforløbet i Lua Academy, og dine fremskridt synkroniseres på tværs af nettet og CoddyKit-appen. Lua Academy-kurset indeholder 4 lektioner i alt.

Funktionssyntaks

Funktioner i Lua defineres med nøgleordet function. Kroppen er en blok, der afsluttes med end. Funktioner kan være globale eller lokale. Du kalder en funktion ved at tilføje parenteser med argumenter. Hvis du udelader argumenter, får manglende parametre værdien 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

Returværdier

Funktioner returnerer værdier med return. I modsætning til de fleste sprog kan Lua-funktioner returnere flere værdier. Hvis du ikke returnerer eksplicit, returnerer funktionen ingenting (nul værdier). Overskydende returværdier kasseres, når kaldet ikke er det sidste udtryk på en liste.

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

Funktioner som værdier

Funktioner er førsteklasses værdier i Lua. Du kan gemme dem i variabler, sende dem som argumenter til andre funktioner og returnere dem. Det muliggør tilbagekald, funktioner af højere orden og funktionelle programmeringsmønstre.

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 og globale funktioner

Brug local function til hjælpefunktioner, der kun skal være tilgængelige i modulet. Globale funktioner forurener det globale navnerum og er tilgængelige overalt, hvilket kan medføre navnekonflikter. I de fleste tilfælde bør du foretrække lokale funktioner og kun eksponere det, du har brug for, gennem en modultabel.

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

Metoder med kolon-syntaks

Lua tilbyder syntaktisk sukker til at definere og kalde metoder på tabeller. obj:method(arg) svarer til obj.method(obj, arg). Kolonformen sender implicit tabellen som det første argument, der konventionelt kaldes self.

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!

Mønster for valgfrie parametre

Lua har ingen indbyggede valgfrie parametre, men du kan simulere dem med nil-kontroller. Send en enkelt indstillingstabel til funktioner med mange valgfrie parametre — det er mere overskueligt end en lang argumentliste.

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)

Haleslag

Et haleslag er et funktionskald i halepositionen (den sidste handling før returnering). Lua udfører optimering af haleslag: Et korrekt haleslag bruger ikke ekstra stakplads. Det muliggør dyb rekursion uden overløb af stakken, når det rekursive kald står i halepositionen.

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

Funktioner, der kaldes med det samme

Du kan definere og kalde en funktion med det samme: (function() ... end)(). Det er nyttigt til at oprette et lokalt scope, udføre opsætningskode præcis én gang eller undgå at forurene det ydre scope med midlertidige variabler.

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

Lagring af funktioner i tabeller

At gemme funktioner i tabeller er idiomatisk Lua-design til moduler. Tabellen fungerer som et navnerum. Du definerer funktioner ved at tildele dem til tabelfelter eller bruge punktum-/kolonnotation sammen med tabelnavnet.

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

Lukninger som tilbagekald

Funktioner af højere orden accepterer tilbagekald. I Lua er tilbagekald blot funktionsværdier. Lukninger er især nyttige som tilbagekald, fordi de indfanger kaldets kontekst uden at kræve, at du sender ekstra argumenter gennem funktionen af højere orden.

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)

Hurtig kontrol

Hvad er resultatet af: local function f() return 1, 2, 3 end; local a, b = f()?

Besvar den i den interaktive lektion

Opsamling: Funktioner

Vigtige punkter:

Brug local function for at undgå at forurene globale variabler
Funktioner er førsteklasses værdier: gem dem i variabler og tabeller, og giv dem som argumenter
Kolon-syntaks videregiver implicit self
Simulér valgfrie parametre med opts or {}
Halekald undgår stakoverløb ved dyb rekursion
Funktioner, der kaldes med det samme, opretter isolerede scopes

Gratis at komme i gang

Lær Lua med en AI-underviser — gratis

Skriv og kør rigtig kode i din browser, få øjeblikkelig hjælp fra en AI-underviser døgnet rundt, og fortsæt, hvor du slap, på web eller i appen.

Kurser: 40
Lektioner: 159

Start gratis Se hele kurset

Ofte stillede spørgsmål

Er lektionen “Definition og kald af funktioner” gratis?

Ja — alle 3 lektioner i læringssporet Lua Academy, inklusive “Definition og kald af funktioner”, kan læses gratis i deres fulde længde her på webstedet. Derefter låser CoddyKit PRO alle lektioner op samt interaktive øvelser med en indbygget kodeeditor og en AI-underviser døgnet rundt. Lua Academy-kurset indeholder 4 lektioner i alt.

Hvad lærer jeg i “Definition og kald af funktioner”?

Lær syntaksen til funktionsdeklarationer, kalderegler samt lokale og globale funktioner. Du øver dig i Lua Academy med praktisk kode, som du kører direkte i browseren, og en AI-vejleder døgnet rundt besvarer dine spørgsmål, mens du arbejder dig gennem lektionen.

Skal jeg have erfaring for at begynde på Lua Academy?

Der kræves ingen tidligere erfaring. Lua Academy på CoddyKit er tilrettelagt for både begyndere og øvede, så du kan starte her eller fra begyndelsen og lære i dit eget tempo. Dette er lektion 1 af 4.

Hvor lang tid tager lektionen “Definition og kald af funktioner”?

De fleste CoddyKit-lektioner tager cirka 5–10 minutter. Hver lektion er kort og interaktiv, så du gør løbende fremskridt og kan fortsætte, hvor du slap – på både web og app.

Kan jeg skrive og køre kode i denne Lua Academy-lektion?

Ja. Alle Lua Academy-lektioner har en indbygget kodeeditor, så du kan skrive og køre rigtig kode direkte i din browser og få øjeblikkelig feedback fra AI – uden lokal opsætning.

Alle lektioner i dette kursus

← Tilbage til Lua Academy