How do I check if variable is an array?

Question

I have a loop over variable names and I need to check if content of a variable is an array or not:

for varname in AA BB CC; do
  local val
  if [ "$varname" is array ]; then # how can I perform this test?
    echo do something with an array
  else
    echo do something with a "'normal'" variable
  fi
done

How do I do it?

Answer 1

To avoid a call to grep, you could use:

if [[ "$(declare -p variable_name)" =~ "declare -a" ]]; then
    echo array
else
    echo no array
fi

Answer 2

According to this wiki page, you can use this command:

declare -p variable-name 2> /dev/null | grep -q '^declare \-a'

Answer 3

Since bash 4.3 it is not that easy anymore.

With "declare -n" you can add a reference to another variable and you can do this over and over again. As if this was not complicated enough, with "declare -p", you do not get the type or the original variable.

Example:

$ declare -a test=( a b c d e)
$ declare -n mytest=test
$ declare -n newtest=mytest
$ declare -p newtest
declare -n newtest="mytest"
$ declare -p mytest
declare -n mytest="test"

Therefore you have to loop through all the references. In bash-only this would look like this:

vartype() {
    local var=$( declare -p $1 )
    local reg='^declare -n [^=]+=\"([^\"]+)\"$'
    while [[ $var =~ $reg ]]; do
            var=$( declare -p ${BASH_REMATCH[1]} )
    done

    case "${var#declare -}" in
    a*)
            echo "ARRAY"
            ;;
    A*)
            echo "HASH"
            ;;
    i*)
            echo "INT"
            ;;
    x*)
            echo "EXPORT"
            ;;
    *)
            echo "OTHER"
            ;;
    esac
}

With the above example:

$ vartype newtest
ARRAY

To check for array, you can modify the code or use it with grep:

vartype $varname | grep -q "ARRAY"

Answer 4

I started with Reuben's great answer above. I implemented a few of the comments and some of my own improvements and came out with this:

#!/bin/bash
array_test() {
    # no argument passed
    [[ $# -ne 1 ]] && echo 'Supply a variable name as an argument'>&2 && return 2
    local var=$1
    # use a variable to avoid having to escape spaces
    local regex="^declare -[aA] ${var}(=|$)"
    [[ $(declare -p "$var" 2> /dev/null) =~ $regex ]] && return 0
}

Now I can do this:

foo=(lorem ipsum dolor)
bar="declare -a tricky"
declare -A baz

array_test foo && echo "it's an array"
array_test bar && echo "it's an array"
# properly detects empty arrays
array_test baz && echo "it's an array"
# won't throw errors on undeclared variables
array_test foobarbaz && echo "it's an array"

Answer 5

is_array() {
  local variable_name=$1
  [[ "$(declare -p $variable_name)" =~ "declare -a" ]]
}

is_array BASH_VERSINFO && echo BASH_VERSINFO is an array

---

is_array() {
    local variable_name=$1
    [[ "$(declare -p $variable_name 2>/dev/null)" =~ "declare -a" ]]
}

Answer 6

Another Way:

Example, create an Array:

Variable=(The Quick Brown Fox...)

Test the Variable:

if [ "${#Variable[@]}" -gt "1" ] ;
 then echo "Variable is an Array"; 
else echo "Variable is NOT an Array" ; 
fi

Answer 7

I think this does it, it checks that the array indexes don't match "" or "0"

It should be cheap for small arrays and non-arrays.

It works by testing for any non-zero character in the array indexes

is_array() {
  eval [[ "\"\${!$1[*]}\"" =~ "[1-9]" ]]
}

an_array=(1 2 3)
wierd_array[4]=3
non_array="Joe"
unset non_exist

is_array an_array && echo pass || echo fail
is_array wierd_array && echo pass || echo fail
is_array non_array && echo fail || echo pass
is_array non_exist && echo fail || echo pass

output should be

pass
pass
pass
pass

Answer 8

miken32's improvement actually causes a regression. The following

a=()
export a
readonly a
declare -p a

prints

declare -arx a=()

which would match if you were just checking for declare -a as a substring, but would fail with miken's more complicated regex. I recommend just using

isArray() {
  # why do we need a regex again?
  [[ $(declare -p "$1") == 'declare -'[aA]* ]]
}

For the ksh folks, it's probably [[ $(declare -p $1) ~= '^(declare|typeset) -[aA]' or [[ $(declare -p $1) == @(declare|typeset)\ -[aA].

---

No, I don't think not throwing an error on undeclared is a good idea. And no, I have no idea why miken checks the variable name on declare output.