Indexed Arrays

## What an indexed array is An indexed array in bash is a variable that holds many values, each stored under an integer subscript starting at 0. It is the only built-in way to hold a list whose items may contain spaces, tabs or newlines: a plain string variable holding `a b c` is one value that only *looks* like three, and the shell will happily re-split it in ways you did not intend. ## Creating one The compound assignment is a parenthesised list of words: ```bash arr=(alpha "beta gamma" delta) ``` The words inside the parentheses go through the normal expansions, so quoting matters exactly as it does on a command line. `"beta gamma"` is one element; without the quotes it would be two. That gives three elements at indices 0, 1 and 2. You can also assign a single slot directly, `arr[7]=eta`, and bash will create the array for you. `declare -a arr` declares an empty indexed array explicitly, which is useful when a later `+=` is the first thing that touches it. ## Reading one element ```bash echo "${arr[1]}" # beta gamma ``` The braces are not optional. In `$arr[0]`, bash sees the parameter name `arr`, expands it, and leaves `[0]` as literal text, so you get `alpha[0]`. Any time a subscript is involved, the whole thing goes inside `${ }`. The subscript itself is an arithmetic context, so `${arr[i]}` works with a bare variable name and `${arr[n+1]}` does arithmetic. Bash 4.3 and later also accept negative subscripts, where `${arr[-1]}` is the last element. ## Length, count and indices Two expansions look almost identical and mean different things: ```bash echo "${#arr[@]}" # 3 -> number of elements echo "${#arr}" # 5 -> characters in ${arr[0]}, i.e. "alpha" echo "${#arr[1]}" # 10 -> characters in "beta gamma" ``` `${!arr[@]}` lists the subscripts that actually exist, which is the reliable way to iterate when the array has gaps. `${arr[@]:1:2}` is a slice of two elements starting at offset 1; `${arr[@]:1}` takes everything from offset 1 onward. ## Appending ```bash arr+=(epsilon zeta) ``` The `+=` compound assignment appends after the highest existing index — it does not overwrite and it does not care that earlier indices may be missing. This is the idiom for building a list in a loop, one `arr+=("$item")` per iteration, with the item quoted so a value containing spaces stays a single element. ## Why bare $arr is the first element Bash defines a bare array name without a subscript as equivalent to subscript 0. So `echo $arr` prints `alpha` and `arr=x` silently overwrites element 0 while leaving the rest of the array in place. There is no syntax that turns the whole array into a value except `${arr[@]}` and `${arr[*]}`, and in practice you almost always want the quoted `"${arr[@]}"`, which produces one word per element with the contents untouched. The same asymmetry explains why `${#arr}` counts characters: with no subscript, bash is measuring the string in element 0, exactly as it would for any ordinary variable. ## Inspecting what you actually have When an array is behaving oddly, print its real structure instead of guessing: ```bash declare -p arr # declare -a arr=([0]="alpha" [1]="beta gamma" [2]="delta") ``` This shows the element boundaries and the actual subscripts, which is far more informative than `echo`, where the boundaries are invisible. `printf '[%s]\n' "${arr[@]}"` is the quick equivalent: one bracketed line per element makes a stray empty element or an accidentally-merged pair obvious. ## Practical habits Quote on assignment (`arr+=("$line")`), quote on expansion (`"${arr[@]}"`), use `${#arr[@]}` for counts, and reach for `declare -p` when debugging. Those four habits cover nearly everything a script does with a list.