XXX 37.3. Bash, version 4¶

Exemple 5. A simple address database¶

#!/bin/bash4
# fetch_address.sh

declare -A address
#       -A option declares associative array.

address[Charles]="414 W. 10th Ave., Baltimore, MD 21236"
address[John]="202 E. 3rd St., New York, NY 10009"
address[Wilma]="1854 Vermont Ave, Los Angeles, CA 90023"


echo "Charles's address is ${address[Charles]}."
# Charles's address is 414 W. 10th Ave., Baltimore, MD 21236.
echo "Wilma's address is ${address[Wilma]}."
# Wilma's address is 1854 Vermont Ave, Los Angeles, CA 90023.
echo "John's address is ${address[John]}."
# John's address is 202 E. 3rd St., New York, NY 10009.

echo

echo "${!address[*]}"   # The array indices ...
# Charles John Wilma

Exemple 6. A somewhat more elaborate address database¶

#!/bin/bash4
# fetch_address-2.sh
# A more elaborate version of fetch_address.sh.

SUCCESS=0
E_DB=99    # Error code for missing entry.

declare -A address
#       -A option declares associative array.


store_address ()
{
  address[$1]="$2"
  return $?
}


fetch_address ()
{
  if [[ -z "${address[$1]}" ]]
  then
    echo "$1's address is not in database."
    return $E_DB
  fi

  echo "$1's address is ${address[$1]}."
  return $?
}


store_address "Lucas Fayne" "414 W. 13th Ave., Baltimore, MD 21236"
store_address "Arvid Boyce" "202 E. 3rd St., New York, NY 10009"
store_address "Velma Winston" "1854 Vermont Ave, Los Angeles, CA 90023"
#  Exercise:
#  Rewrite the above store_address calls to read data from a file,
#+ then assign field 1 to name, field 2 to address in the array.
#  Each line in the file would have a format corresponding to the above.
#  Use a while-read loop to read from file, sed or awk to parse the fields.

fetch_address "Lucas Fayne"
# Lucas Fayne's address is 414 W. 13th Ave., Baltimore, MD 21236.
fetch_address "Velma Winston"
# Velma Winston's address is 1854 Vermont Ave, Los Angeles, CA 90023.
fetch_address "Arvid Boyce"
# Arvid Boyce's address is 202 E. 3rd St., New York, NY 10009.
fetch_address "Bozo Bozeman"
# Bozo Bozeman's address is not in database.

exit $?   # In this case, exit code = 99, since that is function return.

See Example A-53 for an interesting usage of an associative array .

 address[   ]="Blank"
# Error!

address[   ]="Blank"   # Error!

address[   ]="Blank"   # Error!

• Enhancements to the case construct:

the `` ;;& `` and `` ;& `` terminators.

Exemple 7. Testing characters¶

#!/bin/bash4

test_char ()
{
  case "$1" in
    [[:print:]] )  echo "$1 is a printable character.";;&       #
    # The ;;& terminator continues to the next pattern test.
    [[:alnum:]] )  echo "$1 is an alpha/numeric character.";;&  # v
    [[:alpha:]] )  echo "$1 is an alphabetic character.";;&     # v
    [[:lower:]] )  echo "$1 is a lowercase alphabetic character.";;&
    [[:digit:]] )  echo "$1 is an numeric character.";&         #
    # The ;& terminator executes the next statement ...         #
    %%%@@@@@    )  echo "********************************";;    # v
#   ^^^^^^^^  ... even with a dummy pattern.
  esac
}

echo

test_char 3
# 3 is a printable character.
# 3 is an alpha/numeric character.
# 3 is an numeric character.
# ********************************
echo

test_char m
# m is a printable character.
# m is an alpha/numeric character.
# m is an alphabetic character.
# m is a lowercase alphabetic character.
echo

test_char /
# / is a printable character.

echo

# The ;;& terminator can save complex if/then conditions.
# The ;& is somewhat less useful.

• The new coproc builtin enables two parallel

processes to communicate and interact. As Chet Ramey states in the Bash FAQ ` [2] <bashver4.html#FTN.AEN21068>`__ , ver. 4.01:

There is a new ‘coproc’ reserved word that specifies a coprocess:

an asynchronous command run with two pipes connected to the creating

shell. Coprocs can be named. The input and output file descriptors

and the PID of the coprocess are available to the calling shell in

variables with coproc-specific names. George Dimitriu explains,

”... coproc ... is a feature used in Bash process substitution,

which now is made publicly available.”

This means it can be explicitly invoked in a script, rather than

just being a behind-the-scenes mechanism used by Bash.

Coprocesses use file descriptors . File descriptors enable processes and pipes to communicate .

#!/bin/bash4
# A coprocess communicates with a while-read loop.


coproc { cat mx_data.txt; sleep 2; }
#                         ^^^^^^^
# Try running this without "sleep 2" and see what happens.

while read -u ${COPROC[0]} line    #  ${COPROC[0]} is the
do                                 #+ file descriptor of the coprocess.
  echo "$line"sed -e 's/line/NOT-ORIGINAL-TEXT/'
done

kill $COPROC_PID                   #  No longer need the coprocess,
                                   #+ so kill its PID.

But, be careful!

#!/bin/bash4

echo; echo
a=aaa
b=bbb
c=ccc

coproc echo "one two three"
while read -u ${COPROC[0]} a b c;  #  Note that this loop
do                                 #+ runs in a subshell.
  echo "Inside while-read loop: ";
  echo "a = $a"; echo "b = $b"; echo "c = $c"
  echo "coproc file descriptor: ${COPROC[0]}"
done

# a = one
# b = two
# c = three
# So far, so good, but ...

echo "-----------------"
echo "Outside while-read loop: "
echo "a = $a"  # a =
echo "b = $b"  # b =
echo "c = $c"  # c =
echo "coproc file descriptor: ${COPROC[0]}"
echo
#  The coproc is still running, but ...
#+ it still doesn't enable the parent process
#+ to "inherit" variables from the child process, the while-read loop.

#  Compare this to the "badread.sh" script.

#!/bin/bash4

coproc cpname { for

i in {0..10}; do echo “i ndex = $i”; done; }

# ^^^^^^ This i

s a named coprocess.

read -u ${cpname[0]} echo $REPLY

# index = 0

echo ${COPROC[0]}

#+ No output ... the cop rocess timed out

# after the first l

oop iteration.

# However, George Di

mitriu has a partial fix .

coproc cpname { for

i in {0..10}; do echo “i ndex = $i”; done; sleep 1;

echo hi > myo; cat -

>> myo; }

# ^^^^^ This i

s a named coprocess.

echo “I am main”$‘0

4’ >&${cpname[1]}

myfd=${cpname[0]} echo myfd=$myfd

### while read -u $m

yfd

### do ### echo $REPLY; ### done

echo $cpname_PID

# Run this with and

without the commented-o

ut while-loop, and it is

#+ apparent that eac

h process, the executing

shell and the coprocess

,

#+ waits for the oth

er to finish writing in its own write-enabled pi pe.

#!/bin/bash4

coproc cpname { for i in {0..10}; do echo "index = $i"; done; }
#      ^^^^^^ This is a *named* coprocess.
read -u ${cpname[0]}
echo $REPLY         #  index = 0
echo ${COPROC[0]}   #+ No output ... the coprocess timed out
#  after the first loop iteration.



# However, George Dimitriu has a partial fix.

coproc cpname { for i in {0..10}; do echo "index = $i"; done; sleep 1;
echo hi > myo; cat - >> myo; }
#       ^^^^^ This is a *named* coprocess.

echo "I am main"$'\04' >&${cpname[1]}
myfd=${cpname[0]}
echo myfd=$myfd

### while read -u $myfd
### do
###   echo $REPLY;
### done

echo $cpname_PID

#  Run this with and without the commented-out while-loop, and it is
#+ apparent that each process, the executing shell and the coprocess,
#+ waits for the other to finish writing in its own write-enabled pipe.

#!/bin/bash4

coproc cpname { for i in {0..10}; do echo "index = $i"; done; }
#      ^^^^^^ This is a *named* coprocess.
read -u ${cpname[0]}
echo $REPLY         #  index = 0
echo ${COPROC[0]}   #+ No output ... the coprocess timed out
#  after the first loop iteration.



# However, George Dimitriu has a partial fix.

coproc cpname { for i in {0..10}; do echo "index = $i"; done; sleep 1;
echo hi > myo; cat - >> myo; }
#       ^^^^^ This is a *named* coprocess.

echo "I am main"$'\04' >&${cpname[1]}
myfd=${cpname[0]}
echo myfd=$myfd

### while read -u $myfd
### do
###   echo $REPLY;
### done

echo $cpname_PID

#  Run this with and without the commented-out while-loop, and it is
#+ apparent that each process, the executing shell and the coprocess,
#+ waits for the other to finish writing in its own write-enabled pipe.

• The new mapfile builtin makes it possible to load an array with

the contents of a text file without using a loop or command substitution .

#!/bin/bash4

mapfile Arr1 < $0
# Same result as     Arr1=( $(cat $0) )
echo "${Arr1[@]}"  # Copies this entire script out to stdout.

echo "--"; echo

# But, not the same as   read -a   !!!
read -a Arr2 < $0
echo "${Arr2[@]}"  # Reads only first line of script into the array.

exit

• The read builtin got a minor facelift. The `` -t `` timeout option now accepts (decimal) fractional values ` [3]

  <bashver4.html#FTN.AEN21096>`__ and the `` -i `` option

  permits preloading the edit buffer. ` [4]

  <bashver4.html#FTN.AEN21101>`__ Unfortunately, these enhancements

  are still a work in progress and not (yet) usable in scripts.

Exemple 8. Reading N characters¶

#!/bin/bash
# Requires Bash version -ge 4.1 ...

num_chars=61

read -N $num_chars var < $0   # Read first 61 characters of script!
echo "$var"
exit

####### Output of Script #######

#!/bin/bash
# Requires Bash version -ge 4.1 ...

num_chars=61

• Here documents embedded in `` $( ... ) `` command substitution <varassignment.html#COMMANDSUBREF0>`__ constructs may terminate with a simple ) .

Exemple 9. Using a here document to set a variable¶

#!/bin/bash
# here-commsub.sh
# Requires Bash version -ge 4.1 ...

multi_line_var=$( cat <<ENDxxx
------------------------------
This is line 1 of the variable
This is line 2 of the variable
This is line 3 of the variable
------------------------------
ENDxxx)

#  Rather than what Bash 4.0 requires:
#+ that the terminating limit string and
#+ the terminating close-parenthesis be on separate lines.

# ENDxxx
# )


echo "$multi_line_var"

#  Bash still emits a warning, though.
#  warning: here-document at line 10 delimited
#+ by end-of-file (wanted `ENDxxx')

37.3.2. Bash, version 4.2

Version 4.2 of Bash, released in February, 2011, contains a number of

new features and enhancements, in addition to bugfixes.

• Bash now supports the the `` u `` and `` U `` Unicode escape.

  Unicode is a cross-platform standard for encoding into numerical values letters and graphic symbols. This permits representing and displaying characters in foreign alphabets and unusual fonts.

  echo -e '\u2630'   # Horizontal triple bar character.
  # Equivalent to the more roundabout:
  echo -e "\xE2\x98\xB0"
                     # Recognized by earlier Bash versions.
  
  echo -e '\u220F'   # PI (Greek letter and mathematical symbol)
  echo -e '\u0416'   # Capital "ZHE" (Cyrillic letter)
  echo -e '\u2708'   # Airplane (Dingbat font) symbol
  echo -e '\u2622'   # Radioactivity trefoil
  
  echo -e "The amplifier circuit requires a 100 \u2126 pull-up resistor."
  
  
  unicode_var='\u2640'
  echo -e $unicode_var      # Female symbol
  printf "$unicode_var \n"  # Female symbol, with newline
  
  
  #  And for something a bit more elaborate . . .
  
  #  We can store Unicode symbols in an associative array,
  #+ then retrieve them by name.
  #  Run this in a gnome-terminal or a terminal with a large, bold font
  #+ for better legibility.
  
  declare -A symbol  # Associative array.
  
  symbol[script_E]='\u2130'
  symbol[script_F]='\u2131'
  symbol[script_J]='\u2110'
  symbol[script_M]='\u2133'
  symbol[Rx]='\u211E'
  symbol[TEL]='\u2121'
  symbol[FAX]='\u213B'
  symbol[care_of]='\u2105'
  symbol[account]='\u2100'
  symbol[trademark]='\u2122'
  
  
  echo -ne "${symbol[script_E]}   "
  echo -ne "${symbol[script_F]}   "
  echo -ne "${symbol[script_J]}   "
  echo -ne "${symbol[script_M]}   "
  echo -ne "${symbol[Rx]}   "
  echo -ne "${symbol[TEL]}   "
  echo -ne "${symbol[FAX]}   "
  echo -ne "${symbol[care_of]}   "
  echo -ne "${symbol[account]}   "
  echo -ne "${symbol[trademark]}   "
  echo
  

• When the `` lastpipe `` shell option is set, the last command in a pipe doesn’t run in a subshell .

Exemple 10. Piping input to a read¶

#!/bin/bash
# lastpipe-option.sh

line=''                   # Null value.
echo "\$line = "$line""   # $line =

echo

shopt -s lastpipe         # Error on Bash version -lt 4.2.
echo "Exit status of attempting to set \"lastpipe\" option is $?"
#     1 if Bash version -lt 4.2, 0 otherwise.

echo

head -1 $0read line    # Pipe the first line of the script to read.
#            ^^^^^^^^^      Not in a subshell!!!

echo "\$line = "$line""
# Older Bash releases       $line =
# Bash version 4.2          $line = #!/bin/bash

This option offers possible “fixups” for these example scripts: Example 34-3 and Example 15-8 .

• Negative array indices permit counting backwards from the end of an array.

Exemple 11. Negative array indices¶

#!/bin/bash
# neg-array.sh
# Requires Bash, version -ge 4.2.

array=( zero one two three four five )   # Six-element array.
#         0    1   2    3    4    5
#        -6   -5  -4   -3   -2   -1

# Negative array indices now permitted.
echo ${array[-1]}   # five
echo ${array[-2]}   # four
# ...
echo ${array[-6]}   # zero
# Negative array indices count backward from the last element+1.

# But, you cannot index past the beginning of the array.
echo ${array[-7]}   # array: bad array subscript


# So, what is this new feature good for?

echo "The last element in the array is "${array[-1]}""
# Which is quite a bit more straightforward than:
echo "The last element in the array is "${array[${#array[*]}-1]}""
echo

# And ...

index=0
let "neg_element_count = 0 - ${#array[*]}"
# Number of elements, converted to a negative number.

while [ $index -gt $neg_element_count ]; do
  ((index--)); echo -n "${array[index]} "
done  # Lists the elements in the array, backwards.
      # We have just simulated the "tac" command on this array.

echo

# See also neg-offset.sh.

• Substring extraction uses a negative length parameter to specify an offset from the end of the target string.

Exemple 12. Negative parameter in string-extraction construct¶

#!/bin/bash
# Bash, version -ge 4.2
# Negative length-index in substring extraction.
# Important: It changes the interpretation of this construct!

stringZ=abcABC123ABCabc

echo ${stringZ}                              # abcABC123ABCabc
#                   Position within string:    0123456789.....
echo ${stringZ:2:3}                          #   cAB
#  Count 2 chars forward from string beginning, and extract 3 chars.
#  ${string:position:length}

#  So far, nothing new, but now ...

                                             # abcABC123ABCabc
#                   Position within string:    0123....6543210
echo ${stringZ:3:-6}                         #    ABC123
#                ^
#  Index 3 chars forward from beginning and 6 chars backward from end,
#+ and extract everything in between.
#  ${string:offset-from-front:offset-from-end}
#  When the "length" parameter is negative,
#+ it serves as an offset-from-end parameter.

#  See also neg-array.sh.

` [1] <bashver4.html#AEN21025>`__

To be more specific, Bash 4+ has limited support for associative arrays. It’s a bare-bones implementation, and it lacks the much of the functionality of such arrays in other programming languages. Note, however, that associative arrays in Bash seem to execute faster and more efficiently than numerically-indexed arrays .

` [2] <bashver4.html#AEN21068>`__

Copyright 1995-2009 by Chester Ramey.

` [3] <bashver4.html#AEN21096>`__

This only works with pipes and certain other special files.

` [4] <bashver4.html#AEN21101>`__

But only in conjunction with readline , i.e., from the command-line.

` [5] <bashver4.html#AEN21179>`__

And while you’re at it, consider fixing the notorious piped read problem.