Chapter 26. Arrays
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 |
As we have seen, a convenient way of initializing an entire array is the array=( element1 element2 ... elementN) notation.
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. 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. The 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 # ^ Modulo 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: