Indexed arrays: create, slice and loop

A plain variable holds one string, so four file names crammed into it, one of them two words, come apart into five once the shell splits the value. An indexed arrayindexed array: A Bash variable that holds many values at once, each under a whole-number subscript counting from 0; written a=(one two) and read with ${a[i]}. dash has no arrays. keeps them as four values instead, each whole under a number called its subscriptarray subscript: The part in brackets that selects one element, as in a[i]; in an indexed array Bash evaluates it as an arithmetic expression, and from Bash 4.2 a negative value counts back from the last element., counting from 0, so a=(zero one "two words" three) has exactly four elements and two words stays one of them.

You will build arrays and read, append to and slice their elements, reach them from the end with negative subscripts, loop over the values or over the indices, work out the gaps that unset leaves, and see why the same array a shell script relies on makes dash stop with a syntax error.

Create an array and read an element by its index

Write the elements in parentheses, and Bash numbers them from 0. Read one back by putting its subscript in braces, ask how many there are with ${#a[@]}, and take a run of them with a slice. The session builds an array, changes it and reads it four ways:

from session import run

run("""
# Build an array: the words are kept in order, starting at index 0.
a=(zero one "two words" three)
echo "${a[2]}"
echo "count: ${#a[@]}"
# Assign one element by its index, leaving a gap at index 4.
a[5]=five
# Append to the end with += (Bash 3.1 and later).
a+=(six)
echo "all: ${a[*]}"
echo "indices: ${!a[@]}"
echo "a slice of two: ${a[@]:1:2}"
""")

# Build an array: the words are kept in order, starting at index 0.
$ a=(zero one "two words" three)
$ echo "${a[2]}"
two words
$ echo "count: ${#a[@]}"
count: 4
# Assign one element by its index, leaving a gap at index 4.
$ a[5]=five
# Append to the end with += (Bash 3.1 and later).
$ a+=(six)
$ echo "all: ${a[*]}"
all: zero one two words three five six
$ echo "indices: ${!a[@]}"
indices: 0 1 2 3 5 6
$ echo "a slice of two: ${a[@]:1:2}"
a slice of two: one two words

${a[2]} is the third element, two words, kept as one value; ${#a[@]} counts the elements, 4 here (the word-splitting lesson introduced both "${a[@]}" and ${#a[@]}). Assigning a[5]=five put a value at index 5 and left nothing at index 4, and a+=(six) added one after the last element, so the set indices became 0 1 2 3 5 6. The slice ${a[@]:1:2} copied two elements from index 1. The braces matter: $a[2] is not an array read at all, but $a (the element at index 0) followed by the plain text [2]. A bare $a or ${a} always means ${a[0]}, the first element, which surprises a script that meant the whole list.

Slices copy a run of elements, so a queue can rotate

A slice, ${a[@]:start:count}, copies count elements starting at index start; drop the :count and it takes every element from start to the end. Because a slice returns a run of elements that you can drop back into a new array, slices are how a list behaves like a work queue. Read queue.sh first:

#!/usr/bin/env bash
# queue.sh: move jobs through a small work queue using slices.
queue=(build test lint deploy)

# Rotate: the first job goes to the back of the queue.
queue=("${queue[@]:1}" "${queue[0]}")
echo "after rotate: ${queue[*]}"

# Remove the job at index 1, then renumber so there is no gap.
unset 'queue[1]'
queue=("${queue[@]}")
echo "after remove: ${queue[*]}"

# Insert "scan" so it becomes the new index 1.
queue=("${queue[@]:0:1}" scan "${queue[@]:1}")
echo "after insert: ${queue[*]}"

declare -p queue

Each line rebuilds queue from slices of itself. Rotating moves the first job to the back; removing drops index 1 and rebuilds so there is no gap; inserting splices a new job between two slices. The session runs it, after ShellCheck confirms the quoting is sound:

from session import run, files

files("queue.sh")

run("""
# ShellCheck is happy with the quoted expansions in queue.sh.
shellcheck queue.sh && echo "shellcheck: clean"
bash queue.sh
""")

# ShellCheck is happy with the quoted expansions in queue.sh.
$ shellcheck queue.sh && echo "shellcheck: clean"
shellcheck: clean
$ bash queue.sh
after rotate: test lint deploy build
after remove: test deploy build
after insert: test scan deploy build
declare -a queue=([0]="test" [1]="scan" [2]="deploy" [3]="build")

The jobs rotate from build test lint deploy to test lint deploy build, lose lint, then gain scan at index 1. The last line is declare -p queue, which prints an array exactly as you would type it, every index and value, so it is the honest way to see what an array really holds.

Negative subscripts count back from the last element

You rarely know the last index of an array, so Bash lets a negative subscript count back from the end: ${a[-1]} is the last element and ${a[-2]} the one before it. Reading this way has worked since Bash 4.2, and assigning through a negative subscript since Bash 4.3, both recorded in the Bash NEWS file. The session reads, then assigns, then tries the same thing on the Bash that ships with macOS:

from session import run

run("""
a=(mon tue wed thu fri)
# -1 is the last element, -2 the one before it (reading, Bash 4.2 and later).
echo "last: ${a[-1]}"
echo "second last: ${a[-2]}"
# Assigning through a negative subscript changes the last element (Bash 4.3 and later).
a[-1]=sat
echo "now: ${a[*]}"
# macOS ships Bash 3.2, which has no negative subscripts:
/bin/bash --version | head -1
/bin/bash -c 'a=(mon tue wed); echo "[${a[-1]}]"'
""")

$ a=(mon tue wed thu fri)
# -1 is the last element, -2 the one before it (reading, Bash 4.2 and later).
$ echo "last: ${a[-1]}"
last: fri
$ echo "second last: ${a[-2]}"
second last: thu
# Assigning through a negative subscript changes the last element (Bash 4.3 and later).
$ a[-1]=sat
$ echo "now: ${a[*]}"
now: mon tue wed thu sat
# macOS ships Bash 3.2, which has no negative subscripts:
$ /bin/bash --version | head -1
GNU bash, version 3.2.57(1)-release (arm64-apple-darwin25)
$ /bin/bash -c 'a=(mon tue wed); echo "[${a[-1]}]"'
/bin/bash: a: bad array subscript
[]

In Bash 5.3 ${a[-1]} gave fri and a[-1]=sat replaced the last element. The /bin/bash of macOS is 3.2.57, older than the feature, and there ${a[-1]} printed a: bad array subscript on standard error and expanded to nothing. Assigning to a far index, such as a[9]=late, is allowed too and leaves every index in between unset, another way an array becomes sparse.

Loop over values, or over indices when the array is sparse

To work through every element, loop over the values with for dir in "${a[@]}", the quoted form the for-loops lesson used so that each element arrives whole. When you need the position of each element, loop over the indices instead: ${!a[@]} expands to the subscripts that are set, and for i in "${!a[@]}" hands them over one at a time. The two loops matter because unset can leave an array sparsesparse array: An indexed array whose set subscripts are not contiguous, usually because unset removed an element without renumbering, so its indices have a gap such as 0 2 3.: a hole where an element used to be. Step through one array as it gains, loses and renumbers elements:

unset 'a[1]' removed the element but not its slot, so the set indices became 0 2 3 rather than 0 1 2, and only a copy through "${a[@]}" closed the gap. sparse.sh shows both loops over such an array, and ends with the copy:

#!/usr/bin/env bash
# sparse.sh: unsetting elements leaves gaps; a copy renumbers them.
a=(north east south west)

# Remove the element at index 1. Quote the subscript (see the lesson).
unset 'a[1]'

echo "values: ${a[*]}"
echo "indices: ${!a[*]}"

# Loop over the values: gaps do not matter, each value comes once.
for dir in "${a[@]}"; do
  echo "value $dir"
done

# Loop over the indices when you need the position, gaps and all.
for i in "${!a[@]}"; do
  echo "index $i holds ${a[i]}"
done

# A copy through "${a[@]}" renumbers the elements from 0.
b=("${a[@]}")
declare -p b

from session import run, files

files("sparse.sh")

run("""
bash sparse.sh
# The glob trap: an unquoted subscript can be read as a filename pattern.
touch a1
a=(zero one two three)
# a[1] is a glob here: it matches the file a1, so unset deletes a variable named a1.
unset a[1]
echo "unquoted left: ${!a[@]}"
# Quote the subscript, and unset removes element 1 of the array.
unset 'a[1]'
echo "quoted left: ${!a[@]}"
""")

$ bash sparse.sh
values: north south west
indices: 0 2 3
value north
value south
value west
index 0 holds north
index 2 holds south
index 3 holds west
declare -a b=([0]="north" [1]="south" [2]="west")
# The glob trap: an unquoted subscript can be read as a filename pattern.
$ touch a1
$ a=(zero one two three)
# a[1] is a glob here: it matches the file a1, so unset deletes a variable named a1.
$ unset a[1]
$ echo "unquoted left: ${!a[@]}"
unquoted left: 0 1 2 3
# Quote the subscript, and unset removes element 1 of the array.
$ unset 'a[1]'
$ echo "quoted left: ${!a[@]}"
quoted left: 0 2 3

Looping over the values printed north south west with no empty pass, while looping over the indices reported 0, 2 and 3, the real positions. The copy b=("${a[@]}") renumbered the three values to 0 1 2, which declare -p b confirmed.

With the subscript quoted, the two loops and the renumbering copy above are all you need to walk a sparse array and then pack it again.

Arrays are a Bash feature, and quotes decide how they expand

Two subscripts expand every element, @ and *, and inside double quotes they differ. "${a[@]}" gives one word per element, each whole; "${a[*]}" joins them into a single word with the first character of IFSIFS: The internal field separator: the characters Bash splits unquoted expansions on and read splits lines on; by default a space, a tab and a newline. More in “Word splitting and IFS: why "$var" needs quotes” between them, the comma below. Leaving the quotes off invites the word splittingword splitting: The step in which Bash cuts the unquoted results of parameter expansion, command substitution and arithmetic expansion into separate words at the characters of IFS. More in “Word splitting and IFS: why "$var" needs quotes” and globbing that ShellCheck warns about as SC2068. All of this is a Bash feature: the POSIX shell dash has no arrays at all. When an array has no elements, "${a[@]}" expands to nothing, so a command given it as arguments simply receives none.

from session import run, write

write("report.sh", '#!/usr/bin/env bash\nfiles=(one "two words" three)\nfor f in ${files[@]}; do echo "$f"; done\n')
write("list.sh", '#!/bin/sh\nx=(foo bar)\necho "${x[0]}"\n')

run("""
a=(north east south west)
# "${a[*]}" joins the elements with the first character of IFS; "${a[@]}" keeps each whole.
IFS=,
echo "star: ${a[*]}"
printf 'at: %s\\n' "${a[@]}"
unset IFS
# ShellCheck flags the unquoted ${files[@]} loop in report.sh as SC2068.
!shellcheck report.sh
# dash has no arrays at all.
!dash -c 'a=(north east south)'
# In a #!/bin/sh script ShellCheck warns with SC3030.
!shellcheck list.sh
""")

$ a=(north east south west)
# "${a[*]}" joins the elements with the first character of IFS; "${a[@]}" keeps each whole.
$ IFS=,
$ echo "star: ${a[*]}"
star: north,east,south,west
$ printf 'at: %s\n' "${a[@]}"
at: north
at: east
at: south
at: west
$ unset IFS
# ShellCheck flags the unquoted ${files[@]} loop in report.sh as SC2068.
$ shellcheck report.sh

In report.sh line 3:
for f in ${files[@]}; do echo "$f"; done
         ^---------^ SC2068 (error): Double quote array expansions to avoid re-splitting elements.

For more information:
  https://www.shellcheck.net/wiki/SC2068 -- Double quote array expansions to ...
[exit status 1]
# dash has no arrays at all.
$ dash -c 'a=(north east south)'
dash: 1: Syntax error: "(" unexpected
[exit status 2]
# In a #!/bin/sh script ShellCheck warns with SC3030.
$ shellcheck list.sh

In list.sh line 2:
x=(foo bar)
  ^-------^ SC3030 (warning): In POSIX sh, arrays are undefined.


In list.sh line 3:
echo "${x[0]}"
      ^-----^ SC3054 (warning): In POSIX sh, array references are undefined.

For more information:
  https://www.shellcheck.net/wiki/SC3030 -- In POSIX sh, arrays are undefined.
  https://www.shellcheck.net/wiki/SC3054 -- In POSIX sh, array references are...
[exit status 1]

With IFS=, the star form gave the single word north,east,south,west, while the at form gave four separate words. ShellCheck flagged the unquoted ${files[@]} as SC2068, an error, and in a #!/bin/sh script it warned about the array as SC3030 and about reading an element as SC3054. dash itself stopped at the opening parenthesis with Syntax error: "(" unexpected, which is why a script that uses arrays needs a Bash shebang, not #!/bin/sh.

Practise: arrays that keep their shape

Write two functions that change an array in place through a namerefnameref: A variable made with declare -n or local -n that stands for another variable, so every use of it reads or changes the variable it names. More in “Indirection, namerefs and ${var@Q} transforms” (local -n, from the namerefs lesson): rotate_left ARRAYNAME N, which moves the first N elements to the back, and remove_value ARRAYNAME VALUE, which drops every element equal to VALUE and renumbers the rest. Test them in your own shell and check the declare -p lines: tasks=(build test lint deploy ship) then rotate_left tasks 2 must give declare -a tasks=([0]="lint" [1]="deploy" [2]="ship" [3]="build" [4]="test"), and servers=(web1 db1 web2 db1 cache1) then remove_value servers db1 must give declare -a servers=([0]="web1" [1]="web2" [2]="cache1"). The self-check below puts these ideas onto arrays you have not met here:

Interview questions

Warm-up (fresher to 2–5 years): what does ${!a[@]} expand to, and when is it not simply 0 to n − 1?

${!a[@]} expands to the subscripts that currently have a value, in increasing order, not the values themselves. For an array built in one go, such as a=(zero one two three), those indices are exactly 0 1 2 3, the same as 0 to n − 1 for n elements, so looping over "${!a[@]}" and counting 0 to ${#a[@]} - 1 agree. They stop agreeing as soon as the array is sparse: after unset 'a[1]' the indices are 0 2 3, three elements but highest index 3, and b[9]=x on a new array b leaves a single element, at index 9. Whenever an array may have gaps, loop over "${!a[@]}" to get the real positions rather than assuming a contiguous 0 to n − 1.

The questions below go further: a job loop that stops halfway once it starts removing finished entries, and a last-element read that has to give the right answer on three Bash versions at once. Settle on an answer to each yourself first:

Key takeaways

• An indexed array keeps many values under subscripts counting from 0; ${a[2]} reads one, ${#a[@]} counts them, a+=(x) appends, and ${a[@]:start:count} slices a run of elements.
• Negative subscripts count back from the end, ${a[-1]} being the last element: reading works from Bash 4.2 and assigning from 4.3, but macOS Bash 3.2 answers bad array subscript.
• unset 'a[i]' leaves a sparse array whose set indices have a gap; "${!a[@]}" lists those indices, and a copy b=("${a[@]}") renumbers the elements from 0.
• Quote the subscript in unset 'a[i]' so [i] cannot act as a glob pattern that matches a file name.
• "${a[@]}" expands to one word per element and "${a[*]}" joins them with the first character of IFS; arrays are a Bash feature, so dash rejects them and ShellCheck flags them as SC3030 in a #!/bin/sh script.