# For i = 1 in pairs() do

1. What do you want to achieve? I want to learn the difference between for i,v in pairs and for i = 1 in pairs. I also want to learn when should I use for i =1 in pairs.

2. What solutions have you tried so far? Youtube

``````for i = 1 ,#text do
script.Parent.Text = string.sub(text,1,i)
wait()
end
``````
1 Like

Iâm having trouble understanding the question. I havenât ever seen someone do `for i = 1 in pairs() do`. You may be confused with a numeric loop, which follows the format: `for i = start, end do`

1 Like
``````for i = 1 ,#text do

script.Parent.Text = string.sub(text,1,i)

wait()

end
``````

That is what I ment.,

1 Like

This is a numeric loop. It is used when you want to loop between 2 different numbers. We use the `pairs` function to loop through a table. Although, numeric loops can be used to go through a table, they only work for arrays (tables where the indexes are numeric and in order).

``````for index, value in pairs(myArray) do
print(index, value)
end
``````
``````for index = 1, #myArray do
local value = myArray[index]
print(index, value)
end
``````
2 Likes

A numeric loop is used to do something a specific amount of times.

Hereâs like a âdisectionâ of it.

`for` is just a type of loop.
`i` is the name of the variable that can be referenced inside of the loop
`= num1, num2, num3` num1 is the initial number, num2 is the âgoalâ, num3 is the step used to reach this goal. num3 is also optional and is 1 by default

``````for i = 0, 10, 0.1 do
print(i) -- will print 0, 0.1, 0.2, 0.3 etc... all the way to 10 because we used 0.1 as the step
end
``````

Your example would probably error because text is already predefined as a string, you would have to use len on the string.

``````local text = 'Hello here is my text!'

for i = 1, text:len() do
print(text:sub(1,i) -- would print H, He, Hel, Hell, Hello etc...
wait()
end
``````

Also as @OptimisticSide said, there are multiple types of for loops. There are pairs, ipairs, and next iterators.

They all do somewhat close to the same thing but have some key differences.

pairs is used to iterate through a table or dictionary (which may have mixed keys, number keys, or keys with gaps in them). The i and v are used to reference the index and the value. The i would be âkey1â, the v would be 1, then in the next iteration, the i would be key2, value would be {} etcâŚ

The downside to using pairs is that it will not always work in order so the first iteration might be i = key3, value is Color3.new(). Keep in mind though, the index will always correspond with the value so if you arenât too worried about it being in order, itâs not an issue.

So for example,

``````local myDictionary = {
['key1'] = 1;
['key2'] = {};
['key3'] = Color3.new()
}

for i,v in pairs(myDictionary) do
print(i,v) -- would print key1 1, key2 {}, key3 0,0,0 etc...
end
``````

ipairs works similarly to pairs except it will only work for tables that have consecutive number indexes.

``````local myTable = {
[1] = 'string';
[2] = {};
[3] = Color3.new()
}

for i,v in ipairs(myTable) do
print(i,v) -- prints 1 string, 2 {} etc...
end
``````

This will go on as long as there isnât a nil value. But what happens if it runs into a nil value is that it will break (exit, not error) the loop.

``````local myTable = {
[1] = '1';
[2] = '2';
['this is a string key'] = '3'

}

for i,v in ipairs(myTable) do
print(i,v) -- will print 1 1, 2 2 but will never print "this is a string key 3" because it is a non-number value
end
``````

Same thing happens if we have a missing value.

``````local myTable = {
[1] = 1;
[2] = 2;
[4] = 4; -- note we will never see this because of the missing 3 index
}

for i,v in ipairs(myTable) do
print(i,v) -- will print 1 1, 2 2 but never 4 4.
end
``````

The final iterator is the next iterator, probably the most unused one since itâs pretty much the same as pairs. In fact, on the backend, pairs literally uses next to work.

``````local myTable = {
['key'] = 'v';
['key2'] = 'v2';
}

for i,v in next, myTable do
print(i,v) -- prints key v, key2 v2
end
``````

Hereâs the ârawâ pairs.

``````function pairs(t)
return next, t, nil
end
``````

Then there are `repeat` and `while` loops.

While loops basically do something while the condition is true.

``````local var = 1
coroutine.wrap(function()
while var ~= 2 do
print('var is not 2')
wait()
end
end)()
wait(3)
var = 2
``````

This will print âvar is not 2â for 3 seconds since the `var` variable gets assigned 2. Something you might also see is `while true do` or `while wait() do`. The reason people do this is to do something infinitely. The reason `while wait do` works is because wait() returns 2 values which arenât nil. And I assume you have a basic idea of how if statements work, if we do `if wait() then`, it will be considered true.

The final loop is `repeat until` loops. They are basically the same as `while` loops but kind of the opposite. It will repeat something until the condition is true

``````local var = 1
coroutine.wrap(function()
repeat
print('var is not 2')
wait()
until var == 2
end)()
wait(3)
var = 2
``````

This will print âvar is not 2â for 3 seconds as `var` is assigned 2. If you read it out loud, it will make sense. Repeat ___ until var is equal to 2

Anyway, that was a basic rundown of loops, let me know if you have any questions!

Edit:

I left out a few things:

table.foreach passes each index and value to a function:

``````local function printTable(index, value)
print(index, value)
end

table.foreach({['String'] = 'StringValue'; ['String2'] = 'StringValue2'}, printTable)
-->   21:17:07.208  String2 StringValue2  -  Edit
--    21:17:07.208  String StringValue  -  Edit
``````

table.foreachi works similarly to table.foreach in the sense of iterating through the table but it iterates through the length of the table and doesnât stop when the value is nil unlike ipairs.

``````local function printTable(index, value)
print(index,value)
end
table.foreachi({[1] = 'value1'; [2] = 'value2', [4] = 'value4'; ['str'] = 'valuestring'}, printTable)
-->   21:19:34.628  1 value1  -  Edit
--    21:19:34.628  2 value2  -  Edit
--    21:19:34.628  3 nil  -  Edit
--    21:19:34.628  4 value4  -  Edit
``````
5 Likes