How to create a dynamic number of arrays with dynamic names in bash?

How to Dynamically Create Named Arrays in Bash

Hello, fellow Bash enthusiasts! Today, I want to share a handy method for those looking to dynamically create and manage multiple arrays in Bash. This is particularly useful when dealing with data that needs to be split into structured parts for better manipulation and access. Let’s dive right in!

The Challenge:

Suppose you have an array with a variable number of elements, and your goal is to split this array into multiple new arrays, each containing a fixed number of elements. For example, you might start with an array like this:

dec_array=(abc10 def2 ghi333 jkl mno51 pqr_6)

And you want to split dec_array into multiple arrays, each holding, say, three elements (or any other fixed number).

The Problem:

When you try to dynamically create arrays within a loop using names like dyn_array_0, dyn_array_1, etc., you might run into syntax issues as Bash does not support creating dynamic variable names directly in a straightforward way.

The Solution:

To overcome this, we can use associative arrays (supported in Bash version 4 and above) or simulate the effect using indirect references. Here’s how you can do it using indirect references:

declare -a dec_array=(abc10 def2 ghi333 jkl mno51 pqr_6)
num_elem=3
num_arr=0

for ((i=0; i < ${#dec_array[@]}; i+=num_elem)); do
    # Create a string representing the array name
    array_name="dyn_array_$num_arr"
    # Use indirection to declare and assign elements to the dynamic array
    declare -a "${array_name}=( ${dec_array[@]:i:num_elem} )"
    # Increment the array counter
    ((num_arr++))
done

# To access elements, use indirect reference again
for ((j=0; j < num_arr; j++)); do
    array_name="dyn_array_$j"
    echo "Elements in ${array_name}: ${!array_name[*]}"
done

Explanation:

1. Initialization: We start by declaring the initial array and setting parameters for how many elements each new array will contain.

1. Loop to Split Array: We loop through the original array, slicing it into parts and assigning these parts to new array names constructed dynamically.

1. Using Indirect Reference: The magic happens with ${!array_name[*]}, which allows us to expand the array elements dynamically named by array_name.

Output:

This script will output:

“`

Elements in dyn_array_0: abc10 def2 ghi333

Elements in dyn_array_1: jkl mno51 pqr_6

“`

Conclusion:

Bash scripts offer a lot of flexibility to manipulate data in complex ways. While Bash does not natively support dynamic variable names as some other languages do, with a little creativity (like using indirect references), you can achieve similar functionality. This approach is particularly useful in scenarios where the structure of your data isn’t known in advance and needs to be dynamically allocated.

Happy scripting! Whether you’re automating tasks, managing servers, or just experimenting, Bash provides the tools you need to get the job done.