Test for array support by shell

Question

Is there a concise way of testing for array support by the local Bourne-like shell at command line ?

This is always possible:

$ arr=(0 1 2 3);if [ "${arr[2]}" != 2 ];then echo "No array support";fi

or testing for $SHELL and shell version:

$ eval $(echo "$SHELL --version") | grep version

and then reading the man page, assuming I have access to it. (Even there, writing from /bin/bash, I am assuming that all Bourne-like shells admit the long option --version, when that breaks for ksh for instance.)

I am looking for a simple test that could be unattended and incorporated in a Usage section at beginning of script or even before calling it.

Answer 1

Assuming you want to restrict to Bourne-like shells (many other shells like csh, tcsh, rc, es or fish support arrays but writing a script compatible at the same time to Bourne-like shells and those is tricky and generally pointless as they are interpreters for completely different and incompatible languages), note that there are significant differences between implementations.

The Bourne like shells that support arrays (in chronological order of when support was added) are:

• ksh88 (the last evolution of the original ksh, the first one implementing arrays, ksh88 is still found as ksh on most traditional commercial Unices where it's also the basis for sh)

  • arrays are one-dimensional
  • Arrays are defined as set -A array foo bar or set -A array -- "$var" ... if you can't guarantee that $var won't start with a - or +.
  • Array indices start at 0.
  • Individual array elements are assigned as a[1]=value.
  • arrays are sparse. That is a[5]=foo will work even if a[0,1,2,3,4] are not set and will leave them unset.
  • ${a[5]} to access the element of indice 5 (not necessarily the 6th element if the array is sparse). The 5 there can be any arithmetic expression.
  • array size and subscript is limited (to 4096).
  • ${#a[@]} is the number of assigned element in the array (not the greatest assigned indice).
  • there is no way to know the list of assigned subscripts (other than testing the 4096 elements individually with [[ -n "${a[i]+set}" ]]).
  • $a is the same as ${a[0]}. That is arrays somehow extend scalar variables by giving them extra values.

• pdksh and derivatives (that's the basis for the ksh and sometimes sh of several BSDs and was the only opensource ksh implementation before ksh93 source was freed):

  Mostly like ksh88 but note:

  • Some old implementations didn't support set -A array -- foo bar, (the -- wasn't needed there).
  • ${#a[@]} is one plus the indice of the greatest assigned indice. (a[1000]=1; echo "${#a[@]}" outputs 1001 even though the array has only one element.
  • in newer versions, array size is no longer limited (other than by the size of integers).
  • recent versions of mksh have a few extra operators inspired from bash, ksh93 or zsh like assignments a la a=(x y), a+=(z), ${!a[@]} to get the list of assigned indices.

• zsh. zsh arrays are generally better designed and take the best of ksh and csh arrays. As you can see from the zsh 2.0 announcement in 1991, the design was inspired from tcsh rather than ksh. They have some resemblance with ksh arrays but with significant differences:

  • indices start at 1, not 0 (except in ksh emulation), that's consistent with the Bourne array (the position parameters $@, which zsh also exposes as its $argv array) and csh arrays.
  • they are a separate type from normal/scalar variables. Operators apply differently to them and like you'd generally expect. $a is not the same as ${a[0]} but expands to the non-empty elements of the array ("${a[@]}" for all the elements like in ksh).
  • they are normal arrays, not sparse arrays. a[5]=1 works but assigns all the elements from 1 to 4 the empty string if they were not assigned. So ${#a[@]} (same as ${#a} which in ksh is the size of the element of indice 0) is the number of elements in the array and the greatest assigned indice.
  • associative arrays are supported.
  • a great numbers of operators to work with arrays is supported, too big to list here.
  • arrays defined as a=(x y). set -A a x y also works for compatibility with ksh, but set -A a -- x y is not supported unless in ksh emulation (the -- is not needed in zsh emulation).

• ksh93. (here describing latest versions). ksh93, a rewrite of ksh by the original authors, long considered experimental can now be found in more and more systems now that it has been released as FOSS. For instance, it's the /bin/sh (where it replaced the Bourne shell, /usr/xpg4/bin/sh, the POSIX shell is still based on ksh88) and ksh of Solaris 11. Its arrays extend and enhance ksh88's.

  • a=(x y) can be used to define an array, but since a=(...) is also used to define compound variables (a=(foo=bar bar=baz)), a=() is ambiguous and declares a compound variable, not an array.
  • arrays are multi-dimensional (a=((0 1) (0 2))) and array elements can also be compound variables (a=((a b) (c=d d=f)); echo "${a[1].c}").
  • A a=([2]=foo [5]=bar) syntax can be used to define sparse arrays at once.
  • maximum array index raised to 4,194,303.
  • Not to the extent of zsh, but great number of operators supported as well to manipulate arrays.
  • "${!a[@]}" to retrieve the list of array indices.
  • associative arrays also supported as a separate type.

• bash. bash is the shell of the GNU project. It's used as sh on recent versions of OS/X and some GNU/Linux distributions. bash arrays mostly emulate ksh88 ones with some features of ksh93 and zsh.

  • a=(x y) supported. set -A a x y not supported. a=() creates an empty array (no compound variables in bash).
  • "${!a[@]}" for the list of indices.
  • a=([foo]=bar) syntax supported as well as a few others from ksh93 and zsh.
  • recent bash versions also support associative arrays as a separate type.

• yash. It's a relatively recent, clean, multi-byte aware POSIX sh implementation. Not in wide use. Its arrays are another clean API similar to zsh

  • arrays are not sparse
  • Array indices start at 1
  • defined (and declared) with a=(var value)
  • elements inserted, deleted or modified with the array builtin
  • array -s a 5 value to modify the 5^th element would fail if that element was not assigned beforehand.
  • the number of elements in the array is ${a[#]}, ${#a[@]} being the size of the elements as a list.
  • arrays are a separate type. You need a=("$a") to redefine a scalar variable as an array before you can add or modify elements.
  • "$array" expands to all the elements of the array as-is, which makes them much easier to use than in other shells (cmd "$array" to call cmd with the elements of the array as arguments compared to cmd "${array[@]}" in ksh/bash/zsh; zsh's cmd $array is close but strips empty elements).
  • arrays are not supported when invoked as sh.

So, from that you can see that detecting for array support, which you could do with:

if (unset a; set -A a a; eval "a=(a b)"; eval '[ -n "${a[1]}" ]'
   ) > /dev/null 2>&1
then
  array_supported=true
else
  array_supported=false
fi

is not enough to be able to use those arrays. You'd need to define wrapper commands to assign arrays as a whole and individual elements, and make sure you don't attempt to create sparse arrays.

Like

unset a
array_elements() { eval "REPLY=\"\${#$1[@]}\""; }
if (set -A a -- a) 2> /dev/null; then
  set -A a -- a b
  case ${a[0]}${a[1]} in
    --) set_array() { eval "shift; set -A $1"' "$@"'; }
        set_array_element() { eval "$1[1+(\$2)]=\$3"; }
        first_indice=0;;
     a) set_array() { eval "shift; set -A $1"' -- "$@"'; }
        set_array_element() { eval "$1[1+(\$2)]=\$3"; }
        first_indice=1;;
   --a) set_array() { eval "shift; set -A $1"' "$@"'; }
        set_array_element() { eval "$1[\$2]=\$3"; }
        first_indice=0;;
    ab) set_array() { eval "shift; set -A $1"' -- "$@"'; }
        set_array_element() { eval "$1[\$2]=\$3"; }
        first_indice=0;;
  esac
elif (eval 'a[5]=x') 2> /dev/null; then
  set_array() { eval "shift; $1=("'"$@")'; }
  set_array_element() { eval "$1[\$2]=\$3"; }
  first_indice=0
elif (eval 'a=(x) && array -s a 1 y && [ "${a[1]}" = y ]') 2> /dev/null; then
  set_array() { eval "shift; $1=("'"$@")'; }
  set_array_element() {
    eval "
      $1=(\${$1+\"\${$1[@]}"'"})
      while [ "$(($2))" -ge  "${'"$1"'[#]}" ]; do
        array -i "$1" "$2" ""
      done'
    array -s -- "$1" "$((1+$2))" "$3"
   }
  array_elements() { eval "REPLY=\${$1[#]}"; }
  first_indice=1
else
  echo >&2 "Array not supported"
fi

And then you access array elements with "${a[$first_indice+n]}", the whole list with "${a[@]}" and use the wrapper functions (array_elements, set_array, set_array_element) to get the number of elements of an array (in $REPLY), set the array as a whole or assign individual elements.

Probably not worth the effort. I'd use perl or limit to the Bourne/POSIX shell array: "$@".

If the intent is to have some file to be sourced by the interactive shell of a user to define functions that internally use arrays, here are a few more notes that may be useful.

You can configure zsh arrays to be more like ksh arrays in local scopes (in functions or anonymous functions).

myfunction() {
  [ -z "$ZSH_VERSION" ] || setopt localoption ksharrays
  # use arrays of indice 0 in this function
}

You can also emulate ksh (improve compatibility with ksh for arrays and several other areas) with:

myfunction() {
  [ -z "$ZSH_VERSION" ] || emulate -L ksh
  # ksh code more likely to work here
}

With that in mind and you're willing to drop support for yash and ksh88 and older versions of pdksh derivatives, and as long as you don't try to create sparse arrays, you should be able to consistently use:

• a[0]=foo
• a=(foo bar) (but not a=())
• "${a[#]}", "${a[@]}", "${a[0]}"

in those functions that have the emulate -L ksh, while the zsh user still using his/her arrays normally the zsh way.

Answer 2

You can use eval to try the array syntax:

is_array_support() (
  eval 'a=(1)'
) >/dev/null 2>&1

if is_array_support; then
  echo support
else
  echo not
fi