Yrurtj

Another unconventional approach:

#!/bin/bash



array=(1 2 3 4 5 6 7)



f() { array=("${BASH_ARGV[@]}"); }



shopt -s extdebug

f "${array[@]}"

shopt -u extdebug



echo "${array[@]}"

Output:

7 6 5 4 3 2 1

If extdebug is enabled, array BASH_ARGV contains in a function all positional parameters in reverse order.

Unconventional approach (all not pure bash):

• 
  

  if all elements in an array are just one characters (like in the question) you can use rev:

  
  
  

  echo "${array[@]}" | rev
  
  

  
  


• 
  

  otherwise:

  
  
  

  printf '%sn' "${array[@]}" | tac | tr 'n' ' '; echo
  
  

  
  


• 
  

  and if you can use zsh:

  
  
  

  echo ${(Oa)array}
  
  

  
  

If you actually want the reverse in another array:

reverse() {

    # first argument is the array to reverse

    # second is the output array

    declare -n arr="$1" rev="$2"

    for i in "${arr[@]}"

    do

        rev=("$i" "${rev[@]}")

    done

}

Then:

array=(1 2 3 4)

reverse array foo

echo "${foo[@]}"

Gives:

4 3 2 1

This should correctly handle cases where an array index is missing, say you had array=([1]=1 [2]=2 [4]=4), in which case looping from 0 to the highest index may add additional, empty, elements.

To swap the array positions in place (even with sparse arrays)(since bash 3.0):

#!/bin/bash

# Declare an sparse array to test:

array=([5]=1 [6]=2 [10]=3 [11]=4 [20]=5 [21]=6 [40]=7)

declare -p array



scan=("${!array[@]}")                       # non-sparse array of indexes.



min=0; max=$(( ${#scan[@]} - 1 ))           # for all (indexed) elements.

while [[ min -lt max ]]

do

    x="${array[scan[min]]}"                 # temp variable

    array[scan[min]]="${array[scan[max]]}"  # Exchange first and last

    array[scan[max]]="$x"                   #

    (( min++, max-- ))                      # Move closer

done



declare -p array

echo "Final Array swapped in-place"

echo "${array[@]}"

On execution:

./script

declare -a array=([5]="1" [6]="2" [10]="3" [11]="4" [20]="5" [21]="6" [40]="7")

declare -a array=([5]="7" [6]="6" [10]="5" [11]="4" [20]="3" [21]="2" [40]="1")

Final Array swapped in place

7 6 5 4 3 2 1

For older bash, you need to use a loop (in bash (since 2.04)) and using $a to avoid the trailing space:

#!/bin/bash



array=(1 2 3 4 5 6 7)

last=${#array[@]}



a=""

for (( i=last-1 ; i>=0 ; i-- ));do

    printf '%s%s ' "$a" "${array[i]}"

    a=" " 

done

echo

For bash since 2.03:

#!/bin/bash

array=(1 2 3 4 5 6 7)

last=${#array[@]}



a="";i=0

while [[ last -ge $((i+=1)) ]]; do 

    printf '%s%s' "$a" "${array[ last-i ]}"

    a=" "

done

echo

Also (using the negate operator) (since bash 4.2+):

#!/bin/bash

array=(1 2 3 4 5 6 7)

last=${#array[@]}



a=""

for (( i=0 ; i<last ; i++ )); do 

    printf '%s%s' "$a" "${array[~i]}"

    a=" "

done

echo

Ugly, unmaintainable, but one-liner:

eval eval echo "'"${array['{$((${#array[@]}-1))..0}']}"'"

Though i am not going to tell something new and i will also use tac to reverse the array, i though that would be worthing to mention bellow single line solution using bash version 4.4:

$ read -d'n' -a array < <(printf '%sn' "${array[@]}" |tac)

Testing:

$ array=(1 2 3 4 5 6 10 11 12)

$ echo "${array[@]}"

1 2 3 4 5 6 10 11 12

$ read -d'n' -a array < <(printf '%sn' "${array[@]}"|tac)

$ echo "${array[@]}"

12 11 10 6 5 4 3 2 1

Mind that the var name inside read is the name as the original array, so no helper array is required for temp storage.

Alternative implementation by adjusting IFS :

$ IFS=$'n' read -d '' -a array < <(printf '%sn' "${array[@]}"|tac);declare -p array

declare -a array=([0]="12" [1]="11" [2]="10" [3]="6" [4]="5" [5]="4" [6]="3" [7]="2" [8]="1")

PS: I think above solutions will not work in bash bellow version 4.4 due to different read bash builtin function implementation.

To reverse an arbitrary array (which may contain any number of elements with any values):

With zsh:

array_reversed=("${(@Oa)array}")

With bash 4.4+, given that bash variables can't contain NUL bytes anyway, you can use GNU tac -s '' on the elements printed as NUL delimited records:

readarray -td '' array_reversed < <(

  ((${#array[@]})) && printf '%s' "${array[@]}" | tac -s '')

POSIXly, to reverse the POSIX shell array ($@, made of $1, $2...):

code='set --'

n=$#

while [ "$n" -gt 0 ]; do

  code="$code "${$n}""

  n=$((n - 1))

done

eval "$code"

Bash

array=(1 2 3 4 5 6 7)

echo "${array[@]} " | tac -s ' '

Or

array=(1 2 3 4 5 6 7)

reverse=$(echo "${array[@]} " | tac -s ' ')

echo ${reverse[@]}

Result

7 6 5 4 3 2 1

Version

$ tac --version

tac (GNU coreutils) 8.28