Lua Academy · Lezione

Varargs e operatore ...

Gestisca elenchi di argomenti a lunghezza variabile usando ... e select().

Varargs e operatore ... è una lezione Lua Academy gratuita su CoddyKit. Questa è la lezione 3 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.

Argomenti variabili

Una funzione Lua può accettare un numero variabile di argomenti usando ... (tre punti) nell'elenco dei parametri. All'interno della funzione, ... rappresenta gli argomenti aggiuntivi. È possibile usarlo nelle espressioni, passarlo ad altre funzioni o convertirlo in una tabella.

local function sum(...)
  local total = 0
  for _, v in ipairs({...}) do
    total = total + v
  end
  return total
end

print(sum(1, 2, 3))        -- 6
print(sum(10, 20, 30, 40)) -- 100

select() per gli argomenti variabili

select(n, ...) restituisce gli argomenti a partire dalla posizione n. select("#", ...) restituisce il conteggio totale degli argomenti, inclusi i valori nil. È più sicuro di #{...}, che si ferma al primo elemento nil mancante.

local function inspect(...)
  local n = select("#", ...)
  print("count:", n)
  for i = 1, n do
    print(i, select(i, ...))
  end
end

inspect("a", "b", nil, "d")
-- count: 4
-- 1  a
-- 2  b
-- 3  nil
-- 4  d

Passare ... a un'altra funzione

È possibile inoltrare direttamente gli argomenti variabili a un'altra funzione con f(...). Quando ... compare come ultimo argomento di una chiamata, vengono passati tutti gli argomenti variabili. È utile per creare wrapper di funzioni o per registrare informazioni.

local function log(level, ...)
  io.write("[" .. level .. "] ")
  print(...)
end

log("INFO", "Server started on port", 8080)
log("ERROR", "File not found:", "config.lua")
-- [INFO] Server started on port  8080
-- [ERROR] File not found:  config.lua

table.pack e table.unpack

Convertire gli argomenti variabili in una tabella con table.pack(...), che memorizza anche il conteggio nel campo n. Convertire una tabella nuovamente in argomenti variabili con table.unpack(t, i, j). Insieme, queste funzioni offrono il pieno controllo sugli elenchi di argomenti variabili.

local function pack_and_show(...)
  local packed = table.pack(...)
  print("n =", packed.n)
  for i = 1, packed.n do
    print(i, packed[i])
  end
end

pack_and_show(10, nil, 30)
-- n = 3
-- 1  10
-- 2  nil
-- 3  30

Argomenti fissi e variabili combinati

Una funzione può avere sia parametri fissi sia variabili. I parametri fissi vengono prima; ... raccoglie tutti gli argomenti restanti. I parametri fissi vengono assegnati prima che il resto venga inserito in ....

local function printf(fmt, ...)
  io.write(string.format(fmt, ...))
end

printf("Hello, %s! You are %d years old.\n", "Alice", 30)
printf("Pi is approximately %.4f\n", math.pi)

local function firstAndRest(first, ...)
  print("first:", first)
  print("rest count:", select("#", ...))
end
firstAndRest(1, 2, 3, 4)

Argomenti variabili nel costruttore di tabelle

È possibile inserire direttamente gli argomenti variabili in un costruttore di tabelle: {...}. Quando viene usato come ultimo elemento, include tutti gli argomenti. Tuttavia, gli elementi nil mancanti possono rendere ambiguo #: preferire table.pack quando serve un conteggio esatto.

local function toArray(...)
  return {...}  -- collect all args as array
end

local arr = toArray("x", "y", "z")
for i, v in ipairs(arr) do
  print(i, v)
end
-- 1  x
-- 2  y
-- 3  z

Espressioni con argomenti variabili

... può comparire in qualsiasi posizione di un'espressione. In un'assegnazione multipla, si espande in tutti i suoi valori. In un'espressione aritmetica, viene usato solo il primo valore. Comprendere questo comportamento evita bug difficili da individuare quando si combina ... con altre espressioni.

local function first(...)
  local x = ...
  return x
end

print(first(10, 20, 30))  -- 10  (only first)

local function addFirst(n, ...)
  local x = ...
  return n + x
end
print(addFirst(5, 3, 99)) -- 8  (3 is first ...)

print() usa argomenti variabili

La funzione integrata print() di Lua è a sua volta una funzione con argomenti variabili. Accetta un numero qualsiasi di argomenti, converte ciascuno in una stringa e li separa con tabulazioni. Comprendere questo comportamento aiuta a scrivere funzioni di utilità simili.

-- print is vararg
print(1, 2, 3)           -- 1  2  3
print("a", nil, "b")     -- a  nil  b
print()                  -- (empty line)

-- Reimplementing a simple print-like function
local function myprint(...)
  local parts = {}
  for i = 1, select("#", ...) do
    parts[i] = tostring(select(i, ...))
  end
  io.write(table.concat(parts, "\t") .. "\n")
end
myprint(10, nil, 30)

Inoltrare argomenti con pcall

È possibile combinare pcall con gli argomenti variabili per creare un wrapper generico per chiamate sicure. Il wrapper accetta una funzione e un numero qualsiasi di argomenti, la chiama tramite pcall e restituisce i risultati oppure un errore.

local function safeCall(fn, ...)
  local ok, result = pcall(fn, ...)
  if ok then
    return result
  else
    print("Error:", result)
    return nil
  end
end

local function divide(a, b)
  assert(b ~= 0, "division by zero")
  return a / b
end

print(safeCall(divide, 10, 2))   -- 5.0
print(safeCall(divide, 10, 0))  -- Error: ...

Schema per accumulare argomenti variabili

Uno schema comune con gli argomenti variabili consiste nell'iterare su tutti gli argomenti e accumulare un risultato. È possibile farlo con una tabella locale oppure eseguendo direttamente la somma con select. Entrambi gli approcci sono validi; quello basato su una tabella è più ordinato quando gli argomenti sono numerosi.

local function average(...)
  local n = select("#", ...)
  if n == 0 then return 0 end
  local total = 0
  for i = 1, n do
    total = total + select(i, ...)
  end
  return total / n
end

print(average(10, 20, 30, 40))  -- 25.0
print(average(5))               -- 5.0

Verifica rapida

Che cosa restituisce select("#", 1, nil, 3)?

Riepilogo: argomenti variabili

Riepilogo:

function f(...) — accetta argomenti variabili
select("#", ...) — conteggio sicuro che include i valori nil
select(n, ...) — valori a partire dalla posizione n
table.pack(...) — converte gli argomenti variabili in una tabella con il conteggio in .n
table.unpack(t) — converte una tabella in argomenti variabili
... nell'ultima posizione si espande completamente; nella posizione intermedia produce un valore

Domande Frequenti

La lezione «Varargs e operatore ...» è gratuita?

Sì — il testo completo di «Varargs e operatore ...» è 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 «Varargs e operatore ...»?

Gestisca elenchi di argomenti a lunghezza variabile usando ... e select(). 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 3 di 4.

Quanto tempo richiede la lezione «Varargs e operatore ...»?

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

← Torna a Lua Academy