Tables

A table is a data type in Lua that is a useful way to store multiple values, including numbers, strings, functions, more tables, and much more. It is called a table because it acts like a grid with two columns:

Key	Value

The key column is used to find a row in the table, and the value is the value that is stored in that row. Both the key and value can be any Lua value (numbers, strings, Parts etc., and even other tables) except nil. Lua tables do not have to use either numbers, strings or tables as keys. Any combination of key types can be used.

The # operator will return the amount of keys that are numbers.

Creating a table

To create a table we use a pair of curly braces ({}). We can then store the table in a variable:

myTable = {}

When you use curly braces to define a table, this is called a table literal, which means you're defining a table right in your code. You're literally defining a table!

Indexing a table

Getting values into and out of a table is called indexing. An index in a table is like a row in the table model above. To index something in a table, you first need the key for the index you want to get or change the value in. You put the key in square brackets ([]) after the table that that is to be looked in. For example, to get or change the index with the key 1 in the table myTable, we write myTable[1]. You can then use this exactly like a variable or value: it can be used, or set to a different value. For example, to store the string "A value" in myTable in the row with the key 1, we would write:

myTable = {}
myTable[1] = "A value"

myTable[1] can now be used in other places. For example, the print function:

print(myTable[1]) -- prints: A value

If there is already an index in the table with the key that is being set, the old value will be replaced with the new one:

myTable[1] = "A new value"
print(myTable[1]) -- prints: A new value (as apposed to "A value")

If there isn't a row with the key we're using when we try to get a value, it will return nil:

print(myTable[2]) -- prints: nil

More on table literals

Keys can be added to the table while we are creating a table in a very similar way to indexing. Inside the curly brackets, we can put lines that are very similar to indexing, but without the name of the table, and separated by commas (,) or semicolons (;).

myOtherTable = {
    [1] = "A value",
    ["A string key"] = "Another value",
    [2] = 5
}

print(myOtherTable[1], myOtherTable["A string key"], myOtherTable[2]) -- prints: A value Another value 5

The commas and semicolons are are important! If they are not there, Lua will give an error message saying it expects the closing curly bracket (}) at the line where the next value appears.

You can use anything as the index for a table.

local vector = Vector3.new(1,2,3)

local thisTable = {
    [vector] = "stuff",
    [workspace.Part] = "A cool value"
}

print(thisTable[vector], thisTable[workspace.Part])

If you are defining a key that is a string, you may simply state the string without square brackets nor quotes, so long as they follow the naming guidelines of Lua:

local fruitColors = {
    apple = "red",
    orange = "orange",
    banana = "yellow"
}

print(fruitColors ["apple"], fruitColors["orange"], fruitColors["banana"])
-- prints: red orange yellow

Arrays

An array, or list, is a name given to a table wereas all the keys are whole numbers (e.g. 1, 2, 3, 4...). This is very useful for creating lists of things, such as a list of players with special permissions. You would not need to use a string-type key because there is no reason to - you're simply storing a numerical list of names.

Arrays are created the same way as tables, however you can leave-out the ["key"] = ... part, and just write the values separated by commas, and Lua will automatically associate the numbers 1, 2, 3, 4, 5... as keys to the values in the order they are given:

myArray = {"First value", "Second value", "Third value"}
print(myArray[1]) -- prints: First value
print(myArray[2]) -- prints: Second value
print(myArray[3]) -- prints: Third value

You can get the amount of number keys by using the # operator:

print(#myArray) -- prints: 3

Lua's table manipulation functions allow you to easily do things such as add and remove values from an array.

Note: Normally, nil should not be used as a value in an array. # and Lua's table manipulation functions use nil to tell where an array ends. Putting them in the middle of your table may make Lua think the array ends there.

Iteration through tables

Iteration is the repetition of an action. In this case, you are iterating through the values in a table by taking each value and doing something with it. For-loops (and sometimes while-loops) are used to iterate with tables. You can use the pairs (or ipairs if you only want to iterate over the number keys) function to write a for-loop that goes through every value in a table with the value's key.

for key, value in pairs(myOtherTable) do
    print(key, "=", value)
end

Outputs:
1 = A value
A string key = Another value
2 = 5

Pass by reference

An important thing to understand when setting more than one variable to the same table is that tables are passed by reference. This means that the variable doesn't directly contain the table itself, but that it holds a reference (or pointer) to it. This means that when more than one variable is set to a table, the variables do not each have a copy of the table, they refer to the same table, so any changes will be noticed by both variables:

var1 = {}
var2 = var1
var2["key"] = "value"
print(var1["key"]) -- prints "value" because var2 had pointed to var1's value (the table)

See Also

• Metatables
• 2.5 - Tables
• 3.6 - Table Constructors
• 11.2 - Matrices and Multi-Dimensional Arrays
• Tables Tutorial