table

Sets the value for all keys within the given table to nil. This causes the # operator to return 0 for the given table. The allocated capacity of the table's array portion is maintained, which allows for efficient re-use of the space.

local grades = {95, 82, 71, 92, 100, 60}
print(grades[4], #grades) --> 92, 6
table.clear(grades)
print(grades[4], #grades) --> nil, 0
-- If grades is filled again with the same number of entries,
-- no potentially expensive array resizing will occur
-- because the capacity was maintained by table.clear.

This function does not delete/destroy the table provided to it. This function is meant to be used specifically for tables that are to be re-used.

Returns an unfrozen shallow copy of the provided table.

Given an array where all elements are strings or numbers, returns the string t[i] ... sep ... t[i+1] ... sep ... t[j]. The default value for sep is an empty string, the default for i is 1, and the default for j is #t. If i is greater than j, returns the empty string.

Creates a table with the array portion allocated to the given number of elements, optionally filled with the given value.

local t = table.create(3, "Roblox")
print(table.concat(t)) --> RobloxRobloxRoblox

If you are inserting into large array-like tables and are certain of a reasonable upper limit to the number of elements, it's recommended to use this function to initialize the table. This ensures the table's array portion of its memory is sufficiently sized, as resizing it can be expensive. For small quantities this is typically not noticeable.

Within the given array-like table haystack, find the first occurrence of value needle, starting from index init or the beginning if not provided. If the value is not found, nil is returned.

A linear search algorithm is performed.

local t = {"a", "b", "c", "d", "e"}
print(table.find(t, "d")) --> 4
print(table.find(t, "z")) --> nil, because z is not in the table
print(table.find(t, "b", 3)) --> nil, because b appears before index 3

This function makes the given table read-only, effectively "freezing" it in its current state. Attempting to modify a frozen table throws an error.

This freezing effect is shallow, which means that you can write to a table within a frozen table. To deep freeze a table, call this function recursively on all of the descending tables.

Inserts the provided value to the target position of the array.

Appends the provided value to the end of the array.

This function returns true if the given table is frozen and false if it isn't frozen. You can freeze tables using table.freeze().

Returns the maximum numeric key of the provided table, or zero if the table has no numeric keys. Gaps in the table are ignored.

Copies elements in table src from src[a] up to src[b] into table dst starting at index t. Equivalent to the assignment statement dst[t], ..., dst[t + (b - a)] = src[a], ..., src[b].

The default for dst is src. The destination range may overlap with the source range.

Returns dst for convenience.

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.

local t = table.pack(1, 2, 3)
print(table.concat(t, ", ")) --> 1, 2, 3

Removes from array t the element at position pos, returning the value of the removed element. When pos is an integer between 1 and #t, it shifts down the elements t[pos+1], t[pos+2], ..., t[#t] and erases element t[#t]. If the pos parameter is not provided, pos defaults to the length of the table removing the last element.

Sorts elements of array t in a given order, from t[1] to t[#t]. If comp is given, then it must be a function that receives two elements and returns true when the first element must come before the second in the final order.

The error invalid order function for sorting is thrown if both comp(a, b) and comp(b, a) return true.

If comp is not given, then the standard Lua operator < is used instead.

Returns the elements from the given list. By default, i is 1 and j is the length of list.

Note that this same functionality is also provided by the global unpack() function.