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!
Arrays
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
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
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 first element in the array is number 1
print(myArray[1]) -- prints: A string print(myArray[2]) -- prints: 3.14159 print(myArray[3]:GetFullName()) -- prints: Workspace.Part
myArray[2] = "Pi"
print(myArray[2]) -- prints: Pi
More information
You can get the amount of number keys by using the # operator:
print(#myArray) -- prints: 3 print(#myEmptyArray ) -- prints: 0
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.
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 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
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)
