Una caratteristica non convenzionale, ma molto conveniente di Lua è che le funzioni possono restituire più risultati. Diverse funzioni predefinite in Lua restituiscono valori multipli. Un esempio è la string.find funzione, che individua un modello in una stringa. Restituisce due indici: l'indice del carattere in cui il pattern match inizia e quello dove finisce (o nullo se non riesce a trovare il modello). Un'assegnazione multipla consente al programma di ottenere entrambi i risultati:

s, e = string.find ("utenti ciao Lua", "Lua")

stampa (s, e) -> 7 9
Funzioni scritte in Lua possono anche restituire più risultati, per elencarli tutti, dopo il ritorno di parole chiave. Per esempio, una funzione per trovare il massimo elemento di un array può restituire sia il valore massimo e la sua posizione:

funzione massimo (a)
mi locale = 1 - indice massimo
m locale = a [mi] - valore massimo
per i, val a ipairs (a) fare
se val> m poi
mi = i
m = val
fine
fine
ritorno m, mi
fine

stampa (massimo ({} 8,10,23,12,5)) -> 23 3

Lua regola sempre il numero di risultati da una funzione per le circostanze della chiamata. Quando chiamiamo una funzione come una dichiarazione, Lua scarta tutti i suoi risultati. Quando usiamo una chiamata come espressione, Lua mantiene solo il primo risultato. Abbiamo ottenuto tutti i risultati solo quando la chiamata è l'ultima (o l'unico) espressione in un elenco di espressioni. Questi elenchi vengono visualizzati in quattro costruzioni in Lua: assegnazione multipla, argomenti per chiamate di funzione, costruttori tavolo, e tornare dichiarazioni. Per illustrare tutti questi usi, assumeremo le seguenti definizioni per i prossimi esempi:

Funzione foo0 () fine - ha prodotto alcun risultato
Funzione foo1 () ritorno 'a' fine - restituisce 1 risultato
Funzione foo2 () ritorno 'a', 'b' end - restituisce 2 risultati

In una assegnazione multipla, una chiamata di funzione come l'ultimo (o solo) l'espressione produce il maggior numero di risultati in base alle esigenze per abbinare le variabili:

x, y = foo2 () - x = 'a', y = 'b'
x = foo2 () - x = 'a', 'b' viene scartato
x, y, z = 10, foo2 () - x = 10, y = 'A', z = 'b'
Se una funzione non ha risultati, e non come molti risultati di cui abbiamo bisogno, Lua produce nil s:
x, y = foo0 () - x = nil, y = nil
x, y = foo1 () - x = 'a', y = nil
x, y, z = foo2 () - x = 'a', y = 'b', z = nil
Una chiamata di funzione che non è l'ultimo elemento della lista produce sempre un risultato:
x, y = foo2 (), 20 - x = 'a', y = 20
x, y = foo0 (), 20, 30 - x = 'nil', y = 20, 30 viene scartato

Quando una chiamata di funzione è l'ultimo (o l'unico) argomento di un'altra chiamata, tutti i risultati del primo bando vanno come argomenti. Abbiamo visto esempi di questa costruzione già, con la stampa:

stampa (foo0 ()) ->
stampa (foo1 ()) -> un
stampa (foo2 ()) -> ab
stampa (foo2 (), 1) -> a 1
stampa (foo2 () .. "x") -> ascia (vedi sotto)

Quando la chiamata di foo2 appare all'interno di una espressione, Lua regola il numero di risultati alla prima; così, nell'ultima riga, solo la "a" è utilizzato nella concatenazione.
La stampa funzione può ricevere un numero variabile di argomenti. (Nella prossima sezione vedremo come scrivere funzioni con numero variabile di argomenti.) Se scriviamo f (g ()) e f ha un numero fisso di argomenti, Lua regola il numero di risultati di g per il numero di parametri di f, come abbiamo visto in precedenza.

Un costruttore raccoglie anche tutti i risultati di una chiamata, senza alcune registrazioni:

a = {foo0 ()} - a = {} (un tavolo vuoto)
a = {foo1 ()} - a = {'un'}
a = {foo2 ()} - {a = 'a', 'b'}
Come sempre, questo comportamento si verifica solo quando la chiamata è l'ultima della lista; altrimenti, qualsiasi chiamata produce esattamente un risultato:
a = {foo0 (), foo2 (), 4} - un [1] = nil, a [2] = 'a', a [3] = 4
Infine, una dichiarazione come ritorno f () restituisce tutti i valori restituiti da f:

function foo (i)
se i == 0 poi tornare foo0 ()
elseif i == 1 poi tornare foo1 ()
elseif i == 2 poi tornare foo2 ()
fine
fine

stampa (foo (1)) -> un
stampa (foo (2)) -> ab
stampa (foo (0)) - (nessun risultato)
stampa (foo (3)) - (nessun risultato)

È possibile forzare una chiamata per tornare esattamente un risultato racchiudendolo in un paio di parentesi:

stampa ((foo0 ())) -> nil
stampa ((foo1 ())) -> un
stampa ((foo2 ())) -> un
Attenzione che un ritorno dichiarazione non ha bisogno di parentesi attorno al valore restituito, in modo che qualsiasi coppia di parentesi messa lì conta come un altro paio. Cioè, una dichiarazione come ritorno (f ()) restituisce sempre un valore singolo, non importa quanti valori f ritorni. Forse questo è ciò che si vuole, forse no.
Una funzione speciale con più rendimenti è disfare. Riceve un array e restituisce come risultato tutti gli elementi dell'array, a partire dall'indice 1:

stampa (unpack {} 10,20,30) -> 10 20 30
a, b = unpack {} 10,20,30 - a = 10, b = 20, 30 viene scartato

Un uso importante per unpack è in una chiamata generica meccanismo. Un meccanismo di chiamata generica consente di chiamare qualsiasi funzione, con argomenti, in modo dinamico. In ANSI C, per esempio, non c'è modo di farlo. È possibile dichiarare una funzione che riceve un numero variabile di argomenti (con stdarg.h) e si può chiamare una funzione variabili, usando puntatori a funzioni. Tuttavia, non si può chiamare una funzione con un numero variabile di argomenti: ogni chiamata si scrive in C ha un numero fisso di argomenti e ogni argomento ha un tipo fisso. In Lua, se si desidera chiamare una funzione variabile f con argomenti variabili in una matrice una, è sufficiente scrivere

f (unpack (a))
La chiamata a spacchettare restituisce tutti i valori in una, che diventano gli argomenti di f. Ad esempio, se eseguiamo
f = string.find
a = {"ciao", "ll"}

quindi la chiamata f (unpack (a)) restituisce 3 e 4, esattamente come la chiamata statica string.find ("ciao", "ll").
Anche se il predefinito unpack è scritto in C, potremmo scriverlo anche in Lua, utilizzando la ricorsione:

funzione unpack (t, i)
i = i o 1
se t [i] ~ = nil poi
tornare t [i], decomprimere (t, i + 1)
fine
fine

La prima volta che lo chiamiamo noi, con un singolo argomento, io ottiene 1. Quindi la funzione restituisce t [1] seguito da tutti i risultati di unpack (t, 2), che a sua volta ritorna t [2] seguite da tutti i risultati unpack (t, 3), e così via, fino a quando l'ultimo elemento non nullo.