Tables and arrays
Tables are the core data structure in Lua and they are used to store collections of values. Tables can be used to represent arrays, sets, maps, and other data structures. In Lua, arrays are simply a special case of tables where the keys are integers starting at 1.
Here's an example of how to create a simple array in Lua:
local my_array = {1, 2, 3, 4, 5}
In this case, the variable my_array is a table with five elements, where the keys are integers starting at 1 and the values are the numbers 1 through 5.
Here's an example of how to access and modify elements in a Lua array:
local my_array = {1, 2, 3, 4, 5}
print(my_array[3]) -- prints 3
my_array[4] = 42
print(my_array[4]) -- prints 42
In this case, we use the square brackets notation to access and modify elements in the array. The expression my_array[3] retrieves the value of the third element in the array, which is 3. The statement my_array[4] = 42 modifies the value of the fourth element in the array to 42.
Tables can also be used to represent more complex data structures, like maps. Here's an example of how to create a map in Lua:
local my_map = {foo = "bar", baz = 42}
In this case, the variable my_map is a table with two elements, where the keys are the strings "foo" and "baz", and the values are the string "bar" and the number 42, respectively.
Here's an example of how to access and modify elements in a Lua map:
local my_map = {foo = "bar", baz = 42}
print(my_map.foo) -- prints "bar"
my_map.baz = 13
print(my_map.baz) -- prints 13
In this case, we use the dot notation to access and modify elements in the map. The expression my_map.foo retrieves the value of the element with key "foo", which is the string "bar". The statement my_map.baz = 13 modifies the value of the element with key "baz" to 13.
Tables in Lua are very flexible and powerful. They can contain any combination of data types, including other tables. Here's an example of how to create a table of tables in Lua:
local my_table = {
{1, 2, 3},
{4, 5, 6},
{7, 8, 9}
}
In this case, the variable my_table is a table with three elements, where each element is itself a table representing a row of a 3x3 matrix.
Here's an example of how to access and modify elements in a table of tables:
local my_table = {
{1, 2, 3},
{4, 5, 6},
{7, 8, 9}
}
print(my_table[2][3]) -- prints 6
my_table[3][2] = 42
print(my_table[3][2]) -- prints 42
In this case, we use the square brackets notation to access and modify elements in the table of tables. The expression my_table[2][3] retrieves the value of the element at row 2, column 3, which is 6. The statement my_table[3][2] = 42 modifies the value of the element at row 3, column 2 to 42.
Tables in Lua can also have key-value pairs with keys of any type. Here's an example of how to create a table with string keys and values of different types:
local my_table = {
name = "Alice",
age = 30,
interests = {"reading", "hiking", "baking"}
}
In this case, the variable my_table is a table with three elements, where each element is a key-value pair. The first element has the key "name" and the value "Alice". The second element has the key "age" and the value 30. The third element has the key "interests" and the value {"reading", "hiking", "baking"}, which is an array of strings.
Here's an example of how to access and modify elements in a table with string keys:
local my_table = {
name = "Alice",
age = 30,
interests = {"reading", "hiking", "baking"}
}
print(my_table.name) -- prints "Alice"
my_table.age = my_table.age + 1
print(my_table.age) -- prints 31
table.insert(my_table.interests, "yoga")
print(my_table.interests[4]) -- prints "yoga"
In this case, we use the dot notation to access and modify elements in the table. The expression my_table.name retrieves the value of the element with key "name", which is the string "Alice". The statement my_table.age = my_table.age + 1 increments the value of the element with key "age" by 1. The statement table.insert(my_table.interests, "yoga") appends the string "yoga" to the array stored in the element with key "interests".
In conclusion, tables are a powerful and flexible data structure in Lua that can be used to represent arrays, sets, maps, and other complex data structures. They can contain any combination of data types, including other tables, and can have keys of any type. By understanding how to use tables effectively, you can write more expressive and powerful Lua programs.
Leave a Comment