In Lua 5.2 and upwards the best workaround is to use goto:

-- prints odd numbers in [|1,10|] for i=1,10 do if i % 2 == 0 then goto continue end print(i) ::continue:: end 

This is supported in LuaJIT since version 2.0.1

The way that the language manages lexical scope creates issues with including both goto and continue. For example,

local a=0 repeat if f() then a=1 --change outer a end local a=f() -- inner a until a==0 -- test inner a 

The declaration of local a inside the loop body masks the outer variable named a, and the scope of that local extends across the condition of the until statement so the condition is testing the innermost a.

If continue existed, it would have to be restricted semantically to be only valid after all of the variables used in the condition have come into scope. This is a difficult condition to document to the user and enforce in the compiler. Various proposals around this issue have been discussed, including the simple answer of disallowing continue with the repeat ... until style of loop. So far, none have had a sufficiently compelling use case to get them included in the language.

The work around is generally to invert the condition that would cause a continue to be executed, and collect the rest of the loop body under that condition. So, the following loop

-- not valid Lua 5.1 (or 5.2) for k,v in pairs(t) do if isstring(k) then continue end -- do something to t[k] when k is not a string end 

could be written

-- valid Lua 5.1 (or 5.2) for k,v in pairs(t) do if not isstring(k) then -- do something to t[k] when k is not a string end end 

It is clear enough, and usually not a burden unless you have a series of elaborate culls that control the loop operation.

You can wrap loop body in additional repeat until true and then use break inside for effect of continue. Naturally, you'll need to set up additional flags if you also intend to really break out of loop as well.

This will loop 5 times, printing 1, 2, and 3 each time.

for idx = 1, 5 do repeat print(1) print(2) print(3) do break end -- goes to next iteration of for print(4) print(5) until true end 

The break is wrapped in do and end to keep Lua from complaining about the unreachable code below it. This isn't necessary if the break is wrapped in an if condition, as will be the case in most real-world code.

This construction even translates to literal one opcode JMP in Lua bytecode!

$ luac -l continue.lua main <continue.lua:0,0> (22 instructions, 88 bytes at 0x23c9530) 0+ params, 6 slots, 0 upvalues, 4 locals, 6 constants, 0 functions 1 [1] LOADK 0 -1 ; 1 2 [1] LOADK 1 -2 ; 3 3 [1] LOADK 2 -1 ; 1 4 [1] FORPREP 0 16 ; to 21 5 [3] GETGLOBAL 4 -3 ; print 6 [3] LOADK 5 -1 ; 1 7 [3] CALL 4 2 1 8 [4] GETGLOBAL 4 -3 ; print 9 [4] LOADK 5 -4 ; 2 10 [4] CALL 4 2 1 11 [5] GETGLOBAL 4 -3 ; print 12 [5] LOADK 5 -2 ; 3 13 [5] CALL 4 2 1 14 [6] JMP 6 ; to 21 -- Here it is! If you remove do break end from code, result will only differ by this single line. 15 [7] GETGLOBAL 4 -3 ; print 16 [7] LOADK 5 -5 ; 4 17 [7] CALL 4 2 1 18 [8] GETGLOBAL 4 -3 ; print 19 [8] LOADK 5 -6 ; 5 20 [8] CALL 4 2 1 21 [1] FORLOOP 0 -17 ; to 5 22 [10] RETURN 0 1 

Straight from the designer of Lua himself:

Our main concern with "continue" is that there are several other control structures that (in our view) are more or less as important as "continue" and may even replace it. (E.g., break with labels [as in Java] or even a more generic goto.) "continue" does not seem more special than other control-structure mechanisms, except that it is present in more languages. (Perl actually has two "continue" statements, "next" and "redo". Both are useful.)

The first part is answered in the FAQ as slain pointed out.

As for a workaround, you can wrap the body of the loop in a function and return early from that, e.g.

-- Print the odd numbers from 1 to 99 for a = 1, 99 do (function() if a % 2 == 0 then return end print(a) end)() end 

Or if you want both break and continue functionality, have the local function perform the test, e.g.

local a = 1 while (function() if a > 99 then return false; -- break end if a % 2 == 0 then return true; -- continue end print(a) return true; -- continue end)() do a = a + 1 end 

I've never used Lua before, but I Googled it and came up with this:

http://www.luafaq.org/

Check question 1.26.

This is a common complaint. The Lua authors felt that continue was only one of a number of possible new control flow mechanisms (the fact that it cannot work with the scope rules of repeat/until was a secondary factor.)

In Lua 5.2, there is a goto statement which can be easily used to do the same job.

Lua is a lightweight scripting language which aims to be as small as possible. For example, many unary operators such as pre/post increment, are not available.

Instead of continue, you can use goto:

arr = {1,2,3,45,6,7,8} for key,val in ipairs(arr) do if val > 6 then goto skip_to_next end # perform some calculation ::skip_to_next:: end 

We can achieve it as below, it will skip even numbers

local len = 5 for i = 1, len do repeat if i%2 == 0 then break end print(" i = "..i) break until true end 

O/P:

i = 1 i = 3 i = 5 

We encountered this scenario many times and we simply use a flag to simulate continue. We try to avoid the use of goto statements as well.

Example: The code intends to print the statements from i=1 to i=10 except i=3. In addition it also prints "loop start", loop end", "if start", and "if end" to simulate other nested statements that exist in your code.

size = 10 for i=1, size do print("loop start") if whatever then print("if start") if (i == 3) then print("i is 3") --continue end print(j) print("if end") end print("loop end") end 

is achieved by enclosing all remaining statements until the end scope of the loop with a test flag.

size = 10 for i=1, size do print("loop start") local continue = false; -- initialize flag at the start of the loop if whatever then print("if start") if (i == 3) then print("i is 3") continue = true end if continue==false then -- test flag print(j) print("if end") end end if (continue==false) then -- test flag print("loop end") end end 

I'm not saying that this is the best approach but it works perfectly to us.

Again with the inverting, you could simply use the following code:

for k,v in pairs(t) do if not isstring(k) then -- do something to t[k] when k is not a string end 

Funnily enough, I've just posted a YouTube video that is relevant to this: https://youtu.be/qL2VsAjGRnY.

The point I make in the video is that you should not be needing to continue from inside a loop.

You should aim to make the data correct before iterating over it. In Lua, this looks like this:

-- prints odd numbers in [|1,10|] local items = {} -- make the table for i = 1, 10 do table.insert(items, i) end --now filter out even numbers local odds = {} for i = 1, #items do if items[i] % 2 ~= 0 then table.insert(odds, items[i]) end end -- now we can print the odds for _, v in ipairs(odds) do print(v) end 

This demonstrates the principal of getting the data right BEFORE processing it rather than during the processing.