mjhjmtu

I am trying to use arrays in Bourne shell (/bin/sh). I found that the way to initialize array elements is:

arr=(1 2 3)

But it is encountering an error:

syntax error at line 8: `arr=' unexpected

Now the post where I found this syntax says it is for bash, but I could not find any separate syntax for Bourne shell. Does the syntax stand the same for /bin/sh as well?

/bin/sh is hardly ever a Bourne shell on any systems nowadays (even Solaris which was one of the last major system to include it has now switched to a POSIX sh for its /bin/sh in Solaris 11). /bin/sh was the Thompson shell in the early 70s. The Bourne shell replaced it in Unix V7 in 1979.

/bin/sh has been the Bourne shell for many years thereafter (or the Almquist shell, a free reimplementation on BSDs).

Nowadays, /bin/sh is more commonly an interpreter or another for the POSIX sh language which is itself based on a subset of the language of ksh88 (and a superset of the Bourne shell language with some incompatibilities).

The Bourne shell or the POSIX sh language specification don't support arrays. Or rather they have only one array: the positional parameters ($1, $2, $@, so one array per function as well).

ksh88 did have arrays which you set with set -A, but that didn't get specified in the POSIX sh as the syntax is awkward and not very usable.

Other shells with array/lists variables include: csh/tcsh, rc, es, bash (which mostly copied the ksh syntax the ksh93 way), yash, zsh, fish each with a different syntax (rc the shell of the once to-be successor of Unix, fish and zsh being the most consistent ones)...

In standard sh (also works in modern versions of the Bourne shell):

set '1st element' 2 3 # setting the array

set -- "$@" more # adding elements to the end of the array

shift 2 # removing elements (here 2) from the beginning of the array

printf '<%s>n' "$@" # passing all the elements of the $@ array 
 # as arguments to a command

for i do # looping over the elements of the $@ array ($1, $2...)
 printf 'Looping over "%s"n' "$i"
done

printf '%sn' "$1" # accessing individual element of the array.
 # up to the 9th only with the Bourne shell though
 # (only the Bourne shell), and note that you need
 # the braces (as in "$10") past the 9th in other
 # shells.

printf '%sn' "$# elements in the array"

printf '%sn' "$*" # join the elements of the array with the 
 # first character (byte in some implementations)
 # of $IFS (not in the Bourne shell where it's on
 # space instead regardless of the value of $IFS)

(note that in the Bourne shell and ksh88, $IFS must contain the space character for "$@" to work properly (a bug), and in the Bourne shell, you can't access elements above $9 ($10 won't work, you can still do shift 1; echo "$9" or loop over them)).

There are no arrays in plain Bourne shell. You can use the following way to create an array and traverse it:

#!/bin/sh
# ARRAY.sh: example usage of arrays in Bourne Shell

array_traverse()

 for i in $(seq 1 $2)
 do
 current_value=$1$i
 echo $(eval echo $$current_value)
 done
 return 1


ARRAY_1=one
ARRAY_2=two
ARRAY_3=333
array_traverse ARRAY_ 3

No matter what way to use arrays in sh would you pick it will always be cumbersome. Consider using a different language such as Python or Perl if you can unless you are stuck with a very limited platform or want to learn something.

As the others have said, the Bourne Shell doesn't have true arrays.

However, depending on what you need to do, delimited strings should suffice:

sentence="I don't need arrays because I can use delimited strings"
for word in $sentence
do
 printf '%sn' "$word"
done

If the typical delimiters (space, tab, and newline) don't suffice, you can set IFS to whatever delimiter you want before the loop.

And if you need to build the array programmatically, you can just build up a delimited string.

A way to simulate arrays in dash (it can be adapted for any number of dimensions of an array):
(Please note that the use of the seq command requires that IFS is set to ' ' (SPACE = the default value). You can use while ... do ... or do ... while ... loops instead to avoid this (i kept seq in the scope of a better illustration of what the code does).)

#!/bin/sh

## The following functions implement vectors (arrays) operations in dash:
## Definition of a vector <v>:
## v_0 - variable that stores the number of elements of the vector
## v_1..v_n, where n=v_0 - variables that store the values of the vector elements

VectorAddElementNext () 
# Vector Add Element Next
# Adds the string contained in variable $2 in the next element position (vector length + 1) in vector $1

 local elem_value
 local vector_length
 local elem_name

 eval elem_value="$$2"
 eval vector_length=$$1_0
 if [ -z "$vector_length" ]; then
 vector_length=$((0))
 fi

 vector_length=$(( vector_length + 1 ))
 elem_name=$1_$vector_length

 eval $elem_name="$elem_value"
 eval $1_0=$vector_length


VectorAddElementDVNext () 
# Vector Add Element Direct Value Next
# Adds the string $2 in the next element position (vector length + 1) in vector $1

 local elem_value
 local vector_length
 local elem_name

 eval elem_value="$2"
 eval vector_length=$$1_0
 if [ -z "$vector_length" ]; then
 vector_length=$((0))
 fi

 vector_length=$(( vector_length + 1 ))
 elem_name=$1_$vector_length

 eval $elem_name="$elem_value"
 eval $1_0=$vector_length


VectorAddElement () 
# Vector Add Element
# Adds the string contained in the variable $3 in the position contained in $2 (variable or direct value) in the vector $1

 local elem_value
 local elem_position
 local vector_length
 local elem_name

 eval elem_value="$$3"
 elem_position=$(($2))
 eval vector_length=$$1_0
 if [ -z "$vector_length" ]; then
 vector_length=$((0))
 fi

 if [ $elem_position -ge $vector_length ]; then
 vector_length=$elem_position
 fi

 elem_name=$1_$elem_position

 eval $elem_name="$elem_value"
 if [ ! $elem_position -eq 0 ]; then
 eval $1_0=$vector_length
 fi


VectorAddElementDV () 
# Vector Add Element
# Adds the string $3 in the position $2 (variable or direct value) in the vector $1

 local elem_value
 local elem_position
 local vector_length
 local elem_name

 eval elem_value="$3"
 elem_position=$(($2))
 eval vector_length=$$1_0
 if [ -z "$vector_length" ]; then
 vector_length=$((0))
 fi

 if [ $elem_position -ge $vector_length ]; then
 vector_length=$elem_position
 fi

 elem_name=$1_$elem_position

 eval $elem_name="$elem_value"
 if [ ! $elem_position -eq 0 ]; then
 eval $1_0=$vector_length
 fi


VectorPrint () 
# Vector Print
# Prints all the elements names and values of the vector $1 on sepparate lines

 local vector_length

 vector_length=$(($1_0))
 if [ "$vector_length" = "0" ]; then
 echo "Vector "$1" is empty!"
 else
 echo "Vector "$1":"
 for i in $(seq 1 $vector_length); do
 eval echo "[$i]: \"$$1_$i\""
 ###OR: eval printf '%s\n' "[$i]: \"$$1_$i\""
 done
 fi


VectorDestroy () 
# Vector Destroy
# Empties all the elements values of the vector $1

 local vector_length

 vector_length=$(($1_0))
 if [ ! "$vector_length" = "0" ]; then
 for i in $(seq 1 $vector_length); do
 unset $1_$i
 done
 unset $1_0
 fi


##################
### MAIN START ###
##################

## Setting vector 'params' with all the parameters received by the script:
for i in $(seq 1 $#); do
 eval param="$$i"
 VectorAddElementNext params param
done

# Printing the vector 'params':
VectorPrint params

read temp

## Setting vector 'params2' with the elements of the vector 'params' in reversed order:
if [ -n "$params_0" ]; then
 for i in $(seq 1 $params_0); do
 count=$((params_0-i+1))
 VectorAddElement params2 count params_$i
 done
fi

# Printing the vector 'params2':
VectorPrint params2

read temp

## Getting the values of 'params2'`s elements and printing them:
if [ -n "$params2_0" ]; then
 echo "Printing the elements of the vector 'params2':"
 for i in $(seq 1 $params2_0); do
 eval current_elem_value="$params2_$i"
 echo "params2_$i="$current_elem_value""
 done
else
 echo "Vector 'params2' is empty!"
fi

read temp

## Creating a two dimensional array ('a'):
for i in $(seq 1 10); do
 VectorAddElement a 0 i
 for j in $(seq 1 8); do
 value=$(( 8 * ( i - 1 ) + j ))
 VectorAddElementDV a_$i $j $value
 done
done

## Manually printing the two dimensional array ('a'):
echo "Printing the two-dimensional array 'a':"
if [ -n "$a_0" ]; then
 for i in $(seq 1 $a_0); do
 eval current_vector_lenght=$a_$i_0
 if [ -n "$current_vector_lenght" ]; then
 for j in $(seq 1 $current_vector_lenght); do
 eval value="$a_$i_$j"
 printf "$value "
 done
 fi
 printf "n"
 done
fi

################
### MAIN END ###
################