Newer versions of Bash support one-dimensional arrays. Array elements may be initialized with the variable[xx] notation. Alternatively, a script may introduce the entire array by an explicit declare -a variable statement. To dereference (find the contents of) an array element, use curly bracket notation, that is, ${variable[xx]}.
Example 26-1. Simple array usage
1 #!/bin/bash 2 3 4 area[11]=23 5 area[13]=37 6 area[51]=UFOs 7 8 # Array members need not be consecutive or contiguous. 9 10 # Some members of the array can be left uninitialized. 11 # Gaps in the array are okay. 12 # In fact, arrays with sparse data ("sparse arrays") 13 #+ are useful in spreadsheet-processing software. 14 15 16 echo -n "area[11] = " 17 echo ${area[11]} # {curly brackets} needed. 18 19 echo -n "area[13] = " 20 echo ${area[13]} 21 22 echo "Contents of area[51] are ${area[51]}." 23 24 # Contents of uninitialized array variable print blank (null variable). 25 echo -n "area[43] = " 26 echo ${area[43]} 27 echo "(area[43] unassigned)" 28 29 echo 30 31 # Sum of two array variables assigned to third 32 area[5]=`expr ${area[11]} + ${area[13]}` 33 echo "area[5] = area[11] + area[13]" 34 echo -n "area[5] = " 35 echo ${area[5]} 36 37 area[6]=`expr ${area[11]} + ${area[51]}` 38 echo "area[6] = area[11] + area[51]" 39 echo -n "area[6] = " 40 echo ${area[6]} 41 # This fails because adding an integer to a string is not permitted. 42 43 echo; echo; echo 44 45 # ----------------------------------------------------------------- 46 # Another array, "area2". 47 # Another way of assigning array variables... 48 # array_name=( XXX YYY ZZZ ... ) 49 50 area2=( zero one two three four ) 51 52 echo -n "area2[0] = " 53 echo ${area2[0]} 54 # Aha, zero-based indexing (first element of array is [0], not [1]). 55 56 echo -n "area2[1] = " 57 echo ${area2[1]} # [1] is second element of array. 58 # ----------------------------------------------------------------- 59 60 echo; echo; echo 61 62 # ----------------------------------------------- 63 # Yet another array, "area3". 64 # Yet another way of assigning array variables... 65 # array_name=([xx]=XXX [yy]=YYY ...) 66 67 area3=([17]=seventeen [24]=twenty-four) 68 69 echo -n "area3[17] = " 70 echo ${area3[17]} 71 72 echo -n "area3[24] = " 73 echo ${area3[24]} 74 # ----------------------------------------------- 75 76 exit 0 |
Bash permits array operations on variables, even if the variables are not explicitly declared as arrays.
|
Example 26-2. Formatting a poem
1 #!/bin/bash 2 # poem.sh: Pretty-prints one of the document author's favorite poems. 3 4 # Lines of the poem (single stanza). 5 Line[1]="I do not know which to prefer," 6 Line[2]="The beauty of inflections" 7 Line[3]="Or the beauty of innuendoes," 8 Line[4]="The blackbird whistling" 9 Line[5]="Or just after." 10 11 # Attribution. 12 Attrib[1]=" Wallace Stevens" 13 Attrib[2]="\"Thirteen Ways of Looking at a Blackbird\"" 14 # This poem is in the Public Domain (copyright expired). 15 16 echo 17 18 for index in 1 2 3 4 5 # Five lines. 19 do 20 printf " %s\n" "${Line[index]}" 21 done 22 23 for index in 1 2 # Two attribution lines. 24 do 25 printf " %s\n" "${Attrib[index]}" 26 done 27 28 echo 29 30 exit 0 31 32 # Exercise: 33 # -------- 34 # Modify this script to pretty-print a poem from a text data file. |
Array variables have a syntax all their own, and even standard Bash commands and operators have special options adapted for array use.
Example 26-3. Various array operations
1 #!/bin/bash 2 # array-ops.sh: More fun with arrays. 3 4 5 array=( zero one two three four five ) 6 # Element 0 1 2 3 4 5 7 8 echo ${array[0]} # zero 9 echo ${array:0} # zero 10 # Parameter expansion of first element, 11 #+ starting at position # 0 (1st character). 12 echo ${array:1} # ero 13 # Parameter expansion of first element, 14 #+ starting at position # 1 (2nd character). 15 16 echo "--------------" 17 18 echo ${#array[0]} # 4 19 # Length of first element of array. 20 echo ${#array} # 4 21 # Length of first element of array. 22 # (Alternate notation) 23 24 echo ${#array[1]} # 3 25 # Length of second element of array. 26 # Arrays in Bash have zero-based indexing. 27 28 echo ${#array[*]} # 6 29 # Number of elements in array. 30 echo ${#array[@]} # 6 31 # Number of elements in array. 32 33 echo "--------------" 34 35 array2=( [0]="first element" [1]="second element" [3]="fourth element" ) 36 37 echo ${array2[0]} # first element 38 echo ${array2[1]} # second element 39 echo ${array2[2]} # 40 # Skipped in initialization, and therefore null. 41 echo ${array2[3]} # fourth element 42 43 44 exit 0 |
Many of the standard string operations work on arrays.
Example 26-4. String operations on arrays
1 #!/bin/bash 2 # array-strops.sh: String operations on arrays. 3 # Script by Michael Zick. 4 # Used with permission. 5 6 # In general, any string operation in the ${name ... } notation 7 #+ can be applied to all string elements in an array 8 #+ with the ${name[@] ... } or ${name[*] ...} notation. 9 10 11 arrayZ=( one two three four five five ) 12 13 echo 14 15 # Trailing Substring Extraction 16 echo ${arrayZ[@]:0} # one two three four five five 17 # All elements. 18 19 echo ${arrayZ[@]:1} # two three four five five 20 # All elements following element[0]. 21 22 echo ${arrayZ[@]:1:2} # two three 23 # Only the two elements after element[0]. 24 25 echo "-----------------------" 26 27 # Substring Removal 28 # Removes shortest match from front of string(s), 29 #+ where the substring is a regular expression. 30 31 echo ${arrayZ[@]#f*r} # one two three five five 32 # Applied to all elements of the array. 33 # Matches "four" and removes it. 34 35 # Longest match from front of string(s) 36 echo ${arrayZ[@]##t*e} # one two four five five 37 # Applied to all elements of the array. 38 # Matches "three" and removes it. 39 40 # Shortest match from back of string(s) 41 echo ${arrayZ[@]%h*e} # one two t four five five 42 # Applied to all elements of the array. 43 # Matches "hree" and removes it. 44 45 # Longest match from back of string(s) 46 echo ${arrayZ[@]%%t*e} # one two four five five 47 # Applied to all elements of the array. 48 # Matches "three" and removes it. 49 50 echo "-----------------------" 51 52 # Substring Replacement 53 54 # Replace first occurance of substring with replacement 55 echo ${arrayZ[@]/fiv/XYZ} # one two three four XYZe XYZe 56 # Applied to all elements of the array. 57 58 # Replace all occurances of substring 59 echo ${arrayZ[@]//iv/YY} # one two three four fYYe fYYe 60 # Applied to all elements of the array. 61 62 # Delete all occurances of substring 63 # Not specifing a replacement means 'delete' 64 echo ${arrayZ[@]//fi/} # one two three four ve ve 65 # Applied to all elements of the array. 66 67 # Replace front-end occurances of substring 68 echo ${arrayZ[@]/#fi/XY} # one two three four XYve XYve 69 # Applied to all elements of the array. 70 71 # Replace back-end occurances of substring 72 echo ${arrayZ[@]/%ve/ZZ} # one two three four fiZZ fiZZ 73 # Applied to all elements of the array. 74 75 echo ${arrayZ[@]/%o/XX} # one twXX three four five five 76 # Why? 77 78 echo "-----------------------" 79 80 81 # Before reaching for awk (or anything else) -- 82 # Recall: 83 # $( ... ) is command substitution. 84 # Functions run as a sub-process. 85 # Functions write their output to stdout. 86 # Assignment reads the function's stdout. 87 # The name[@] notation specifies a "for-each" operation. 88 89 newstr() { 90 echo -n "!!!" 91 } 92 93 echo ${arrayZ[@]/%e/$(newstr)} 94 # on!!! two thre!!! four fiv!!! fiv!!! 95 # Q.E.D: The replacement action is an 'assignment.' 96 97 # Accessing the "For-Each" 98 echo ${arrayZ[@]//*/$(newstr optional_arguments)} 99 # Now, if Bash would just pass the matched string as $0 100 #+ to the function being called . . . 101 102 echo 103 104 exit 0 |
Command substitution can construct the individual elements of an array.
Example 26-5. Loading the contents of a script into an array
1 #!/bin/bash 2 # script-array.sh: Loads this script into an array. 3 # Inspired by an e-mail from Chris Martin (thanks!). 4 5 script_contents=( $(cat "$0") ) # Stores contents of this script ($0) 6 #+ in an array. 7 8 for element in $(seq 0 $((${#script_contents[@]} - 1))) 9 do # ${#script_contents[@]} 10 #+ gives number of elements in the array. 11 # 12 # Question: 13 # Why is seq 0 necessary? 14 # Try changing it to seq 1. 15 echo -n "${script_contents[$element]}" 16 # List each field of this script on a single line. 17 echo -n " -- " # Use " -- " as a field separator. 18 done 19 20 echo 21 22 exit 0 23 24 # Exercise: 25 # -------- 26 # Modify this script so it lists itself 27 #+ in its original format, 28 #+ complete with whitespace, line breaks, etc. |
In an array context, some Bash builtins have a slightly altered meaning. For example, unset deletes array elements, or even an entire array.
Example 26-6. Some special properties of arrays
1 #!/bin/bash 2 3 declare -a colors 4 # All subsequent commands in this script will treat 5 #+ the variable "colors" as an array. 6 7 echo "Enter your favorite colors (separated from each other by a space)." 8 9 read -a colors # Enter at least 3 colors to demonstrate features below. 10 # Special option to 'read' command, 11 #+ allowing assignment of elements in an array. 12 13 echo 14 15 element_count=${#colors[@]} 16 # Special syntax to extract number of elements in array. 17 # element_count=${#colors[*]} works also. 18 # 19 # The "@" variable allows word splitting within quotes 20 #+ (extracts variables separated by whitespace). 21 # 22 # This corresponds to the behavior of "$@" and "$*" 23 #+ in positional parameters. 24 25 index=0 26 27 while [ "$index" -lt "$element_count" ] 28 do # List all the elements in the array. 29 echo ${colors[$index]} 30 let "index = $index + 1" 31 # Or: 32 # index+=1 33 # if running Bash, version 3.1 or later. 34 done 35 # Each array element listed on a separate line. 36 # If this is not desired, use echo -n "${colors[$index]} " 37 # 38 # Doing it with a "for" loop instead: 39 # for i in "${colors[@]}" 40 # do 41 # echo "$i" 42 # done 43 # (Thanks, S.C.) 44 45 echo 46 47 # Again, list all the elements in the array, but using a more elegant method. 48 echo ${colors[@]} # echo ${colors[*]} also works. 49 50 echo 51 52 # The "unset" command deletes elements of an array, or entire array. 53 unset colors[1] # Remove 2nd element of array. 54 # Same effect as colors[1]= 55 echo ${colors[@]} # List array again, missing 2nd element. 56 57 unset colors # Delete entire array. 58 # unset colors[*] and 59 #+ unset colors[@] also work. 60 echo; echo -n "Colors gone." 61 echo ${colors[@]} # List array again, now empty. 62 63 exit 0 |
As seen in the previous example, either ${array_name[@]} or ${array_name[*]} refers to all the elements of the array. Similarly, to get a count of the number of elements in an array, use either ${#array_name[@]} or ${#array_name[*]}. ${#array_name} is the length (number of characters) of ${array_name[0]}, the first element of the array.
Example 26-7. Of empty arrays and empty elements
1 #!/bin/bash 2 # empty-array.sh 3 4 # Thanks to Stephane Chazelas for the original example, 5 #+ and to Michael Zick and Omair Eshkenazi for extending it. 6 7 8 # An empty array is not the same as an array with empty elements. 9 10 array0=( first second third ) 11 array1=( '' ) # "array1" consists of one empty element. 12 array2=( ) # No elements . . . "array2" is empty. 13 array3=( ) # What about this array? 14 15 echo 16 ListArray() 17 { 18 echo 19 echo "Elements in array0: ${array0[@]}" 20 echo "Elements in array1: ${array1[@]}" 21 echo "Elements in array2: ${array2[@]}" 22 echo "Elements in array3: ${array3[@]}" 23 echo 24 echo "Length of first element in array0 = ${#array0}" 25 echo "Length of first element in array1 = ${#array1}" 26 echo "Length of first element in array2 = ${#array2}" 27 echo "Length of first element in array3 = ${#array3}" 28 echo 29 echo "Number of elements in array0 = ${#array0[*]}" # 3 30 echo "Number of elements in array1 = ${#array1[*]}" # 1 (Surprise!) 31 echo "Number of elements in array2 = ${#array2[*]}" # 0 32 echo "Number of elements in array3 = ${#array3[*]}" # 0 33 } 34 35 # =================================================================== 36 37 ListArray 38 39 # Try extending those arrays. 40 41 # Adding an element to an array. 42 array0=( "${array0[@]}" "new1" ) 43 array1=( "${array1[@]}" "new1" ) 44 array2=( "${array2[@]}" "new1" ) 45 array3=( "${array3[@]}" "new1" ) 46 47 ListArray 48 49 # or 50 array0[${#array0[*]}]="new2" 51 array1[${#array1[*]}]="new2" 52 array2[${#array2[*]}]="new2" 53 array3[${#array3[*]}]="new2" 54 55 ListArray 56 57 # When extended as above; arrays are 'stacks' 58 # The above is the 'push' 59 # The stack 'height' is: 60 height=${#array2[@]} 61 echo 62 echo "Stack height for array2 = $height" 63 64 # The 'pop' is: 65 unset array2[${#array2[@]}-1] # Arrays are zero-based, 66 height=${#array2[@]} #+ which means first element has index 0. 67 echo 68 echo "POP" 69 echo "New stack height for array2 = $height" 70 71 ListArray 72 73 # List only 2nd and 3rd elements of array0. 74 from=1 # Zero-based numbering. 75 to=2 76 array3=( ${array0[@]:1:2} ) 77 echo 78 echo "Elements in array3: ${array3[@]}" 79 80 # Works like a string (array of characters). 81 # Try some other "string" forms. 82 83 # Replacement: 84 array4=( ${array0[@]/second/2nd} ) 85 echo 86 echo "Elements in array4: ${array4[@]}" 87 88 # Replace all matching wildcarded string. 89 array5=( ${array0[@]//new?/old} ) 90 echo 91 echo "Elements in array5: ${array5[@]}" 92 93 # Just when you are getting the feel for this . . . 94 array6=( ${array0[@]#*new} ) 95 echo # This one might surprise you. 96 echo "Elements in array6: ${array6[@]}" 97 98 array7=( ${array0[@]#new1} ) 99 echo # After array6 this should not be a surprise. 100 echo "Elements in array7: ${array7[@]}" 101 102 # Which looks a lot like . . . 103 array8=( ${array0[@]/new1/} ) 104 echo 105 echo "Elements in array8: ${array8[@]}" 106 107 # So what can one say about this? 108 109 # The string operations are performed on 110 #+ each of the elements in var[@] in succession. 111 # Therefore : Bash supports string vector operations 112 #+ if the result is a zero length string, 113 #+ that element disappears in the resulting assignment. 114 115 # Question, are those strings hard or soft quotes? 116 117 zap='new*' 118 array9=( ${array0[@]/$zap/} ) 119 echo 120 echo "Elements in array9: ${array9[@]}" 121 122 # Just when you thought you where still in Kansas . . . 123 array10=( ${array0[@]#$zap} ) 124 echo 125 echo "Elements in array10: ${array10[@]}" 126 127 # Compare array7 with array10. 128 # Compare array8 with array9. 129 130 # Answer: must be soft quotes. 131 132 exit 0 |
The relationship of ${array_name[@]} and ${array_name[*]} is analogous to that between $@ and $*. This powerful array notation has a number of uses.
1 # Copying an array. 2 array2=( "${array1[@]}" ) 3 # or 4 array2="${array1[@]}" 5 # 6 # However, this fails with "sparse" arrays, 7 #+ arrays with holes (missing elements) in them, 8 #+ as Jochen DeSmet points out. 9 # ------------------------------------------ 10 array1[0]=0 11 # array1[1] not assigned 12 array1[2]=2 13 array2=( "${array1[@]}" ) # Copy it? 14 15 echo ${array2[0]} # 0 16 echo ${array2[2]} # (null), should be 2 17 # ------------------------------------------ 18 19 20 21 # Adding an element to an array. 22 array=( "${array[@]}" "new element" ) 23 # or 24 array[${#array[*]}]="new element" 25 26 # Thanks, S.C. |
The array=( element1 element2 ... elementN ) initialization operation, with the help of command substitution, makes it possible to load the contents of a text file into an array.
|
Clever scripting makes it possible to add array operations.
Example 26-8. Initializing arrays
1 #! /bin/bash 2 # array-assign.bash 3 4 # Array operations are Bash-specific, 5 #+ hence the ".bash" in the script name. 6 7 # Copyright (c) Michael S. Zick, 2003, All rights reserved. 8 # License: Unrestricted reuse in any form, for any purpose. 9 # Version: $ID$ 10 # 11 # Clarification and additional comments by William Park. 12 13 # Based on an example provided by Stephane Chazelas 14 #+ which appeared in the book: Advanced Bash Scripting Guide. 15 16 # Output format of the 'times' command: 17 # User CPU <space> System CPU 18 # User CPU of dead children <space> System CPU of dead children 19 20 # Bash has two versions of assigning all elements of an array 21 #+ to a new array variable. 22 # Both drop 'null reference' elements 23 #+ in Bash versions 2.04, 2.05a and 2.05b. 24 # An additional array assignment that maintains the relationship of 25 #+ [subscript]=value for arrays may be added to newer versions. 26 27 # Constructs a large array using an internal command, 28 #+ but anything creating an array of several thousand elements 29 #+ will do just fine. 30 31 declare -a bigOne=( /dev/* ) # All the files in /dev . . . 32 echo 33 echo 'Conditions: Unquoted, default IFS, All-Elements-Of' 34 echo "Number of elements in array is ${#bigOne[@]}" 35 36 # set -vx 37 38 39 40 echo 41 echo '- - testing: =( ${array[@]} ) - -' 42 times 43 declare -a bigTwo=( ${bigOne[@]} ) 44 # Note parens: ^ ^ 45 times 46 47 48 echo 49 echo '- - testing: =${array[@]} - -' 50 times 51 declare -a bigThree=${bigOne[@]} 52 # No parentheses this time. 53 times 54 55 # Comparing the numbers shows that the second form, pointed out 56 #+ by Stephane Chazelas, is from three to four times faster. 57 # 58 # As William Park explains: 59 #+ The bigTwo array assigned element by element (because of parentheses), 60 #+ whereas bigThree assigned as a single string. 61 # So, in essence, you have: 62 # bigTwo=( [0]="..." [1]="..." [2]="..." ... ) 63 # bigThree=( [0]="... ... ..." ) 64 # 65 # Verify this by: echo ${bigTwo[0]} 66 # echo ${bigThree[0]} 67 68 69 # I will continue to use the first form in my example descriptions 70 #+ because I think it is a better illustration of what is happening. 71 72 # The reusable portions of my examples will actual contain 73 #+ the second form where appropriate because of the speedup. 74 75 # MSZ: Sorry about that earlier oversight folks. 76 77 78 # Note: 79 # ---- 80 # The "declare -a" statements in lines 31 and 43 81 #+ are not strictly necessary, since it is implicit 82 #+ in the Array=( ... ) assignment form. 83 # However, eliminating these declarations slows down 84 #+ the execution of the following sections of the script. 85 # Try it, and see. 86 87 exit 0 |
Adding a superfluous declare -a statement to an array declaration may speed up execution of subsequent operations on the array. |
Example 26-9. Copying and concatenating arrays
1 #! /bin/bash 2 # CopyArray.sh 3 # 4 # This script written by Michael Zick. 5 # Used here with permission. 6 7 # How-To "Pass by Name & Return by Name" 8 #+ or "Building your own assignment statement". 9 10 11 CpArray_Mac() { 12 13 # Assignment Command Statement Builder 14 15 echo -n 'eval ' 16 echo -n "$2" # Destination name 17 echo -n '=( ${' 18 echo -n "$1" # Source name 19 echo -n '[@]} )' 20 21 # That could all be a single command. 22 # Matter of style only. 23 } 24 25 declare -f CopyArray # Function "Pointer" 26 CopyArray=CpArray_Mac # Statement Builder 27 28 Hype() 29 { 30 31 # Hype the array named $1. 32 # (Splice it together with array containing "Really Rocks".) 33 # Return in array named $2. 34 35 local -a TMP 36 local -a hype=( Really Rocks ) 37 38 $($CopyArray $1 TMP) 39 TMP=( ${TMP[@]} ${hype[@]} ) 40 $($CopyArray TMP $2) 41 } 42 43 declare -a before=( Advanced Bash Scripting ) 44 declare -a after 45 46 echo "Array Before = ${before[@]}" 47 48 Hype before after 49 50 echo "Array After = ${after[@]}" 51 52 # Too much hype? 53 54 echo "What ${after[@]:3:2}?" 55 56 declare -a modest=( ${after[@]:2:1} ${after[@]:3:2} ) 57 # ---- substring extraction ---- 58 59 echo "Array Modest = ${modest[@]}" 60 61 # What happened to 'before' ? 62 63 echo "Array Before = ${before[@]}" 64 65 exit 0 |
Example 26-10. More on concatenating arrays
1 #! /bin/bash 2 # array-append.bash 3 4 # Copyright (c) Michael S. Zick, 2003, All rights reserved. 5 # License: Unrestricted reuse in any form, for any purpose. 6 # Version: $ID$ 7 # 8 # Slightly modified in formatting by M.C. 9 10 11 # Array operations are Bash-specific. 12 # Legacy UNIX /bin/sh lacks equivalents. 13 14 15 # Pipe the output of this script to 'more' 16 #+ so it doesn't scroll off the terminal. 17 18 19 # Subscript packed. 20 declare -a array1=( zero1 one1 two1 ) 21 # Subscript sparse ([1] is not defined). 22 declare -a array2=( [0]=zero2 [2]=two2 [3]=three2 ) 23 24 echo 25 echo '- Confirm that the array is really subscript sparse. -' 26 echo "Number of elements: 4" # Hard-coded for illustration. 27 for (( i = 0 ; i < 4 ; i++ )) 28 do 29 echo "Element [$i]: ${array2[$i]}" 30 done 31 # See also the more general code example in basics-reviewed.bash. 32 33 34 declare -a dest 35 36 # Combine (append) two arrays into a third array. 37 echo 38 echo 'Conditions: Unquoted, default IFS, All-Elements-Of operator' 39 echo '- Undefined elements not present, subscripts not maintained. -' 40 # # The undefined elements do not exist; they are not being dropped. 41 42 dest=( ${array1[@]} ${array2[@]} ) 43 # dest=${array1[@]}${array2[@]} # Strange results, possibly a bug. 44 45 # Now, list the result. 46 echo 47 echo '- - Testing Array Append - -' 48 cnt=${#dest[@]} 49 50 echo "Number of elements: $cnt" 51 for (( i = 0 ; i < cnt ; i++ )) 52 do 53 echo "Element [$i]: ${dest[$i]}" 54 done 55 56 # Assign an array to a single array element (twice). 57 dest[0]=${array1[@]} 58 dest[1]=${array2[@]} 59 60 # List the result. 61 echo 62 echo '- - Testing modified array - -' 63 cnt=${#dest[@]} 64 65 echo "Number of elements: $cnt" 66 for (( i = 0 ; i < cnt ; i++ )) 67 do 68 echo "Element [$i]: ${dest[$i]}" 69 done 70 71 # Examine the modified second element. 72 echo 73 echo '- - Reassign and list second element - -' 74 75 declare -a subArray=${dest[1]} 76 cnt=${#subArray[@]} 77 78 echo "Number of elements: $cnt" 79 for (( i = 0 ; i < cnt ; i++ )) 80 do 81 echo "Element [$i]: ${subArray[$i]}" 82 done 83 84 # The assignment of an entire array to a single element 85 #+ of another array using the '=${ ... }' array assignment 86 #+ has converted the array being assigned into a string, 87 #+ with the elements separated by a space (the first character of IFS). 88 89 # If the original elements didn't contain whitespace . . . 90 # If the original array isn't subscript sparse . . . 91 # Then we could get the original array structure back again. 92 93 # Restore from the modified second element. 94 echo 95 echo '- - Listing restored element - -' 96 97 declare -a subArray=( ${dest[1]} ) 98 cnt=${#subArray[@]} 99 100 echo "Number of elements: $cnt" 101 for (( i = 0 ; i < cnt ; i++ )) 102 do 103 echo "Element [$i]: ${subArray[$i]}" 104 done 105 echo '- - Do not depend on this behavior. - -' 106 echo '- - This behavior is subject to change - -' 107 echo '- - in versions of Bash newer than version 2.05b - -' 108 109 # MSZ: Sorry about any earlier confusion folks. 110 111 exit 0 |
--
Arrays permit deploying old familiar algorithms as shell scripts. Whether this is necessarily a good idea is left to the reader to decide.
Example 26-11. An old friend: The Bubble Sort
1 #!/bin/bash 2 # bubble.sh: Bubble sort, of sorts. 3 4 # Recall the algorithm for a bubble sort. In this particular version... 5 6 # With each successive pass through the array to be sorted, 7 #+ compare two adjacent elements, and swap them if out of order. 8 # At the end of the first pass, the "heaviest" element has sunk to bottom. 9 # At the end of the second pass, the next "heaviest" one has sunk next to bottom. 10 # And so forth. 11 # This means that each successive pass needs to traverse less of the array. 12 # You will therefore notice a speeding up in the printing of the later passes. 13 14 15 exchange() 16 { 17 # Swaps two members of the array. 18 local temp=${Countries[$1]} # Temporary storage 19 #+ for element getting swapped out. 20 Countries[$1]=${Countries[$2]} 21 Countries[$2]=$temp 22 23 return 24 } 25 26 declare -a Countries # Declare array, 27 #+ optional here since it's initialized below. 28 29 # Is it permissable to split an array variable over multiple lines 30 #+ using an escape (\)? 31 # Yes. 32 33 Countries=(Netherlands Ukraine Zaire Turkey Russia Yemen Syria \ 34 Brazil Argentina Nicaragua Japan Mexico Venezuela Greece England \ 35 Israel Peru Canada Oman Denmark Wales France Kenya \ 36 Xanadu Qatar Liechtenstein Hungary) 37 38 # "Xanadu" is the mythical place where, according to Coleridge, 39 #+ Kubla Khan did a pleasure dome decree. 40 41 42 clear # Clear the screen to start with. 43 44 echo "0: ${Countries[*]}" # List entire array at pass 0. 45 46 number_of_elements=${#Countries[@]} 47 let "comparisons = $number_of_elements - 1" 48 49 count=1 # Pass number. 50 51 while [ "$comparisons" -gt 0 ] # Beginning of outer loop 52 do 53 54 index=0 # Reset index to start of array after each pass. 55 56 while [ "$index" -lt "$comparisons" ] # Beginning of inner loop 57 do 58 if [ ${Countries[$index]} \> ${Countries[`expr $index + 1`]} ] 59 # If out of order... 60 # Recalling that \> is ASCII comparison operator 61 #+ within single brackets. 62 63 # if [[ ${Countries[$index]} > ${Countries[`expr $index + 1`]} ]] 64 #+ also works. 65 then 66 exchange $index `expr $index + 1` # Swap. 67 fi 68 let "index += 1" # Or, index+=1 on Bash, ver. 3.1 or newer. 69 done # End of inner loop 70 71 # ---------------------------------------------------------------------- 72 # Paulo Marcel Coelho Aragao suggests for-loops as a simpler altenative. 73 # 74 # for (( last = $number_of_elements - 1 ; last > 0 ; last-- )) 75 ## Fix by C.Y. Hunt ^ (Thanks!) 76 # do 77 # for (( i = 0 ; i < last ; i++ )) 78 # do 79 # [[ "${Countries[$i]}" > "${Countries[$((i+1))]}" ]] \ 80 # && exchange $i $((i+1)) 81 # done 82 # done 83 # ---------------------------------------------------------------------- 84 85 86 let "comparisons -= 1" # Since "heaviest" element bubbles to bottom, 87 #+ we need do one less comparison each pass. 88 89 echo 90 echo "$count: ${Countries[@]}" # Print resultant array at end of each pass. 91 echo 92 let "count += 1" # Increment pass count. 93 94 done # End of outer loop 95 # All done. 96 97 exit 0 |
--
Is it possible to nest arrays within arrays?
1 #!/bin/bash 2 # "Nested" array. 3 4 # Michael Zick provided this example, 5 #+ with corrections and clarifications by William Park. 6 7 AnArray=( $(ls --inode --ignore-backups --almost-all \ 8 --directory --full-time --color=none --time=status \ 9 --sort=time -l ${PWD} ) ) # Commands and options. 10 11 # Spaces are significant . . . and don't quote anything in the above. 12 13 SubArray=( ${AnArray[@]:11:1} ${AnArray[@]:6:5} ) 14 # This array has six elements: 15 #+ SubArray=( [0]=${AnArray[11]} [1]=${AnArray[6]} [2]=${AnArray[7]} 16 # [3]=${AnArray[8]} [4]=${AnArray[9]} [5]=${AnArray[10]} ) 17 # 18 # Arrays in Bash are (circularly) linked lists 19 #+ of type string (char *). 20 # So, this isn't actually a nested array, 21 #+ but it's functionally similar. 22 23 echo "Current directory and date of last status change:" 24 echo "${SubArray[@]}" 25 26 exit 0 |
--
Embedded arrays in combination with indirect references create some fascinating possibilities
Example 26-12. Embedded arrays and indirect references
1 #!/bin/bash 2 # embedded-arrays.sh 3 # Embedded arrays and indirect references. 4 5 # This script by Dennis Leeuw. 6 # Used with permission. 7 # Modified by document author. 8 9 10 ARRAY1=( 11 VAR1_1=value11 12 VAR1_2=value12 13 VAR1_3=value13 14 ) 15 16 ARRAY2=( 17 VARIABLE="test" 18 STRING="VAR1=value1 VAR2=value2 VAR3=value3" 19 ARRAY21=${ARRAY1[*]} 20 ) # Embed ARRAY1 within this second array. 21 22 function print () { 23 OLD_IFS="$IFS" 24 IFS=$'\n' # To print each array element 25 #+ on a separate line. 26 TEST1="ARRAY2[*]" 27 local ${!TEST1} # See what happens if you delete this line. 28 # Indirect reference. 29 # This makes the components of $TEST1 30 #+ accessible to this function. 31 32 33 # Let's see what we've got so far. 34 echo 35 echo "\$TEST1 = $TEST1" # Just the name of the variable. 36 echo; echo 37 echo "{\$TEST1} = ${!TEST1}" # Contents of the variable. 38 # That's what an indirect 39 #+ reference does. 40 echo 41 echo "-------------------------------------------"; echo 42 echo 43 44 45 # Print variable 46 echo "Variable VARIABLE: $VARIABLE" 47 48 # Print a string element 49 IFS="$OLD_IFS" 50 TEST2="STRING[*]" 51 local ${!TEST2} # Indirect reference (as above). 52 echo "String element VAR2: $VAR2 from STRING" 53 54 # Print an array element 55 TEST2="ARRAY21[*]" 56 local ${!TEST2} # Indirect reference (as above). 57 echo "Array element VAR1_1: $VAR1_1 from ARRAY21" 58 } 59 60 print 61 echo 62 63 exit 0 64 65 # As the author of the script notes, 66 #+ "you can easily expand it to create named-hashes in bash." 67 # (Difficult) exercise for the reader: implement this. |
--
Arrays enable implementing a shell script version of the Sieve of Eratosthenes. Of course, a resource-intensive application of this nature should really be written in a compiled language, such as C. It runs excruciatingly slowly as a script.
Example 26-13. Complex array application: Sieve of Eratosthenes
1 #!/bin/bash 2 # sieve.sh (ex68.sh) 3 4 # Sieve of Eratosthenes 5 # Ancient algorithm for finding prime numbers. 6 7 # This runs a couple of orders of magnitude slower 8 #+ than the equivalent program written in C. 9 10 LOWER_LIMIT=1 # Starting with 1. 11 UPPER_LIMIT=1000 # Up to 1000. 12 # (You may set this higher . . . if you have time on your hands.) 13 14 PRIME=1 15 NON_PRIME=0 16 17 let SPLIT=UPPER_LIMIT/2 18 # Optimization: 19 # Need to test numbers only halfway to upper limit (why?). 20 21 22 declare -a Primes 23 # Primes[] is an array. 24 25 26 initialize () 27 { 28 # Initialize the array. 29 30 i=$LOWER_LIMIT 31 until [ "$i" -gt "$UPPER_LIMIT" ] 32 do 33 Primes[i]=$PRIME 34 let "i += 1" 35 done 36 # Assume all array members guilty (prime) 37 #+ until proven innocent. 38 } 39 40 print_primes () 41 { 42 # Print out the members of the Primes[] array tagged as prime. 43 44 i=$LOWER_LIMIT 45 46 until [ "$i" -gt "$UPPER_LIMIT" ] 47 do 48 49 if [ "${Primes[i]}" -eq "$PRIME" ] 50 then 51 printf "%8d" $i 52 # 8 spaces per number gives nice, even columns. 53 fi 54 55 let "i += 1" 56 57 done 58 59 } 60 61 sift () # Sift out the non-primes. 62 { 63 64 let i=$LOWER_LIMIT+1 65 # We know 1 is prime, so let's start with 2. 66 67 until [ "$i" -gt "$UPPER_LIMIT" ] 68 do 69 70 if [ "${Primes[i]}" -eq "$PRIME" ] 71 # Don't bother sieving numbers already sieved (tagged as non-prime). 72 then 73 74 t=$i 75 76 while [ "$t" -le "$UPPER_LIMIT" ] 77 do 78 let "t += $i " 79 Primes[t]=$NON_PRIME 80 # Tag as non-prime all multiples. 81 done 82 83 fi 84 85 let "i += 1" 86 done 87 88 89 } 90 91 92 # ============================================== 93 # main () 94 # Invoke the functions sequentially. 95 initialize 96 sift 97 print_primes 98 # This is what they call structured programming. 99 # ============================================== 100 101 echo 102 103 exit 0 104 105 106 107 # -------------------------------------------------------- # 108 # Code below line will not execute, because of 'exit.' 109 110 # This improved version of the Sieve, by Stephane Chazelas, 111 #+ executes somewhat faster. 112 113 # Must invoke with command-line argument (limit of primes). 114 115 UPPER_LIMIT=$1 # From command line. 116 let SPLIT=UPPER_LIMIT/2 # Halfway to max number. 117 118 Primes=( '' $(seq $UPPER_LIMIT) ) 119 120 i=1 121 until (( ( i += 1 ) > SPLIT )) # Need check only halfway. 122 do 123 if [[ -n $Primes[i] ]] 124 then 125 t=$i 126 until (( ( t += i ) > UPPER_LIMIT )) 127 do 128 Primes[t]= 129 done 130 fi 131 done 132 echo ${Primes[*]} 133 134 exit 0 |
Compare this array-based prime number generator with an alternative that does not use arrays, Example A-16.
--
Arrays lend themselves, to some extent, to emulating data structures for which Bash has no native support.
Example 26-14. Emulating a push-down stack
1 #!/bin/bash 2 # stack.sh: push-down stack simulation 3 4 # Similar to the CPU stack, a push-down stack stores data items 5 #+ sequentially, but releases them in reverse order, last-in first-out. 6 7 BP=100 # Base Pointer of stack array. 8 # Begin at element 100. 9 10 SP=$BP # Stack Pointer. 11 # Initialize it to "base" (bottom) of stack. 12 13 Data= # Contents of stack location. 14 # Must use global variable, 15 #+ because of limitation on function return range. 16 17 declare -a stack 18 19 20 push() # Push item on stack. 21 { 22 if [ -z "$1" ] # Nothing to push? 23 then 24 return 25 fi 26 27 let "SP -= 1" # Bump stack pointer. 28 stack[$SP]=$1 29 30 return 31 } 32 33 pop() # Pop item off stack. 34 { 35 Data= # Empty out data item. 36 37 if [ "$SP" -eq "$BP" ] # Stack empty? 38 then 39 return 40 fi # This also keeps SP from getting past 100, 41 #+ i.e., prevents a runaway stack. 42 43 Data=${stack[$SP]} 44 let "SP += 1" # Bump stack pointer. 45 return 46 } 47 48 status_report() # Find out what's happening. 49 { 50 echo "-------------------------------------" 51 echo "REPORT" 52 echo "Stack Pointer = $SP" 53 echo "Just popped \""$Data"\" off the stack." 54 echo "-------------------------------------" 55 echo 56 } 57 58 59 # ======================================================= 60 # Now, for some fun. 61 62 echo 63 64 # See if you can pop anything off empty stack. 65 pop 66 status_report 67 68 echo 69 70 push garbage 71 pop 72 status_report # Garbage in, garbage out. 73 74 value1=23; push $value1 75 value2=skidoo; push $value2 76 value3=FINAL; push $value3 77 78 pop # FINAL 79 status_report 80 pop # skidoo 81 status_report 82 pop # 23 83 status_report # Last-in, first-out! 84 85 # Notice how the stack pointer decrements with each push, 86 #+ and increments with each pop. 87 88 echo 89 90 exit 0 91 92 # ======================================================= 93 94 95 # Exercises: 96 # --------- 97 98 # 1) Modify the "push()" function to permit pushing 99 # + multiple element on the stack with a single function call. 100 101 # 2) Modify the "pop()" function to permit popping 102 # + multiple element from the stack with a single function call. 103 104 # 3) Add error checking to the critical functions. 105 # That is, return an error code, depending on 106 # + successful or unsuccessful completion of the operation, 107 # + and take appropriate action. 108 109 # 4) Using this script as a starting point, 110 # + write a stack-based 4-function calculator. |
--
Fancy manipulation of array "subscripts" may require intermediate variables. For projects involving this, again consider using a more powerful programming language, such as Perl or C.
Example 26-15. Complex array application: Exploring a weird mathematical series
1 #!/bin/bash 2 3 # Douglas Hofstadter's notorious "Q-series": 4 5 # Q(1) = Q(2) = 1 6 # Q(n) = Q(n - Q(n-1)) + Q(n - Q(n-2)), for n>2 7 8 # This is a "chaotic" integer series with strange and unpredictable behavior. 9 # The first 20 terms of the series are: 10 # 1 1 2 3 3 4 5 5 6 6 6 8 8 8 10 9 10 11 11 12 11 12 # See Hofstadter's book, _Goedel, Escher, Bach: An Eternal Golden Braid_, 13 #+ p. 137, ff. 14 15 16 LIMIT=100 # Number of terms to calculate. 17 LINEWIDTH=20 # Number of terms printed per line. 18 19 Q[1]=1 # First two terms of series are 1. 20 Q[2]=1 21 22 echo 23 echo "Q-series [$LIMIT terms]:" 24 echo -n "${Q[1]} " # Output first two terms. 25 echo -n "${Q[2]} " 26 27 for ((n=3; n <= $LIMIT; n++)) # C-like loop conditions. 28 do # Q[n] = Q[n - Q[n-1]] + Q[n - Q[n-2]] for n>2 29 # Need to break the expression into intermediate terms, 30 #+ since Bash doesn't handle complex array arithmetic very well. 31 32 let "n1 = $n - 1" # n-1 33 let "n2 = $n - 2" # n-2 34 35 t0=`expr $n - ${Q[n1]}` # n - Q[n-1] 36 t1=`expr $n - ${Q[n2]}` # n - Q[n-2] 37 38 T0=${Q[t0]} # Q[n - Q[n-1]] 39 T1=${Q[t1]} # Q[n - Q[n-2]] 40 41 Q[n]=`expr $T0 + $T1` # Q[n - Q[n-1]] + Q[n - Q[n-2]] 42 echo -n "${Q[n]} " 43 44 if [ `expr $n % $LINEWIDTH` -eq 0 ] # Format output. 45 then # ^ Modula operator 46 echo # Break lines into neat chunks. 47 fi 48 49 done 50 51 echo 52 53 exit 0 54 55 # This is an iterative implementation of the Q-series. 56 # The more intuitive recursive implementation is left as an exercise. 57 # Warning: calculating this series recursively takes a VERY long time. |
--
Bash supports only one-dimensional arrays, though a little trickery permits simulating multi-dimensional ones.
Example 26-16. Simulating a two-dimensional array, then tilting it
1 #!/bin/bash 2 # twodim.sh: Simulating a two-dimensional array. 3 4 # A one-dimensional array consists of a single row. 5 # A two-dimensional array stores rows sequentially. 6 7 Rows=5 8 Columns=5 9 # 5 X 5 Array. 10 11 declare -a alpha # char alpha [Rows] [Columns]; 12 # Unnecessary declaration. Why? 13 14 load_alpha () 15 { 16 local rc=0 17 local index 18 19 for i in A B C D E F G H I J K L M N O P Q R S T U V W X Y 20 do # Use different symbols if you like. 21 local row=`expr $rc / $Columns` 22 local column=`expr $rc % $Rows` 23 let "index = $row * $Rows + $column" 24 alpha[$index]=$i 25 # alpha[$row][$column] 26 let "rc += 1" 27 done 28 29 # Simpler would be 30 #+ declare -a alpha=( A B C D E F G H I J K L M N O P Q R S T U V W X Y ) 31 #+ but this somehow lacks the "flavor" of a two-dimensional array. 32 } 33 34 print_alpha () 35 { 36 local row=0 37 local index 38 39 echo 40 41 while [ "$row" -lt "$Rows" ] # Print out in "row major" order: 42 do #+ columns vary, 43 #+ while row (outer loop) remains the same. 44 local column=0 45 46 echo -n " " # Lines up "square" array with rotated one. 47 48 while [ "$column" -lt "$Columns" ] 49 do 50 let "index = $row * $Rows + $column" 51 echo -n "${alpha[index]} " # alpha[$row][$column] 52 let "column += 1" 53 done 54 55 let "row += 1" 56 echo 57 58 done 59 60 # The simpler equivalent is 61 # echo ${alpha[*]} | xargs -n $Columns 62 63 echo 64 } 65 66 filter () # Filter out negative array indices. 67 { 68 69 echo -n " " # Provides the tilt. 70 # Explain how. 71 72 if [[ "$1" -ge 0 && "$1" -lt "$Rows" && "$2" -ge 0 && "$2" -lt "$Columns" ]] 73 then 74 let "index = $1 * $Rows + $2" 75 # Now, print it rotated. 76 echo -n " ${alpha[index]}" 77 # alpha[$row][$column] 78 fi 79 80 } 81 82 83 84 85 rotate () # Rotate the array 45 degrees -- 86 { #+ "balance" it on its lower lefthand corner. 87 local row 88 local column 89 90 for (( row = Rows; row > -Rows; row-- )) 91 do # Step through the array backwards. Why? 92 93 for (( column = 0; column < Columns; column++ )) 94 do 95 96 if [ "$row" -ge 0 ] 97 then 98 let "t1 = $column - $row" 99 let "t2 = $column" 100 else 101 let "t1 = $column" 102 let "t2 = $column + $row" 103 fi 104 105 filter $t1 $t2 # Filter out negative array indices. 106 # What happens if you don't do this? 107 done 108 109 echo; echo 110 111 done 112 113 # Array rotation inspired by examples (pp. 143-146) in 114 #+ "Advanced C Programming on the IBM PC," by Herbert Mayer 115 #+ (see bibliography). 116 # This just goes to show that much of what can be done in C 117 #+ can also be done in shell scripting. 118 119 } 120 121 122 #--------------- Now, let the show begin. ------------# 123 load_alpha # Load the array. 124 print_alpha # Print it out. 125 rotate # Rotate it 45 degrees counterclockwise. 126 #-----------------------------------------------------# 127 128 exit 0 129 130 # This is a rather contrived, not to mention inelegant simulation. 131 132 # Exercises: 133 # --------- 134 # 1) Rewrite the array loading and printing functions 135 # in a more intuitive and less kludgy fashion. 136 # 137 # 2) Figure out how the array rotation functions work. 138 # Hint: think about the implications of backwards-indexing an array. 139 # 140 # 3) Rewrite this script to handle a non-square array, 141 # such as a 6 X 4 one. 142 # Try to minimize "distortion" when the array is rotated. |
A two-dimensional array is essentially equivalent to a one-dimensional one, but with additional addressing modes for referencing and manipulating the individual elements by row and column position.
For an even more elaborate example of simulating a two-dimensional array, see Example A-10.
--
For more interesting scripts using arrays, see: