如何将数组参数传递给 Bash 脚本

Question

It is surprising me that I do not find the answer after 1 hour search for this. I would like to pass an array to my script like this:

test.sh argument1 array argument2

I DO NOT want to put this in another bash script like following:

array=(a b c)
for i in "${array[@]}"
do
  test.sh argument1 $i argument2
done

Answer 1

Bash arrays are not "first class values" -- you can't pass them around like one "thing".

Assuming test.sh is a bash script, I would do

#!/bin/bash
arg1=$1; shift
array=( "$@" )
last_idx=$(( ${#array[@]} - 1 ))
arg2=${array[$last_idx]}
unset array[$last_idx]

echo "arg1=$arg1"
echo "arg2=$arg2"
echo "array contains:"
printf "%s\n" "${array[@]}"

And invoke it like

test.sh argument1 "${array[@]}" argument2

Answer 2

Have your script arrArg.sh like this:

#!/bin/bash

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

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

Now setup your arrays like this in a shell:

arr=(ab 'x y' 123)
arr2=(a1 'a a' bb cc 'it is one')

And pass arguments like this:

. ./arrArg.sh "foo" "arr[@]" "bar" "arr2[@]"

Above script will print:

arg1=foo
arg2 array=ab x y 123
arg2 #elem=3
arg3=bar
arg4 array=a1 a a bb cc it is one
arg4 #elem=5

Note: It might appear weird that I am executing script using . ./script . ./script syntax. Note that this is for executing commands of the script in the current shell environment .

Q. Why current shell environment and why not a sub shell?
A. Because bash doesn't export array variables to child processes as documented here by bash author himself

Answer 3

Passing array as argument to script by using alternate separator

Practical sample:

Choosing bell character: ascii 0x07 used by C sequence: \a .

Little preparation: Having a function to prepare variables:

mergeArray() {
    local IFS=$'\a'
    local -n src=$1 tgt=$2
    tgt=${src[*]}
}

Then the script could look like:

#!/bin/bash

arg1="$1"
IFS=$'\a' read -ra arg2 <<<"$2"
arg3="$3"

declare -p arg{1,2,3}

In practice:

var1=Hello var2=(foo bar baz) var3=world.
mergeArray var2 mvar2
bash script "$var1" "$mvar2" "$var3"

must output:

declare -- arg1="Hello"
declare -a arg2=([0]="foo" [1]="bar" [2]="baz")
declare -- arg3="world."

Explanations

• by using local IFS= I ensure IFS varialbe won't be modified in environment
• local -n is a nameref for binding variables.
• ${src[*]} will merge all elements of array to one string by using 1st character of $IFS
• Of course, I use \a for this, this could replaced (on both side) by any other single byte non null character (ascii) from \1 to \377 , while choosed character is not used in your array.

Installation and remote execution

The function mergeArray could be installed into your .bashrc for sample or in any file to be sourced before you run your script.

Once done, the script himself could even be located remotely. then run by same command:

ssh user@remote /path/to/script  "$var1" "$mvar2" "$var3"

But for more robust remote execution I prefer:

myArray=("foo bar baz" 'alice bob charlie' 'strawberry raspberry')
mergeArray myArray mergedArray
var1="Hello world!"
ssh user@remote /bin/bash <<eoRemote
    /path/to/script  "$var1" "$mergedArray" "This seem nice, isnt't it?"
eoRemote

On my remote host, this produce:

declare -- arg1="Hello world!"
declare -a arg2=([0]="foo bar baz" [1]="alice bob charlie" [2]="strawberry raspberry")
declare -- arg3="This seem nice, isnt't it?"

Answer 4

You can write your array to a file, then source the file in your script. eg:

array.sh

array=(a b c)

test.sh

source $2
...

Run the test.sh script:

./test.sh argument1 array.sh argument3

Answer 5

If the values have no spaces (ie they are urls, identifiers, numbers, etc) you can do this:

ARRAY=(one two three)
test.sh argument1 "${ARRAY[*]}" argument3

which is the same as:

test.sh argument1 "one two three" argument3

And in test.sh you do:

ARG1="$1"
ARRAY=($2) # Note that we don't add quotes
ARG3="$3"

---

If values have spaces I would go for glenn jackman's answer and simplify it by passing the array as the last argument:

ARRAY=("the first" "the second" "the third")
test.sh argument1 argument2 "${ARRAY[@]}"

which is the same as:

test.sh argument1 argument2 "the first" "the second" "the third"

And in test.sh do:

ARG1="$1"; shift
ARG2="$1"; shift
ARRAY=("$@")

Answer 6

The best solution that I'm found here

f() {
    declare -a argAry1=("${!1}")
    echo "${argAry1[@]}"
    # ...
}

arr1=(
    "a"
    "b"
)
f arr1[@] arr2[@] arg2

Answer 7

if the length of your array is not too long, you can convert the array to a string which joining with ','

file1.sh

s=${1}
arr=(`echo ${s} | tr ',' ' '`)  # then we can convert str to arr

file2.sh

a="1,2,3,4"
sh file1.sh ${a} 

Answer 8

If this is your command:

test.sh argument1 ${array[*]} argument2

You can read the array into test.sh like this:

arg1=$1
arg2=${2[*]}
arg3=$3

It will complain at you ("bad substitution"), but will work.