In a bash script, `n=5; for i in {1..$n}; do echo "$i"; done` prints `{1..5}` instead of the numbers 1 through 5. Why does that happen, and which loop forms do iterate a variable number of times?

## Why the braces do not expand Bash expands a word in a fixed order, and brace expansion comes first — before parameter expansion, command substitution, arithmetic expansion, word splitting and pathname expansion. When bash looks at `{1..$n}` it is deciding whether the braces contain a valid sequence, and all it can see there is `1..$n`. `$n` is not a number at that point (the expansion that would turn it into one has not run yet), so the construct is not a range, and bash leaves the whole word untouched. Parameter expansion then does its job and turns the surviving text into `{1..5}` — a single ordinary word, which the `for` loop faithfully iterates over exactly once. The same explanation covers why `{1..5}` with literal numbers works fine: everything the expansion needs is present at the time it runs. ```bash echo {1..3} # 1 2 3 n=3; echo {1..$n} # {1..3} <- one word, not three ``` ## Form 1: the C-style loop ```bash for ((i = 1; i <= n; i++)); do echo "$i" done ``` The three parts inside `(( ))` are arithmetic expressions, evaluated once at the start, before every iteration, and after every iteration respectively. Because they are evaluated each time round rather than expanded once into a list, a variable bound is exactly what they are for. Inside an arithmetic context a bare name is read as a variable, which is why `i <= n` works without a `$` — though writing `$n` there is also legal and harmless. This form is a bash and ksh extension; it is not in POSIX, so it does not work in a `#!/bin/sh` script running under dash. Use it whenever you have decided the script is a bash script. ## Form 2: `seq` ```bash for i in $(seq 1 "$n"); do echo "$i" done ``` `seq` is an external program, not a builtin, and not specified by POSIX either — though it is present on GNU and BSD systems including macOS. It forks a process per loop, which is irrelevant for small counts and wasteful for large ones. The unquoted substitution is safe here only because the output is digits and newlines; the word-splitting hazards that make `$(ls)` dangerous do not bite on integers. `seq` earns its place when you need a step or formatting that arithmetic would make ugly, for example `seq -w 1 10` for zero-padded values. ## Form 3: `while` with an arithmetic condition ```bash i=1 while ((i <= n)); do echo "$i" i=$((i + 1)) done ``` Useful when the increment is not uniform, or when the loop variable is advanced from inside the body based on data. Note one trap that bites strict-mode scripts here: `((expr))` returns exit status 1 when the expression evaluates to zero, so `((i++))` with `i` at 0 returns a failure status that can terminate a script running under `set -e`. ## Ranges with literal bounds When the bounds really are constants, braces are the clearest option and support a step in bash 4.0 and later: `{0..20..5}` gives `0 5 10 15 20`, and `{a..e}` gives letters. Zero padding works too — `{01..12}` produces `01 02 ... 12`, which is handy for month or day directories. ## What not to do `eval "for i in {1..$n}"` does technically work, because the string is re-parsed after `$n` has been substituted, so brace expansion gets a second chance at a now-literal range. It is still the wrong answer in an interview and in review: it re-parses data as code, so if `n` ever comes from a caller or a file you have handed that caller a shell injection. There are two clean forms that need no re-parsing; use one of them.