Do these lines do the same thing?
I am just wondering if these both do the same thing.
I always use:
1 | for i,v in pairs do |
I never use:
1 | for i = 1, #Bleh do |
2
3 answers
Not exactly.
The pairs function iterates over the key/value pairs in a table. With this function the key/value mappings do not have to be ordered numerically for it to look through all the pairs.
The ipairs function is more similar to a numeric for loop, as it does require numeric ordering of key/value pairs. However, it stops as soon as it finds a nil value so it may not loop over all the mappings.
Usage Examples
01 | local table = {"Apple", "Banana", [4] = "Donut", ["Peach"] = "Pear"} |
02 |
03 | for key, value in pairs(table) do |
04 | print(key, value) |
05 | end |
06 |
07 | -- Output: |
08 | -- 1 Apple |
09 | -- 2 Banana |
10 | -- 4 Donut |
11 | -- Peach Pear |
12 |
13 | for key, value in ipairs(table) do |
14 | print(key, value) |
15 | end |
First one catches the value's integer (position) and value.
01 | myTable = {"Hello", 10, true, function() return "worked!" end} |
02 |
03 | for i,v in pairs(myTable) do |
04 | print(i, v, type(v)) |
05 | if type(v) == "function" then |
06 | print(v()) -- Runs the function, returns the string and uses it in a print-function. |
07 | end |
08 | end |
09 |
10 | --[[ Output: |
11 | 1 Hello string |
12 | 2 10 number |
13 | 3 true boolean |
14 | 4 function: xxxxxxxx function |
15 | worked! |
16 | ]] |
The fourth value prints a bunch of characters, not necessarily just x's. It's the function's ID.
Second one uses integers to determine how many loops the for-loop should do. It also uses an identifier to help find out how many loops it has done.
01 | startNumber = 9 |
02 | stopNumber = 23 |
03 |
04 | for i = startNumber / 3, stopNumber / 3 do -- 3, 7.666... |
05 | print(i * 2) |
06 | end |
07 |
08 | --[[ Output: |
09 | 6 |
10 | 8 |
11 | 10 |
12 | 12 |
13 | 14 |
14 | ]] |
It started with 6 since 3 was the starting number and it printed 3 times 2 (print(i * 2)). It ended with 14 since 16 would mean i is equal to 8 which is above the ending number (7.666...) and could not be included in the loop.
I'm gonna talk about how these actually work. Lua.org is a good place to go that.
for i = 1, #tab do is a numeric for loop. It's the same as
1 | for i = 1, 10 do |
2 | print(i) |
3 | end |
which is pretty straightforward.
for i, v in pairs(tab) do, however, is a generic for loop. It uses an iterator function. According to the wiki, an iterator function is just "a function that returns the next set of values each time it is called."
Before we talk about pairs, let's cover ipairs. It's actually pretty simple how ipairs works.
01 | function iter (t, i) |
02 | i = i + 1 |
03 | local v = t[i] |
04 | if v then |
05 | return i, v |
06 | end |
07 | end |
08 |
09 | function ipairs (t) |
10 | return iter, t, 0 |
11 | end |
iter is the iterator function, t is the array, and 0 is the initial value. Lua then calls iter(a, 0), then iter(a, 1), then iter(a, 2) etc.
pairs() works similarly.
1 | function pairs (t) |
2 | return next, t, nil |
3 | end |
next is a primitive iterator function in Lua. next(table, key) will return the next key and value in the table, although in no specified order. next(table, nil) will return the first key and value in the table, which is why pairs also returns nil.
You can also use next directly. Since pairs(t) returns next, t, nil, we can just do this:
1 | for i, v in next, t, nil do |
Or, since nil is nil,
1 | for i, v in next, t do |
I think the other answer already explained the practical differences, so I'll leave it at that.