For i = 1, #children do

i have this script that goes as followed:

“for i = 1, #children do
children[i].material = “Neon””

my first question is what does “for i = 1” do? and my second question is what do the [] brackets do?

put three backticks please, it’s under the Esc key, also it’s to loop until it reaches a number after 1,, and the brackets [] are for getting a certain item in a table using a string or a integer

This is making a for loop. The code inside will run multiple times, and the i variable will be set to a different number each time. The number starts at 1 and ends at another number.

for i = 1, 5 do

You can get the length of a list like this:

local list = {"a","b","c","d"}
print(#list) --> 4
-- The '#' operator can get the length of a list and a string

You can get items of a list like this:

local list = {"a","b","c","d"}
print(list[3]) --> c

Basically, it iterates through all the children and changes their material. In Lua, arrays start from 1. So it starts at 1 and ends at the length of the array(which is given by the # operator). More specifically this is equivalent to the following code:

for _, v in pairs(children) do
	v.Material = "Neon"

The only difference is that instead of v you have children[i] which is pretty much the same(the value at a specific index). The _ is the i but in Lua, it’s a good practice to name it _ when it’s not being used.

1 Like

Tables can be very complicated to understand at first, but once you get it you’ll love it. All you have to understand is how to access stuff in a table. Roblox has two types of tables, arrays and dictionaries.
The array is simple, you just type

local array_value_2 = "hello world"
local my_table = {"array value 1", array_value_2, workspace.Part, function()end, {}}

The array has a hidden element which is the index. Every index is separated by a comma and the first index is 1, so “array value 1” has index 1, workspace.Part has index 3.

This is what makes the array and dictionary different. In a dictionary, the “index” is called a key, it is not hidden. For example here’s a dictionary:

local array_value_2 = "hello world"
local my_table = {key_1 = "array value 1", key_2 = array_value_2, key_5 = workspace.Part, key_69 = function()end, empty_table_key = {}}

The key and index are the same thing, don’t get confused by that they are called differently. The index is a key, but not every key is an index just like how a square is a rectangle, but not every rectangle is a square.

These keys are how you access the contents of a table. Another very helpful thing is to think of the Explorer as a table. For example:

local rainbow_part = workspace.Parts_Folder.Rainbow_Part

This code tries to access an Instance in the explorer ||(everything in explorer is Instance, but the first ones like Workspace, ServerScriptService, etc. are services, that’s why you do game:GetService(""))||

In the explorer every object DIRECTLY inside another object is its child. Every object INDIRECTLY inside another object is its descendant. For example in the code above Rainbow_Part is a child of Parts_Folder, but it’s a descendant of Workspace because its an indirect child. This is applicable to the tables you make in scripts.

What happens there is the key of workspace.Parts_Folder is Parts_Folder and the value is what would be returned if you assign it to a variable.

I haven’t talked about values above so every key and index has a value. When you try to explore a table, the key/index that you choose to access returns the value assigned to it. For example:

local array_value_2 = "hello world"
local my_table = {"array value 1", array_value_2, workspace.Part, function()end, {}}
local value = my_table[1] -- this is now equal to "array value 1"

It’s incredibly important to understand what return does when you work with tables because they return values. When you assign a variable to anything, it’s now equal to whatever that returned (as seen above).

With dictionaries you can use different ways to select keys in a table, for example you can do the [] with a string inside, use a dot . or use a colon : which is also called a method. The colon basically adds a bit more complexity as it passes an additional parameter called self so you don’t have to. I never found a use for methods and you probably won’t for a long time too. For example:

local my_table = {key_1 = "array value 1", key_2 = array_value_2, key_5 = workspace.Part, key_69 = function()end, empty_table_key = {}}
local value_1 = my_table["key_1"]
local value_1 = my_table.key_1

The values returned by a table can also be functions, but when you try to access a function in a table with () it runs the function with the given paraments. For example:

local function_table = {
  function_1 = function()
    return "one"
  function_2 = function()
    return 2
local value_1 = function_table.function_1() -- value_1 = "one"
local value_2 = function_table["function_2"]() -- value_2 = 2

With some basic function understanding you can also pass parameters that change what the function returns, but this isn’t the current topic.
Long story short, the square brackets are a good way to search a table if you want to make your code more abstract. The circle brackets are to call functions and pass parameters, the curly brackets are to make tables. For example:

local function_table = nil
function_table = {
  function_1 = function(key_name)
    return function_table[key_name]
  function_2 = function(key_name)
    return function_table[key_name]()
  function_3 = function()
    return "hello_world"

print(function_table.function_1("function_3")) -- prints the function itself
print(function_table.function_2("function_3")) -- prints "hello_world"
1 Like