What is this line of code doing?

[IProgramForFun]

Could someone explain what this code snippet is doing?

for k=1, #arr do local v = arr[k]

[XdJackyboiiXd21 (GDoggs_Jack)]

I could explain it better with more code, but basically it is looping through a table, and making a variable called v that is equal to that value in the table.

for k = 1, #arr --for loop that increases until it reaches the number of values in the table
--then it sets a variable to the table[k]

It’s basically the same as:

for i, v in pairs(tablename) do
       
end

[IProgramForFun]

Which one would you say is faster though?

[tehgreatdoge]

I would assume the one using in pairs, but I will have to do some testing. either way, the different is probably unnoticeable in tables under 1000 values.

[XdJackyboiiXd21 (GDoggs_Jack)]

Yes, in pairs I would assume is faster because the other one needs an extra line to set the v variable.

[IProgramForFun]

No I dont think so because pairs is using a function call overhead and this one doesnt saving performance thus being faster

[SanctuaryIX (Sanctuary)]

The one you wrote is faster than doing pairs. Check this thread:

Faster lists loops?

I found this thread about optimizations you can do in Lua if you would like to read it. Most notably in my opinion, they write not to use ipairs and instead get the index and values yourself using a for-loop. I think that you should probably be less worried about premature optimization with syntax, unless you start running into problems. This thread actually has tested that: The 10,000 items are looped over in 38 ms, which I would say is not worrisome.

[XdJackyboiiXd21 (GDoggs_Jack)]

I’ll test it. If we ran 2 coroutines at the same time we could test it.

[IProgramForFun]

Alright test it and get back to me with the results

[XdJackyboiiXd21 (GDoggs_Jack)]

I have to go, here is the code I came up with. The problem is that one coroutine goes, then the other coroutine doesn’t start until the first one is finished. Maybe someone could fix my code so it works. The idea is to see which one stops printing first so that we know which loop is faster.

local testTable = {
	
}

for i = 1, 100 do
	table.insert(testTable, i)
end

wait(2)


local c = coroutine.wrap(function()
	for i, v in pairs (testTable) do
		print(v.." In pairs loop")
	end
end)

local a = coroutine.wrap(function()
	for k=1, #testTable do 
		local v = testTable[k]
		print(v.." Other loop")
	end
end)

a()
c()

[PhoenixRessusection (PhoenixCausesOof)]

@sleitnick

Edit 2020: The new Luau interpreter makes all three methods comparable in speed. Use ipairs for arrays and pairs for dictionaries.

pairs is much faster than ipairs. Only use ipairs if you really have to. In other words, only use ipairs if you have a mixed table and must scan through only numeric indices. However, you can really just design your tables to avoid that scenario.

The speed between next and pairs is really not significant. Read my article about it here!

If you’re looking for the best performance in a numeric-indexed table array, use a numeric for loop. However, only do so if you have to. Remember: Programming is a science and an art, and code readability is important. I would use pairs in all circumstances unless I was forced to use something else due to performance issues.

As said here, you should use numeric for loops when looping through a numeric-indexed array, but do note what he said.