Concatenation таблиц в Lua

Question

ОРИГИНАЛЬНЫЙ ПОСТ

Учитывая, что нет встроенной функции в Lua, я в поисках функции, которая позволяет мне добавлять таблицы вместе. Я немного поработал в Google и пробовал все решения, которые я наткнулся, но ни один из них не работает должным образом.

Сценарий выглядит следующим образом: Я использую Lua, встроенную в приложение. Внутренняя команда приложения возвращает список значений в виде таблицы.

То, что я пытаюсь сделать, это вызвать эту команду рекурсивно в цикле и добавить возвращаемые значения снова в виде таблицы в таблицу из предыдущих итераций.

---

EDIT

Для тех, кто пришел на этот пост в будущем, обратите внимание на то, что @gimf вывешенным. Поскольку таблицы в Lua так же похожи, как и массивы, чем что-либо еще (даже в контексте списка), нет реального правильного способа добавления одной таблицы в другую. Ближайшей концепцией является слияние таблиц. Пожалуйста, см. Сообщение «Lua - merge tables?» за помощью в этом отношении.

Answer 1

Если вы хотите объединить две таблицы, но вам нужна глубокая копия таблицы результатов, по какой-либо причине используйте слияние с another SO question on merging tables плюс код глубокой копии от lua-users.

(редактировать Ну, может быть, вы можете изменить свой вопрос, чтобы обеспечить минимальный пример ... Если вы имеете в виду, что таблица

{ a = 1, b = 2 } 

сцепляются с другой таблицей

{ a = 5, b = 10 } 

должен результат

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

, тогда вам не повезло. Ключи уникальны.

Кажется, что вы хотите иметь список пар, например { { a, 1 }, { b, 2 }, { a, 5 }, { b, 10 } }. Вы также можете использовать конечную структуру, например { a = { 1, 5 }, b = { 2, 10 } }, в зависимости от вашего приложения.

Но простое представление о «конкатенировании» таблиц не имеет смысла в таблицах Lua. )

Answer 2

В целом понятие конкатенирования произвольных таблиц не имеет смысла в Lua, поскольку один ключ может иметь только одно значение.

Существуют особые случаи, когда конкатенация имеет смысл. Один из них относится к таблицам, содержащим простые массивы, что может быть естественным результатом функции, предназначенной для возврата списка результатов.

В этом случае, вы можете написать:

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

Это неполная копия, и не делает никаких попыток выяснить, если userdata или значение функции является контейнером или объект какого-то, что может понадобиться разным лечение.

Альтернативная реализация может изменить первый аргумент, а не создавать новую таблицу. Это позволит сэкономить затраты на копирование и сделать array_concat отличным от оператора .. по строкам.

Edit: Как было отмечено в комментарии по Joseph Kingry, я не смог правильно извлечь фактическое значение каждого аргумента из .... Я также не смог полностью вернуть объединенную таблицу из этой функции. Это то, что я получаю для кодирования в окне ответа, а не для тестирования кода вообще.

Answer 3

Вот реализация, которую я сделал аналогично RBerteig выше, но с использованием скрытого параметра arg, который доступен, когда функция получает переменное количество аргументов. Лично я считаю, что это более читаемо по сравнению с синтаксисом select.

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

Чтобы добавить две таблицы вместе это сделать

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

использовать первую таблицу в качестве переменной, которую вы хотели добавить код добавляет второй к концу первой таблицы в порядке.

• i - начальный номер таблицы или списка.
• #secondtable+#firsttable - это то, к чему нужно закончить.

Она начинается в конце первой таблицы вы хотите добавить, и заканчивается в конце второй таблицы в for петли, так она работает с любым размером таблицей или списком.

Answer 5

Сложные ответы много?

вот моя реализация:

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

Answer 6

Простой способ сделать то, что вы хотите:

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 7

И еще один способ:

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

Это кажется мне наиболее читаемый - он повторяет вторую таблицу и добавляет ее значения к 1-му, концу истории. Любопытно, как это ускоряется в скорости до явного индексации [] выше

Answer 8

Вот моя реализация, чтобы объединить набор таблиц с индексом чистого целого, FYI.

1. определить функцию объединения двух таблиц, concat_2tables

2. другой рекурсивную функцию concatenateTables: разделить список таблицы на unpack и вызвать concat_2tables конкатенировать table1 и 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)