How to expand array content from its name?

Question

I have an array

declare -a arr0=("'1 2 3'" "'4 5 6'")

and a variable

x=0

Then I create the new variable with the array's name

tmp="arr$x"

and I'd like to be able to expand arr0 content from this tmp variable like this

newArr=( "${!tmp}" )

and to use newArr like the ordinary array, e.g. use indices etc.

---

But when I try print it now, it looks like this:

$ echo ${newArr[@]}
'1 2 3'

Only the first element is stored and I don't know, how to fix it.

I've also tried to create newArr like this

newArr=( "${!tmp[@]}" )

but then it's even worse - only 0 is printed.

$ echo ${newArr[@]}
0

---

So, do you know, how to use an array if its name is stored in some other variable?

Answer 1

It is possible with eval:

$ declare -a array=( 1 2 3 4 )
$ echo "${array[@]}"
1 2 3 4
$ p=ay
$ tmp=arr$p
$ echo "$tmp"
array
$ echo "\${${tmp}[@]}"
${array[@]}
$ echo "newarray=(\"\${${tmp}[@]}\")"
newarray=("${array[@]}")
$ eval "newarray=(\"\${${tmp}[@]}\")"
$ echo "${newarray[@]}"
1 2 3 4
$

Commands starting with echo are for illustration, eval is dangerous.

Note that the above doesn't preserve array indices for sparse arrays.

Answer 2

Indirect expansion has some exceptions, and using ! in arrays is one of the exceptions.

From man bash:

If the first character of parameter is an exclamation point (!), a level of variable indirection is introduced. Bash uses the value of the variable formed from the rest of parameter as the name of the variable; this variable is then expanded and that value is used in the rest of the substitution, rather than the value of parameter itself. This is known as indirect expansion.

The exceptions to this are the expansions of ${!prefix*} and ${!name[@]} described below. ${!prefix*} Names matching prefix. Expands to the names of variables whose names begin with prefix, separated by the first character of the IFS special variable.

As described in BASH FAQ06 , one workaround is like this:

arrA=("AA" "2" "4")
echo -e "array arrA contains: \c" && declare -p arrA
ref=arrA;
tmp=${ref}[@] #this can be adjusted to [1] , [2] etc to refer to particular array items
echo "Indirect Expansion Printing: ${!tmp}"

#Output
array arrA contains: declare -a arrA='([0]="AA" [1]="2" [2]="4")'
Indirect Expansion Printing: AA 2 4

Answer 3

bash 4.3 added support for ksh93-like namerefs.

So in bash-4.3 or above you can do:

a0[5]=whatever
x=0
typeset -n var="a$x"
printf '%s\n' "${var[5]}"

But note that's a reference (a pointer, not a copy) to the variable name, not the variable (the difference matters when you have several variables by the same name in different contexts like for local variables in functions).

bash copied ksh arrays with their awkward design. Making a copy of an array in bash is difficult, you can use a helper function like:

copy_array() { # Args: <src_array_name> <dst_array_name>
  eval '
    local i
    '"$2"'=()
    for i in "${!'"$1"'[@]}"; do
      '"$2"'[$i]=${'"$1"'[$i]}
    done'
}

To be used for instance as:

$ a0[5]=123
$ x=0
$ copy_array "a$x" var
$ typeset -p var
declare -a var=([5]="123")

ksh (and bash which copied ksh) is the only shell where arrays are sparse (or are associative arrays whose keys are limited to positive integers) (also the only arrays with indices starting at 0 instead of 1, or where $array unintuitively doesn't expand to the elements but the element of indice 0). It's a lot easier with other shells.

• rc: array_copy = $array
• fish: set array_copy = $array
• csh: set array_copy = ($array:q)
• zsh or yash: array_copy=("${array[@]}"}

For indirect copy (where $var contains the source array name):

• rc: eval array_copy = '$'$var
• fish: eval set array_copy \$$var
• csh: eval "set array_copy = (\$${var}:q)"
• zsh: array_copy=("${(@P)var}")
• yash (or zsh): eval 'array_copy=("${'"$var"'[@]}")'