0Pricing
Lua Academy · Lezione

Valori restituiti multipli

Restituisca e acquisisca più valori da una singola chiamata di funzione.

Valori restituiti multipli è una lezione Lua Academy gratuita su CoddyKit. Questa è la lezione 2 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.

Restituire più valori

A differenza della maggior parte dei linguaggi, le funzioni Lua possono restituire nativamente più valori con una singola istruzione return. I valori multipli sono separati da virgole dopo return. In questo modo non servono oggetti wrapper o parametri di output.

local function divmod(a, b)
  return math.floor(a / b), a % b
end

local quotient, remainder = divmod(17, 5)
print(quotient, remainder)   -- 3  2

Adattare i valori restituiti

Lua adatta i valori restituiti al numero di variabili riceventi. I valori aggiuntivi vengono scartati; quelli mancanti diventano nil. Questo adattamento avviene ogni volta che una chiamata di funzione non è l'espressione finale di un elenco: in quella posizione viene mantenuto solo il primo valore.

local function triple()
  return 10, 20, 30
end

local a, b, c = triple()
print(a, b, c)      -- 10  20  30

local x, y = triple()
print(x, y)         -- 10  20  (30 discarded)

local p = triple()
print(p)            -- 10  (only first when 1 var)

Adattamento nella posizione intermedia

Quando una chiamata di funzione compare nella posizione intermedia di un elenco di espressioni, e non nell'ultima, Lua la riduce a un singolo valore. Solo l'ultima espressione dell'elenco può produrre più valori.

local function pair()
  return 1, 2
end

-- pair() in middle: only 1 value used
local t = {pair(), pair()}
print(#t, t[1], t[2], t[3])  -- 3  1  1  2
-- first pair() gives just 1; last pair() gives 1,2

-- pair() at end: all values used
local t2 = {10, pair()}
print(#t2, t2[1], t2[2], t2[3])  -- 3  10  1  2

Le parentesi impongono un singolo valore

local function coords()
  return 10, 20, 30
end

print(coords())    -- 10  20  30  (all three)
print((coords()))  -- 10  (parentheses: single value only)

local x = (coords())
print(x)           -- 10

Valori restituiti da string.find

Molte funzioni della libreria standard usano più valori restituiti. string.find restituisce le posizioni iniziale e finale di una corrispondenza, oltre agli eventuali gruppi catturati. math.modf restituisce la parte intera e quella frazionaria. Comprendere questi schemi aiuta a usare la libreria standard con naturalezza.

local s = "hello world"
local start, finish = string.find(s, "world")
print(start, finish)   -- 7  11

-- math.modf: integer and fractional parts
local int, frac = math.modf(3.75)
print(int, frac)       -- 3   0.75

Catturare valori con table.pack

table.pack(...) raccoglie tutti gli argomenti, o i valori restituiti tramite ..., in una tabella. La tabella include un campo n con il conteggio totale, compresi i valori nil. In questo modo si conserva il conteggio esatto, a differenza di #, che si ferma al primo elemento mancante.

local function getData()
  return "Alice", 30, nil, true
end

local t = table.pack(getData())
print(t.n)         -- 4
print(t[1])        -- Alice
print(t[2])        -- 30
print(t[3])        -- nil
print(t[4])        -- true

table.unpack per espandere i valori

table.unpack(t, i, j) restituisce gli elementi di una tabella come valori distinti. È l'inverso di table.pack. Lo si usa per passare il contenuto di una tabella come argomenti a una funzione o per espandere i valori in un'istruzione return.

local args = {10, 20, 30}

local function sum3(a, b, c)
  return a + b + c
end

print(sum3(table.unpack(args)))  -- 60

-- Use in return
local function passThrough(t)
  return table.unpack(t)
end
print(passThrough({5, 6, 7}))   -- 5  6  7

Restituzioni nello stile degli errori

Una convenzione comune in Lua consiste nel restituire nil, errorMessage in caso di errore e il risultato in caso di successo. Il codice chiamante controlla il primo valore restituito: se è nil, si è verificato un errore. In questo modo si evitano le eccezioni nei casi di errore previsti.

local function openConfig(path)
  local f = io.open(path, "r")
  if not f then
    return nil, "cannot open: " .. path
  end
  local content = f:read("*a")
  f:close()
  return content
end

local data, err = openConfig("config.lua")
if not data then
  print("Error:", err)
end

Scambiare valori con restituzioni multiple

I valori restituiti multipli risolvono elegantemente il problema dello scambio. Il lato destro viene valutato prima dell'assegnazione, quindi a, b = b, a scambia correttamente i valori senza una variabile temporanea.

local a, b = 5, 10
print(a, b)   -- 5  10

a, b = b, a
print(a, b)   -- 10  5

-- Works for three-way rotation too
local x, y, z = 1, 2, 3
x, y, z = z, x, y
print(x, y, z)  -- 3  1  2

Convenzione dei valori restituiti da pcall

pcall(f, ...) usa a sua volta più valori restituiti: il primo è un booleano (true in caso di successo, false in caso di errore), mentre i valori successivi sono i valori restituiti da f oppure il messaggio di errore. Controllare sempre il primo valore restituito prima di usare gli altri.

local function risky(x)
  if x < 0 then error("negative input") end
  return math.sqrt(x)
end

local ok, result = pcall(risky, 16)
print(ok, result)   -- true  4.0

ok, result = pcall(risky, -1)
print(ok, result)   -- false  input:2: negative input

Verifica rapida

Che cosa produce in output print((string.find("hello", "ll")))?

Riepilogo: valori restituiti multipli

Concetti fondamentali:

  • Restituire più valori: return a, b, c
  • I valori aggiuntivi vengono scartati; quelli mancanti diventano nil
  • Le chiamate in posizione intermedia vengono ridotte a un valore
  • (f()) forza esattamente un valore
  • table.pack/table.unpack per gli elenchi dinamici di valori
  • Convenzione: restituire nil, errmsg in caso di errore

Domande Frequenti

La lezione «Valori restituiti multipli» è gratuita?

Sì — il testo completo di «Valori restituiti multipli» è 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 «Valori restituiti multipli»?

Restituisca e acquisisca più valori da una singola chiamata di funzione. 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 2 di 4.

Quanto tempo richiede la lezione «Valori restituiti multipli»?

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