[lua] Ajuste del valor de retorno de la función

Maillist vio un problema hoy: ¿El valor de retorno de una función siempre se ajustará a un valor como máximo?

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

Conclusión: no

Lua ajustará el número de valores de retorno de la función y lo ajustará a 1 si y solo si la función no es el último valor r. En caso contrario se ajusta al importe recibido por el lvalue.

En resumen, el valor de retorno de la función de evaluación se ajustará a varios, solo para ver si la función es el último valor r
: si no, el valor de retorno de la función se ajustará a 1; si es el último valor r, entonces hay varios receptores a la izquierda, y la función tendrá varios valores de retorno (complete la parte que falta con cero)

Toma una castaña:

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

producción:

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 El texto original del manual de referencia:

Tanto las llamadas a funciones como las expresiones vararg pueden generar varios valores. Si se usa una llamada de función como declaración (ver §3.3.6), entonces su lista de devolución se ajusta a cero elementos, descartando así todos los valores devueltos. Si se utiliza una expresión como el último (o el único) elemento de una lista de expresiones, no se realiza ningún ajuste (a menos que la expresión esté entre paréntesis). En todos los demás contextos, Lua ajusta la lista de resultados a un elemento, descartando todos los valores excepto el primero o agregando un solo cero si no hay valores.

Aquí hay unos ejemplos:

 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

Cualquier expresión encerrada entre paréntesis siempre da como resultado un solo valor. Por lo tanto, (f(x,y,z)) es siempre un solo valor, incluso si f devuelve varios valores. (El valor de (f(x,y,z)) es el primer valor devuelto por f o nil si f no devuelve ningún valor).