Pass multiple arrays as arguments to a Bash script?

Charles Duffy's response works perfectly well, but I would go about it a different way that makes it simpler to initialize var1, var2 and var3 in your script:

./myScript.sh "${#array1[@]} ${#array2[@]} ${#array3[@]}" \
 "${array1[@]}" "${array2[@]}" "${array3[@]}"

Then in myScript.sh

#!/bin/bash
declare -ai lens=($1);
declare -a var1=("${@:2:lens[0]}") var2=("${@:2+lens[0]:lens[1]}") var3=("${@:2+lens[0]+lens[1]:lens[2]}");

Edit: Since Charles has simplified his solution, it is probably a better and more clear solution than mine.

Here is a code sample, which shows how to pass 2 arrays to a function. There is nothing more than in previous answers except it provides a full code example.

This is coded in bash 4.4.12, i.e. after bash 4.3 which would require a different coding approach. One array contains the texts to be colorized, and the other array contains the colors to be used for each of the text elements :

function cecho_multitext () {
  # usage : cecho_multitext message_array color_array
  # what it does : Multiple Colored-echo.

    local -n array_msgs=$1
    local -n array_colors=$2
    # printf '1: %q\n' "${array_msgs[@]}"
    # printf '2: %q\n' "${array_colors[@]}"


    local i=0
    local coloredstring=""
    local normalcoloredstring=""

    # check array counts
    # echo "msg size : "${#array_msgs[@]}
    # echo "col size : "${#array_colors[@]}

    [[ "${#array_msgs[@]}" -ne "${#array_colors[@]}" ]] && exit 2

    # build the colored string
    for msg in "${array_msgs[@]}"
    do
      color=${array_colors[$i]}
      coloredstring="$coloredstring $color $msg "
      normalcoloredstring="$normalcoloredstring $msg"
      # echo -e "coloredstring ($i): $coloredstring"
      i=$((i+1))
    done

    # DEBUG
    # echo -e "colored string : $coloredstring"
    # echo -e "normal color string : $normal $normalcoloredstring"

    # use either echo or printf as follows :
    # echo -e "$coloredstring"
    printf '%b\n' "${coloredstring}"

    return
}

Calling the function :

#!/bin/bash
green='\E[32m'
cyan='\E[36m'
white='\E[37m'
normal=$(tput sgr0)
declare -a text=("one" "two" "three" )
declare -a color=("$white" "$green" "$cyan")
cecho_multitext text color

Job done :-)

I do prefer using base64 to encode and decode arrays like:

encode_array(){
    local array=($@)
    echo -n "${array[@]}" | base64
} 
decode_array(){
    echo -n "$@" | base64 -d
}
some_func(){
    local arr1=($(decode_array $1))
    local arr2=($(decode_array $2))
    local arr3=($(decode_array $3))
    echo arr1 has ${#arr1[@]} items, the second item is ${arr1[2]} 
    echo arr2 has ${#arr2[@]} items, the third item is ${arr2[3]} 
    echo arr3 has ${#arr3[@]} items, the here the contents ${arr3[@]} 
}

a1=(ab cd ef)
a2=(gh ij kl nm)
a3=(op ql)
some_func "$(encode_array "${a1[@]}")" "$(encode_array "${a2[@]}")" "$(encode_array "${a3[@]}")"

The output is

arr1 has 3 items, the second item is cd
arr2 has 4 items, the third item is kl
arr3 has 2 items, the here the contents op ql

Anyway, that will not work with values that have tabs or spaces. If required, we need a more elaborated solution. something like:

encode_array()
{
        for item in "$@";
        do
                echo -n "$item" | base64
        done | paste -s -d , -
}

decode_array()
{
        local IFS=$'\2'

        local -a arr=($(echo "$1" | tr , "\n" |
                while read encoded_array_item;
                do 
                        echo  "$encoded_array_item" | base64 -d;
                        echo "$IFS"
                done))
        echo "${arr[*]}";
}

test_arrays_step1()
{
        local IFS=$'\2'
        local -a arr1=($(decode_array $1))
        local -a arr2=($(decode_array $2))
        local -a arr3=($(decode_array $3))
        unset IFS
        echo arr1 has ${#arr1[@]} items, the second item is ${arr1[1]} 
        echo arr2 has ${#arr2[@]} items, the third item is ${arr2[2]} 
        echo arr3 has ${#arr3[@]} items, the here the contents ${arr3[@]} 
}

test_arrays()
{
        local a1_2="$(echo -en "c\td")";
        local a1=("a b" "$a1_2" "e f");
        local a2=(gh ij kl nm);
        local a3=(op ql );
        a1_size=${#a1[@])};
        resp=$(test_arrays_step1 "$(encode_array "${a1[@]}")" "$(encode_array "${a2[@]}")" "$(encode_array "${a3[@]}")");
        echo -e "$resp" | grep arr1 | grep "arr1 has $a1_size, the second item is $a1_2" || echo but it should have only $a1_size items, with the second item as $a1_2
        echo "$resp"
}

Based on the answers to this question you could try the following.

Define the arrays as variable on the shell:

array1=(1 2 3)
array2=(3 4 5)
array3=(6 7 8)

Have a script like this:

arg1=("${!1}")
arg2=("${!2}")
arg3=("${!3}")


echo "arg1 array=${arg1[@]}"
echo "arg1 #elem=${#arg1[@]}"

echo "arg2 array=${arg2[@]}"
echo "arg2 #elem=${#arg2[@]}"

echo "arg3 array=${arg3[@]}"
echo "arg3 #elem=${#arg3[@]}"

And call it like this:

. ./test.sh "array1[@]" "array2[@]" "array3[@]"

Note that the script will need to be sourced (. or source) so that it is executed in the current shell environment and not a sub shell.