Variable for array name within curly braces (passing or printing an array in bash)

Question

I have a code snippet to print out an array in a shell script:

for i in "${array[@]}"; do
   echo "$i"
   done
}

I wanted to create a function out of it

printArray() {
    for i in "${$1[@]}"; do
      echo "$i"
      done
}

but when I call my function with the array name (which is also available in the shell script), I get an error: ${$1[@]}: bad substitution

What I found out ist that curly braces expand first, probably trying to expand "$1[@]" literally.

I only found answers for numeric expansion like from 1 to 5. So is it possible to replace an array name with a variable inside curly braces?

I expect to be able to put a variable instead of a specific array name in my function.

Answer 1

You can make use of the nameref attribute (introduced with version 4.3 of bash) using the -n option to the declare or local builtin commands to accomplish this job:

#!/bin/bash

printArray() {
    if [[ $1 != 'aref' ]]; then
        local -n aref=$1 || return
    fi
    printf '%s\n' "${aref[@]}"
}

echo '*** array=( -n -e -E ); printArray array ***'
array=( -n -e -E ); printArray array

echo '*** aref=( 8 9 10 ); printArray aref ***'
aref=( 8 9 10 ); printArray aref

echo '*** i=( 8 9 10 ); printArray i; declare -p i ***'
i=( 8 9 10 ); printArray i; declare -p i

Search for nameref in the Bash Reference Manual.

Answer 2

Here's how I pass and print bash arrays:

Print a bash array by passing parameters by value

arrays_join_and_print.sh from my eRCaGuy_hello_world repo:

Update: even better, see: array_print.sh now, which I just wrote. Sourcing (importing) array_print.sh via . array_print.sh gives you direct access to my two print functions below.

# Function to print all elements of an array.
# Example usage, where `my_array` is a bash array:
#       my_array=()
#       my_array+=("one")
#       my_array+=("two")
#       my_array+=("three")
#       print_array "${my_array[@]}"
print_array() {
    for element in "$@"; do
        printf "    %s\n" "$element"
    done
}

# Usage

# Build an array
array1=()
array1+=("one")
array1+=("two")
array1+=("three")

# Print it
echo "array1:"
print_array "${array1[@]}"

Sample output:

array1:
    one
    two
    three

Print a bash array by passing the array by reference

print_array2() {
    # declare a local **reference variable** (hence `-n`) named `array_ref`
    # which is a reference to the first parameter passed in
    local -n array_ref="$1"

    for element in "${array_ref[@]}"; do
        printf "    %s\n" "$element"
    done
}

# Usage

print_array2 "array1"
# or
print_array2 array1

Output: same as above.

Going further:

For passing arrays as parameters in Bash, I present 3 solutions which can also be used for printing arrays:

1. [my favorite] Pass arrays by reference (regular arrays and associative bash arrays)
2. Manually serialize and deserialize arrays
3. For associative arrays: pass by reference and manually serialize/deserialize

Answer 3

I posted my code in the following shell check: https://www.shellcheck.net/

And it gave me the following answer: https://www.shellcheck.net/wiki/SC2082

# Expand variable names dynamically
var_1="hello world"
n=1
name="var_$n"
echo "${!name}"

So I first expanded array name and then put it with an exclamation mark in curly braces. After this the error disappeared and the array got printed out.

printArray() {
    array="$1[@]"
    for i in "${!array}"; do
      echo "$i"
    done
}

Answer 4

This Shellcheck-clean code should work with any version of Bash:

#! /bin/bash -p

printArray() {
    [[ -z ${1-} || $1 == [[:digit:]]* || $1 == *[^[:alnum:]_]* ]] && return 1
    set -- "$1[@]"
    if [[ -o nounset ]]; then
        set +o nounset
        set -- "${!1}"
        set -o nounset
    else
        set -- "${!1}"
    fi
    (( $# == 0 )) || printf '%s\n' "$@"
}

• To avoid variable name clashes, the function uses no variables except for the positional parameters ($1, $2, ...).
• [[ -z ${1-} || $1 == [[:digit:]]* || $1 == *[^[:alnum:]_]* ]] && return 1 ensures that the argument ($1) is a valid variable name. This is necessary because several Bash mechanisms for accessing variables through other variables (including indirect expansion, namerefs, and eval) can cause code injection if they are used with invalid variable names.
• set -- "$1[@]" replaces the first positional parameter ($1) (e.g. arrname) with a string that can be used with indirect expansion to expand to the list of elements in an array (e.g. arrname[@]).
• set -- "${!1}" replaces the positional parameters with the elements of the array.
• The code relating to nounset is necessary because of a long-standing bug in Bash. Using set -o nounset (or set -u) in Bash code causes it to treat accesses to unset variables as errors. Some people and teams do that for all Bash programs because it can help to avoid bugs due to uninitialized variables. However, the feature has historically caused problems for code that uses arrays because Bash, incorrectly, treats empty arrays as uninitialized variables in some contexts. Most of the problems were fixed with Bash 4.4, but I've found that they persist with indirect expansions even in Bash 5. set -- "${!1}" causes an error if the referenced array is empty and nounset is enabled. The code works around the problem by disabling nounset before doing the expansion and re-enabling it afterwards, if it was enabled already.
• Finally, the codes uses printf to print all of the positional parameters, one-per-line. The (( $# == 0 )) test is necessary to prevent a blank line being printed if the array is empty (and so there are no positional parameters).

WARNING

Although I think the function above is very robust, I don't think that it is useful. The output of the function may not give you an accurate representation of what is in the array. For instance, it will print the same output for both of these arrays: array=(1 2 3) (3 elements), and array=($'1\n2\n3') (1 element).

Bash has a built-in mechanism for printing array contents in an unambiguous way: declare -p arrname. I would always use that instead of an array-printing function.