How to copy an array in Bash?

a=(foo bar "foo 1" "bar two")  #create an array
b=("${a[@]}")                  #copy the array in another one 

for value in "${b[@]}" ; do    #print the new array 
echo "$value" 
done   

The simplest way to copy a non-associative array in bash is to:

arrayClone=("${oldArray[@]}")

or to add elements to a preexistent array:

someArray+=("${oldArray[@]}")

Newlines/spaces/IFS in the elements will be preserved.

For copying associative arrays, Isaac's solutions work great.

The solutions given in the other answers won't work for associative arrays, or for arrays with non-contiguous indices. Here are is a more general solution:

declare -A arr=([this]=hello [\'that\']=world [theother]='and "goodbye"!')
temp=$(declare -p arr)
eval "${temp/arr=/newarr=}"

diff <(echo "$temp") <(declare -p newarr | sed 's/newarr=/arr=/')
# no output

And another:

declare -A arr=([this]=hello [\'that\']=world [theother]='and "goodbye"!')
declare -A newarr
for idx in "${!arr[@]}"; do
    newarr[$idx]=${arr[$idx]}
done

diff <(echo "$temp") <(declare -p newarr | sed 's/newarr=/arr=/')
# no output

Try this: arrayClone=("${oldArray[@]}")

This works easily.

You can copy an array by inserting the elements of the first array into the copy by specifying the index:

#!/bin/bash

array=( One Two Three Go! );
array_copy( );

let j=0;
for (( i=0; i<${#array[@]}; i++)
do
    if [[ $i -ne 1 ]]; then # change the test here to your 'isn't installed' test
        array_copy[$j]="${array[$i]}
        let i+=1;
    fi
done

for k in "${array_copy[@]}"; do
    echo $k
done

The output of this would be:

One
Three
Go!

A useful document on bash arrays is on TLDP.

array_copy() {
    set -- "$(declare -p $1)" "$2"
    eval "$2=${1#*=}"
}

# Usage examples:

these=(apple banana catalog dormant eagle fruit goose hat icicle)
array_copy these those
declare -p those

declare -A src dest
source=(["It's a 15\" spike"]="and it's 1\" thick" [foo]=bar [baz]=qux)
array_copy src dest
declare -p dest

Note: when copying associative arrays, the destination must already exist as an associative array. If not, array_copy() will create it as a standard array and try to interpret the key names from the associative source as arithmetic variable names, with ugly results.

Isaac Schwabacher's solution is more robust in this regard, but it can't be tidily wrapped up in a function because its eval step evaluates an entire declare statement and bash treats those as equivalent to local when they're inside a function. This could be worked around by wedging the -g option into the evaluated declare but that might give the destination array more scope than it's supposed to have. Better, I think, to have array_copy() perform only the actual copy into an explicitly scoped destination.

Problem is to copy array in function to be visible in parent code. This solution works for indexed arrays and if before copying are predefined as declare -A ARRAY, works also for associative arrays.

function array_copy
# $1 original array name
# $2 new array name with the same content
{
    local INDEX
    eval "
        for INDEX in \"\${!$1[@]}\"
        do
            $2[\"\$INDEX\"]=\"\${$1[\$INDEX]}\"
        done
    "
}

Starting with Bash 4.3, you can do this

$ alpha=(bravo charlie 'delta  3' '' foxtrot)

$ declare -n golf=alpha

$ echo "${golf[2]}"
delta  3

Managed to copy an array into another.

firstArray=()
secondArray=()

firstArray+=("Element1")
firstArray+=("Element2")

secondArray+=("${firstArray[@]}")

for element in "${secondArray[@]}"; do
  echo "${element}"
done

Isaac's solution (with declare -p) is quite good, but it has an unnecessary subshell. We can use an obscure bash feature to avoid that:

declare -A arr=([this]=hello [\'that\']=world [theother]='and "goodbye"!')
temp="${arr[@]@A}"
eval "${temp/arr=/newarr=}"

If one wanted to avoid eval, it's also possible to do it like this:

declare -A arr=([this]=hello [\'that\']=world [theother]='and "goodbye"!')
temp="${arr[@]@A}"
declare -A newarr="${temp#*=}"

This has the advantage of making it easier to add more flags to the declare, such as -g.

If you do not want to hardcode the fact that the array is associative, you can do the following:

declare -A arr=([this]=hello [\'that\']=world [theother]='and "goodbye"!')
temp="${arr[@]@A}"
declare -${arr@a} newarr="${temp#*=}"

I'm going to one-up this and add indirection with a sweet, safe and, simple solution as long as you have a recent enough version of bash:

eval "$varname=("${srcarr[@]@Q}")"

If you want this as a safe shell, general-purpose function then it gets a little more complicated as you should first check for a valid variable name

# Meets IEEE 1003.1-2017 §3.235 Name
is_posix_name() {
    local LC_CTYPE=POSIX
    for n in "$@"; do
        case "$n" in ""|[0-9]*|*[!A-Za-z0-9_]*) return 1;; esac
    done
}

copyarr() {
    local dest="$1"
    is_posix_name || {
        printf "Invalid variable name '%s\n" "$dest" >2
        return 1
    }
    shift
    eval "$dest=("${@@Q}")"
}

src=("jack and" "jill went up" the hill)
copyarr mycopy "${src[@]}"

I've found that this works for me (mostly :)) ...

eval $(declare -p base | sed "s,base,target,")

extending the sed command to edit any switches as necessary e.g. if the new structure has to be writeable, to edit out read-only (-r).