This library provides generic functions for table manipulation. It provides all its functions inside the table [
Remember that, whenever an operation needs the length of a table, all caveats about the length operator apply (see The Length Operator). All functions ignore non-numeric keys in the tables given as arguments.
table.concat (list [, sep [, i [, j]]])
Given a list where all elements are strings or numbers, returns the string
list[i]..sep..list[i+1] ··· sep..list[j]. The default value for
sep is the empty string, the default for
i is 1, and the default for
i is greater than
j, returns the empty string.
table.insert (list, [pos,] value)
value at position
list, shifting up the elements
list[pos], list[pos+1], ···, list[#list]. The default value for
#list+1, so that a call
x at the end of the list
table.move (a1, f, e, t [,a2])
Moves elements from the table
a1 to the table
a2, performing the equivalent to the following multiple assignment:
a2[t],··· = a1[f],···,a1[e]. The default for
a1. The destination range can overlap with the source range. The number of elements to be moved must fit in a Lua integer.
Returns the destination table
Returns a new table with all arguments stored into keys 1, 2, etc. and with a field "
n" with the total number of arguments. Note that the resulting table may not be a sequence, if some arguments are nil.
table.remove (list [, pos])
list the element at position
pos, returning the value of the removed element. When
pos is an integer between 1 and
#list, it shifts down the elements
list[pos+1], list[pos+2], ···, list[#list] and erases element
list[#list]; The index
pos can also be 0 when
#list is 0, or
#list + 1.
The default value for
#list, so that a call
table.remove(l) removes the last element of the list
table.sort (list [, comp])
Sorts the list elements in a given order, in-place, from
comp is given, then it must be a function that receives two list elements and returns true when the first element must come before the second in the final order, so that, after the sort,
i <= j implies
not comp(list[j],list[i]). If
comp is not given, then the standard Lua operator
< is used instead.
comp function must define a consistent order; more formally, the function must define a strict weak order. (A weak order is similar to a total order, but it can equate different elements for comparison purposes.)
The sort algorithm is not stable: Different elements considered equal by the given order may have their relative positions changed by the sort.
table.unpack (list [, i [, j]])
Returns the elements from the given list. This function is equivalent to
return list[i], list[i+1], ···, list[j]
i is 1 and