(Redirected from API:Table)
< Scripting | Data Types

A table is a data type in Lua that is useful 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.

Another way to describe it is that by inputting the key, you receive the value.

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


An array is a list of values, stored in order. It is a table where the keys are sequential integers starting at 1, e.g. 1, 2, 3, 4. Arrays are useful for creating lists of things, such as a list of players with special permissions.

Creating arrays[edit]

Arrays are created with a pair of braces ({ and }), containing the values to store in the array separated by commas (,) or semicolons (;). The values can be of any type.

local myArray = {"A string", 3.14159, Workspace.Part}
local myEmptyArray = {}

Reading from and writing to arrays[edit]

To read from an array, add a pair of brackets ([ and ]) after the array, and put the number of the element you want inside it. The element in the array start at index 1.

myArray[2] = "Pi"
A string


Iterating over arrays[edit]

See also: generic for and ipairs

You should use ipairs to iterate over arrays, rather than pairs.

for index, value in ipairs(myArray) do
    print(index, '=', value)

More information[edit]

You can get the length of the array with the # operator:

print(#myArray)       --> 3
print(#myEmptyArray ) --> 0

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


Dictionaries are an extension of arrays. While an array stores an ordered list of items, a dictionary stores a set of key/value pairs. For example, in a real dictionary, the "keys" are the words, and the "values" the definition.

Creating a dictionary[edit]

Once again, dictionaries are created with braces

local myDictionary = {
	["Roblox"] = "A massively multiplayer online game",
	["Wiki"] = "A Web site developed collaboratively by a community of users",
	["Lua"] = "A lightweight multi-paradigm programming language"

Like arrays, dictionaries are not restricted to strings. The values can be any type, but the keys are restricted to non-nil values. For example, this would be a valid dictionary:

local playerScores = {
	[game.Players.Telamon] = "Over 9000!",  
	[game.Players.Roblox] = 1337,
	[game.Players.Sorcus] = Enum.DialogTone.Enemy

And this wouldn't:

local playerScores = {
	[nil] = "Hey!",
	[game.Players.Telamon] = "Over 9000!",  
	[game.Players.Roblox] = 1337,
	[game.Players.Sorcus] = Enum.DialogTone.Enemy
error, line 2: table index is nil

Shorthand for string keys[edit]

If a key in a dictionary is a string, and a valid Lua identifier (that is, it can be used as the name of a variable), the quotes and brackets can be omitted:

local myDictionary = {
	Roblox = "A massively multiplayer online game",
	Wiki = "A Web site developed collaboratively by a community of users",
	Lua = "A lightweight multi-paradigm programming language"

Indexing a dictionary[edit]

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:

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]) --> 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]) --> nil


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 function to write a for-loop that goes through every key and value in a table.

for key, value in pairs(myOtherTable) do
    print(key, "=", value)
1 = A value
A string key = Another value
2 = 5

Pass by reference[edit]

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[edit]