Posted on
• Advanced

Working with Arrays in Bash

Author
  • User
    Linux Bash
    Posts by this author
    Posts by this author

In Bash, arrays are a useful way to store multiple values in a single variable. Unlike other programming languages, Bash arrays are not fixed in size, and they can store values of different types (such as strings, numbers, or mixed types). Here's a comprehensive guide on working with arrays in Bash:

1. Declaring Arrays

There are two common ways to declare arrays in Bash:

1.1 Using Parentheses ()

You can declare an array and initialize it with values inside parentheses.

# Declare an array with values
my_array=("apple" "banana" "cherry")

# Print the array (will show all elements as a space-separated string)
echo "${my_array[@]}"  # Output: apple banana cherry

1.2 Empty Array

You can also create an empty array and populate it later.

# Declare an empty array
my_array=()

# Add elements one by one
my_array+=("apple")
my_array+=("banana")
my_array+=("cherry")

# Print the array
echo "${my_array[@]}"  # Output: apple banana cherry

2. Accessing Array Elements

Array elements are accessed by their index, which starts at 0. You can use ${array[index]} to access an individual element.

2.1 Access a Single Element

# Access the first element (index 0)
echo "${my_array[0]}"  # Output: apple

# Access the second element (index 1)
echo "${my_array[1]}"  # Output: banana

2.2 Access All Elements

To print all elements in the array, use ${array[@]}.

# Access all elements
echo "${my_array[@]}"  # Output: apple banana cherry

3. Array Length

You can get the length of an array using ${#array[@]} or ${#array[*]}.

# Get the length (number of elements) of the array
length=${#my_array[@]}
echo "Array length: $length"  # Output: 3

4. Array Indexing

Bash arrays are zero-indexed. You can directly reference an element using its index.

# Access the first element
echo "${my_array[0]}"  # Output: apple

# Access the second element
echo "${my_array[1]}"  # Output: banana

# Set a new value to an existing index
my_array[1]="blueberry"
echo "${my_array[1]}"  # Output: blueberry

5. Adding Elements to an Array

You can add elements to an array using the += operator.

# Add an element to the array
my_array+=("date")

# Print all elements
echo "${my_array[@]}"  # Output: apple blueberry cherry date

6. Removing Array Elements

To remove an array element, you can use the unset command, which will delete the element at the specified index.

# Remove the second element (index 1)
unset my_array[1]

# Print all elements after removal
echo "${my_array[@]}"  # Output: apple cherry date

Note that unset removes the element but does not "reindex" the array. The deleted element is still considered an index in the array. For example:

echo "${#my_array[@]}"  # Output: 4 (still counts the removed index)

7. Looping Through Arrays

You can loop through arrays using a for loop to iterate over all elements.

7.1 Looping Over Indices

for index in "${!my_array[@]}"; do
    echo "Index $index: ${my_array[$index]}"
done

7.2 Looping Over Values

for value in "${my_array[@]}"; do
    echo "$value"
done

8. Associative Arrays (Dictionaries)

Bash also supports associative arrays (also known as hash maps or dictionaries), where you can use strings as keys instead of integers.

8.1 Declaring an Associative Array

To declare an associative array, you need to use the declare -A syntax.

# Declare an associative array
declare -A fruits

# Add key-value pairs
fruits["apple"]="green"
fruits["banana"]="yellow"
fruits["cherry"]="red"

# Access a value using the key
echo "${fruits["banana"]}"  # Output: yellow

8.2 Accessing All Keys and Values

You can iterate over both keys and values in an associative array.

# Loop through keys and values
for key in "${!fruits[@]}"; do
    echo "$key is ${fruits[$key]}"
done

This will output:

apple is green
banana is yellow
cherry is red

9. Array Slicing

Bash doesn't have built-in support for slicing arrays directly like other languages (e.g., Python), but you can simulate it by using loops or parameter expansion.

9.1 Slicing with Parameter Expansion

You can access a subarray by specifying a range of indices.

# Get a subarray (from index 1 to 2)
echo "${my_array[@]:1:2}"  # Output: blueberry cherry

Here, ${my_array[@]:1:2} means "starting from index 1, get 2 elements."

9.2 Using Loops for Slicing

If you need more control over slicing, you can use a loop:

# Get a subarray from index 1 onwards
subarray=()
for i in "${my_array[@]:1}"; do
    subarray+=("$i")
done

echo "${subarray[@]}"  # Output: blueberry cherry date

10. Examples of Array Use Cases

10.1 List of Files

# Store all filenames in a directory in an array
files=($(ls))

# Print all file names
echo "${files[@]}"

10.2 Counting Occurrences

# Count occurrences of specific values in an array
count=0
for fruit in "${my_array[@]}"; do
    if [[ "$fruit" == "banana" ]]; then
        ((count++))
    fi
done

echo "Banana appears $count times."

10.3 Sorting an Array

You can sort an array using sort.

# Sort an array in alphabetical order
sorted=($(echo "${my_array[@]}" | tr ' ' '\n' | sort))

# Print the sorted array
echo "${sorted[@]}"  # Output: apple banana cherry

11. Summary of Array Operations in Bash

  • Declaring an array: my_array=("apple" "banana" "cherry")
  • Accessing elements: echo "${my_array[0]}" or echo "${my_array[@]}"
  • Adding elements: my_array+=("date")
  • Removing elements: unset my_array[1]
  • Array length: ${#my_array[@]}
  • Looping through arrays: for value in "${my_array[@]}"; do ... done
  • Associative arrays: declare -A my_dict and access via keys.
  • Array slicing: ${my_array[@]:start:length}

By mastering arrays in Bash, you can handle complex tasks efficiently and write more powerful scripts.

Related posts