lua tables

Concatenación de mesas en lua.

Question

POSTE ORIGINAL

Dado que no hay una función incorporada en Lua, estoy en busca de una función que me permita agregar tablas juntas. He buscado en Google bastante y he intentado todas las soluciones con las que tropecé, pero ninguna parece funcionar correctamente.

El escenario es el siguiente: estoy usando Lua incrustado en una aplicación. Un comando interno de la aplicación devuelve una lista de valores en forma de tabla.

Lo que estoy tratando de hacer es invocar ese comando recursivamente en un bucle y agregar los valores devueltos, nuevamente en forma de tabla, a la tabla de las iteraciones anteriores.

EDITAR

Para aquellos que se encuentren con esta publicación en el futuro, tenga en cuenta lo que @gimf publicó. Dado que las Tablas en Lua son tan parecidas a matrices que cualquier otra cosa (incluso en un contexto de lista), no hay una forma correcta real de agregar una tabla a otra. El concepto más cercano es la fusión de tablas. Consulte la publicación " Lua - merge tables? " Para obtener ayuda al respecto.

Answer 1

¿Respuestas demasiado complicadas?

Aquí está mi implementación:

function TableConcat(t1,t2)
    for i=1,#t2 do
        t1[#t1+1] = t2[i]
    end
    return t1
end

Answer 2

Aquí está mi implementación para concatenar un conjunto de tablas de indexación de enteros puros, FYI.

1. Definir una función para concatenar dos tablas, concat_2tables

2. otra función recursiva concatenateTables : divide la lista de tablas por unpack y llama a concat_2tables para concatenar table1 y restTableList

   t1 = {1, 2, 3}
   t2 = {4, 5}
   t3 = {6}
   
   concat_2tables = function(table1, table2)
       len = table.getn(table1)
       for key, val in pairs(table2)do
           table1[key+len] = val
       end
       return table1
   end
   
   concatenateTables = function( tableList )
       if tableList==nil then
           return  nil
       elseif table.getn(tableList) == 1 then
           return  tableList[1]
       else
           table1 = tableList[1]
           restTableList = {unpack(tableList, 2)}
           return concat_2tables(table1, concatenateTables(restTableList))
       end
   end
   
   tt = {t1, t2, t3}
   t = concatenateTables(tt)  

Answer 3

Aquí hay una implementación que he hecho similar a la de RBerteig arriba, pero usando el parámetro oculto arg que está disponible cuando una función recibe un número variable de argumentos. Personalmente, creo que esto es más legible en comparación con la sintaxis seleccionada.

function array_concat(...)
    local t = {}

    for i = 1, arg.n do
        local array = arg[i]
        if (type(array) == "table") then
            for j = 1, #array do
                t[#t+1] = array[j]
            end
        else
            t[#t+1] = array
        end
    end

    return t
end

Answer 4

En general, la noción de concatenar tablas arbitrarias no tiene sentido en Lua porque una sola clave solo puede tener un valor.

Hay casos especiales en los que la concatenación tiene sentido. Una de ellas es para tablas que contienen matrices simples, que podrían ser el resultado natural de una función que pretende devolver una lista de resultados.

En ese caso, puedes escribir:

-- return a new array containing the concatenation of all of its -- parameters. Scaler parameters are included in place, and array -- parameters have their values shallow-copied to the final array. -- Note that userdata and function values are treated as scalar. function array_concat(...) local t = {} for n = 1,select("#",...) do local arg = select(n,...) if type(arg)=="table" then for _,v in ipairs(arg) do t[#t+1] = v end else t[#t+1] = arg end end return t end

Esta es una copia superficial, y no intenta averiguar si un valor de datos de userdata o función es un contenedor u objeto de algún tipo que pueda necesitar un tratamiento diferente.

Una implementación alternativa puede modificar el primer argumento en lugar de crear una nueva tabla. Esto ahorraría el costo de copiar y haría que array_concat diferente del operador .. en las cadenas.

Edit: Como se observó en un comentario de Joseph Kingry , no logré extraer correctamente el valor real de cada argumento de ... También no pude devolver la tabla combinada de la función en absoluto. Eso es lo que obtengo por la codificación en el cuadro de respuesta y no probar el código en absoluto.

Answer 5

Para sumar dos tablas juntas haz esto

    ii=0
for i=#firsttable, #secondtable+#firsttable do
    ii=ii+1
    firsttable[i]=secondtable[ii]
end

use la primera tabla como la variable que desea agregar a medida que el código agrega la segunda al final de la primera tabla en orden.

• i es el número inicial de la tabla o lista.
• #secondtable+#firsttable es en qué terminar.

Comienza al final de la primera tabla a la que desea agregar, y termina al final de la segunda tabla en un bucle for para que funcione con cualquier tabla o lista de tamaño.

Answer 6

Si desea combinar dos tablas, pero necesita una copia profunda de la tabla de resultados, por el motivo que sea, use la combinación de otra pregunta SO al combinar tablas más un código de copia profunda de lua-users .

(edite Bueno, quizás pueda editar su pregunta para proporcionar un ejemplo mínimo ... Si quiere decir que una tabla

 { a = 1, b = 2 }

concatenado con otra mesa

{ a = 5, b = 10 }

debe resultar en

{ a = 1, b = 2, a = 5, b = 10 }

entonces estás fuera de suerte. Las llaves son únicas.

Parece que quieres tener una lista de pares, como { { a, 1 }, { b, 2 }, { a, 5 }, { b, 10 } } . También puede usar una estructura final como { a = { 1, 5 }, b = { 2, 10 } } , dependiendo de su aplicación.

Pero la noción simple de "concatenar" tablas no tiene sentido con las tablas Lua. )

Answer 7

Una forma sencilla de hacer lo que quieras:

local t1 = {1, 2, 3, 4, 5}
local t2 = {6, 7, 8, 9, 10}

local t3 = {unpack(t1)}
for I = 1,#t2 do
    t3[#t1+I] = t2[I]
end

Answer 8

Y una forma más:

for _,v in ipairs(t2) do 
    table.insert(t1, v)
end

Me parece el más legible: itera sobre la 2ª tabla y agrega sus valores a la 1ª, final de la historia. Curioso cómo le va en velocidad a la indexación explícita [] arriba