Loops in Julia

A for loop in Julia iterates over anything that implements the iteration protocol — ranges like 1:10, arrays, dictionaries, strings, and custom types alike — using the syntax for i in 1:10 ... end (the keyword in can be swapped for = or ∈, which are all equivalent). Iterating a Dict yields key => value pairs that can be destructured directly in the loop header, as in for (k, v) in scores, and enumerate(collection) and zip(a, b) are the idiomatic ways to get indices or iterate two collections in lockstep without manual index bookkeeping.

A while loop repeats as long as its condition remains true, checked before each iteration, making it the right tool when the number of iterations isn't known in advance — for example, reading lines from a stream until EOF, or running a numerical solver until it converges within a tolerance: while abs(x_new - x_old) > tol ... end. Because the condition must eventually become false, it's easy to write an infinite loop by forgetting to update the loop variable inside the body.

break exits the innermost loop immediately, and continue skips the rest of the current iteration and moves to the next one — both work the same in for and while loops. A common pattern is searching a collection and breaking as soon as a match is found: for x in data; x == target && (found = true; break); end. Julia does not support labeled break/continue to jump out of an outer loop from within a nested one; instead, refactor the nested loops into a function and use return, or wrap the search in a helper.

Array and generator comprehensions are often the more idiomatic replacement for a simple accumulation loop: [x^2 for x in 1:10 if isodd(x)] builds a filtered, transformed array in one expression, and dropping the brackets for (x^2 for x in 1:10) creates a lazy generator that's iterated without materializing the full array — useful when feeding results directly into sum(...) or for without allocating memory for the intermediate collection.

Unlike Python, loops in Julia are compiled to fast machine code and are not something to avoid for performance — a hand-written for loop is often as fast as, or faster than, a vectorized one-liner, because Julia's JIT compiler specializes the loop body for the concrete types involved. The main performance pitfall is type instability: if a loop variable's type can change between iterations (e.g., starting an accumulator as total = 0 when the loop later adds Float64 values), the compiler can't infer a concrete type and falls back to slower, boxed operations — initializing total = 0.0 instead fixes it.