0Pricing
Lua Academy · Lezione

Definizione e chiamata delle funzioni

Apprenda la sintassi per la dichiarazione delle funzioni, le convenzioni di chiamata e la differenza tra funzioni locali e globali.

Definizione e chiamata delle funzioni è una lezione Lua Academy gratuita su CoddyKit. Questa è la lezione 1 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento Lua Academy, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso Lua Academy include 4 lezioni in totale.

Sintassi delle funzioni

In Lua le funzioni vengono definite con la parola chiave function. Il corpo è un blocco terminato da end. Le funzioni possono essere globali o locali. Una funzione viene chiamata aggiungendo tra parentesi gli argomenti. Se si omettono gli argomenti, i parametri mancanti ricevono 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

Valori restituiti

Le funzioni restituiscono valori con return. A differenza della maggior parte dei linguaggi, le funzioni Lua possono restituire più valori. Se non si specifica alcun return, la funzione non restituisce nulla (zero valori). I valori restituiti in eccesso vengono scartati quando la chiamata non è l'ultima espressione di un elenco.

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

La funzione come valore

In Lua le funzioni sono valori di prima classe. È possibile memorizzarle in variabili, passarle come argomenti ad altre funzioni e restituirle. Questo consente di utilizzare callback, funzioni di ordine superiore e schemi di programmazione funzionale.

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

Funzioni locali e globali

Utilizzi local function per le funzioni di supporto private del modulo. Le funzioni globali inquinano lo spazio dei nomi globale e sono accessibili da qualsiasi punto, causando possibili conflitti di nomi. Nella maggior parte dei casi, preferisca le funzioni locali ed esponga tramite una tabella del modulo solo ciò che è necessario.

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

Metodi con la sintassi dei due punti

Lua offre una scorciatoia sintattica per definire e chiamare metodi sulle tabelle. obj:method(arg) equivale a obj.method(obj, arg). La forma con i due punti passa implicitamente la tabella come primo argomento, convenzionalmente denominato 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!

Schema dei parametri facoltativi

Lua non dispone di parametri facoltativi integrati, ma è possibile simularli verificando la presenza di nil. Per le funzioni con molti parametri facoltativi, passi un'unica tabella di opzioni: è più ordinato di un lungo elenco di argomenti.

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)

Chiamate in coda

Una chiamata in coda è una chiamata di funzione nella posizione finale, cioè l'ultima operazione prima della restituzione. Lua esegue l'ottimizzazione delle chiamate in coda: una corretta chiamata in coda non utilizza spazio aggiuntivo nello stack. Questo consente una ricorsione profonda senza overflow dello stack quando la chiamata ricorsiva si trova nella posizione finale.

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

Funzioni invocate immediatamente

È possibile definire e chiamare immediatamente una funzione: (function() ... end)(). Questo è utile per creare uno scope locale, eseguire il codice di configurazione esattamente una volta o evitare di inquinare lo scope esterno con variabili temporanee.

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

Memorizzare funzioni nelle tabelle

Memorizzare funzioni nelle tabelle è uno schema idiomatico per progettare moduli Lua. La tabella funge da spazio dei nomi. Le funzioni vengono definite assegnandole ai campi della tabella oppure utilizzando la notazione con punto o due punti insieme al nome della tabella.

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

Closure come callback

Le funzioni di ordine superiore accettano callback. In Lua, le callback sono semplicemente valori funzione. Le closure sono particolarmente utili come callback perché acquisiscono il contesto della chiamata senza dover passare argomenti aggiuntivi attraverso la funzione di ordine superiore.

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)

Verifica rapida

Qual è l'output di: local function f() return 1, 2, 3 end; local a, b = f()?

Riepilogo: funzioni

Punti chiave:

  • Usare local function per evitare di contaminare le variabili globali
  • Le funzioni sono valori di prima classe: è possibile memorizzarle in variabili e tabelle e passarle come argomenti
  • La sintassi con i due punti passa implicitamente self
  • Simulare i parametri opzionali con opts or {}
  • Le chiamate in coda evitano l'overflow dello stack nella ricorsione profonda
  • Le funzioni invocate immediatamente creano ambiti isolati

Domande Frequenti

La lezione «Definizione e chiamata delle funzioni» è gratuita?

Sì — il testo completo di «Definizione e chiamata delle funzioni» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso Lua Academy, passa a CoddyKit PRO. Il corso Lua Academy include 4 lezioni in totale.

Cosa imparerò in «Definizione e chiamata delle funzioni»?

Apprenda la sintassi per la dichiarazione delle funzioni, le convenzioni di chiamata e la differenza tra funzioni locali e globali. Eserciti Lua Academy con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.

Ho bisogno di esperienza per iniziare Lua Academy?

Non è richiesta alcuna esperienza precedente. Lua Academy su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 1 di 4.

Quanto tempo richiede la lezione «Definizione e chiamata delle funzioni»?

La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.

Posso scrivere ed eseguire codice in questa lezione Lua Academy?

Sì. Ogni lezione Lua Academy include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.

Tutte le lezioni di questo corso

  1. Definizione e chiamata delle funzioni
  2. Valori restituiti multipli
  3. Varargs e operatore ...
  4. Ricorsione in Lua
← Torna a Lua Academy