[lua] Ajuste do valor de retorno da função

Maillist viu um problema hoje: o valor de retorno de uma função sempre será ajustado para no máximo um valor?

local a, b, c = f(), x -- f() is adjusted to 1 result (c gets nil)

Conclusão: não

Lua ajustará o número de valores de retorno da função e ajustará para 1 se e somente se a função não for o último rvalue. Caso contrário, é ajustado ao valor recebido pelo lvalue.

Resumindo, o valor de retorno da função de julgamento será ajustado para vários, apenas para ver se a função é o último rvalue
: se não, o valor de retorno da função será ajustado para 1; se for o último rvalue, haverá vários receptores à esquerda e a função terá vários valores de retorno (preencha a parte que falta com nil)

Pegue uma castanha:

local function returnTest()
    return 3, 2, 1
end

-- 不是最后一个右值，返回值的个数调整成1
local a, b, c = "first", returnTest(), "last"
print("when function isn't the last element:\n", a, b, c)

-- 是最后一个右值，等号左边还有两个变量可以接收，返回值的个数调整成2
local a, b, c = "last", returnTest()
print("when function is the last element:\n", a, b, c)

-- 是最后一个右值，等号左边还有四个变量可以接收，返回值的个数调整成4。原函数只返回3个，不足的1个用nil补齐
local a, b, c, d, e = "last", returnTest()
print("when function is the last element:\n", a, b, c, d, e)

-- 是最后一个右值，由于接收者是函数，可以接收任意个值，所以返回值的个数不进行调整
print("when function is the last parameter of another function:\n", returnTest())

-- 是最后一个右值，由于无接收者，可以接收0个值，所以返回值的个数调整为0
returnTest()

saída:

when function isn't the last element:
        first   3       last
when function is the last element:
        last    3       2
when function is the last element:
        last    3       2       1       nil
when function is the last parameter of another function:
        3       2       1

5.4 O texto original do manual de referência:

Tanto as chamadas de função quanto as expressões vararg podem resultar em vários valores. Se uma chamada de função for usada como uma instrução (consulte §3.3.6), então sua lista de retorno é ajustada para zero elementos, descartando assim todos os valores retornados. Se uma expressão for usada como o último (ou único) elemento de uma lista de expressões, nenhum ajuste será feito (a menos que a expressão esteja entre parênteses). Em todos os outros contextos, Lua ajusta a lista de resultados para um elemento, descartando todos os valores exceto o primeiro ou adicionando um único nil se não houver valores.

aqui estão alguns exemplos:

 f()                -- adjusted to 0 results
 g(f(), x)          -- f() is adjusted to 1 result
 g(x, f())          -- g gets x plus all results from f()
 a,b,c = f(), x     -- f() is adjusted to 1 result (c gets nil)
 a,b = ...          -- a gets the first vararg argument, b gets
                    -- the second (both a and b can get nil if there
                    -- is no corresponding vararg argument)
 
 a,b,c = x, f()     -- f() is adjusted to 2 results
 a,b,c = f()        -- f() is adjusted to 3 results
 return f()         -- returns all results from f()
 return ...         -- returns all received vararg arguments
 return x,y,f()     -- returns x, y, and all results from f()
 {f()}              -- creates a list with all results from f()
 {...}              -- creates a list with all vararg arguments
 {f(), nil}         -- f() is adjusted to 1 result

Qualquer expressão entre parênteses sempre resulta em apenas um valor. Assim, (f(x,y,z)) é sempre um único valor, mesmo que f retorne vários valores. (O valor de (f(x,y,z)) é o primeiro valor retornado por f ou nil se f não retornar nenhum valor.)