Indirect References to Variables

9.5. Indirect References to Variables

Assume that the value of a variable is the name of a second variable. Is it somehow possible to retrieve the value of this second variable from the first one? For example, if a=letter_of_alphabet and letter_of_alphabet=z, can a reference to a return z? This can indeed be done, and it is called an indirect reference. It uses the unusual eval var1=\$$var2 notation.

Example 9-19. Indirect References

#!/bin/bash

# Indirect variable referencing.

a=letter_of_alphabet letter_of_alphabet=z

echo

#Direct reference. echo "a = $a"

#Indirect reference. eval a=\$$a

echo "Now a = $a"

echo

# Now, let's try changing the second order reference.

t=table_cell_3 table_cell_3=24

echo "\"table_cell_3\" = $table_cell_3"

echo -n "dereferenced \"t\" = "; eval echo \$$t

#In this simple case,

#eval t=\$$t; echo "\"t\" = $t"

#also works (why?).

echo

t=table_cell_3 NEW_VAL=387 table_cell_3=$NEW_VAL

echo "Changing value of \"table_cell_3\" to $NEW_VAL." echo "\"table_cell_3\" now $table_cell_3"

echo -n "dereferenced \"t\" now "; eval echo \$$t

# "eval" takes the two arguments "echo" and "\$$t" (set equal to $table_cell_3) echo

http://tldp.org/LDP/abs/html/ivr.html (1 of 3) [7/15/2002 6:35:12 PM]

Indirect References to Variables

#(Thanks, S.C., for clearing up the above behavior.)

#Another method is the ${!t} notation, discussed in "Bash, version 2" section.

#See also example "ex78.sh".

exit 0

Example 9-20. Passing an indirect reference to awk

#!/bin/bash

#Another version of the "column totaler" script

#that adds up a specified column (of numbers) in the target file.

#This uses indirect references.

ARGS=2

E_WRONGARGS=65

if [ $# -ne "$ARGS" ] # Check for proper no. of command line args. then

echo "Usage: `basename $0` filename column-number" exit $E_WRONGARGS

fi

filename=$1 column_number=$2

#===== Same as original script, up to this point =====#

# A multi-line awk script is invoked by awk ' ..... '

# Begin awk script.

# ------------------------------------------------

awk "

{ total += \$${column_number} # indirect reference

}

END {

print total

}

""$filename"

#------------------------------------------------

#End awk script.

#Indirect variable reference avoids the hassles

#of referencing a shell variable within the embedded awk script.

#Thanks, Stephane Chazelas.

http://tldp.org/LDP/abs/html/ivr.html (2 of 3) [7/15/2002 6:35:12 PM]

Indirect References to Variables

exit 0

This method of indirect referencing is a bit tricky. If the second order variable changes its value, then the first order variable must be properly dereferenced (as in the above example). Fortunately, the ${!variable} notation introduced with version 2 of Bash (see Example 35-2) makes indirect referencing more intuitive.

http://tldp.org/LDP/abs/html/ivr.html (3 of 3) [7/15/2002 6:35:12 PM]

$RANDOM: generate random integer

9.6. $RANDOM: generate random integer

$RANDOM is an internal Bash function (not a constant) that returns a pseudorandom integer in the range 0 - 32767. $RANDOM should not be used to generate an encryption key.

Example 9-21. Generating random numbers

#!/bin/bash

#$RANDOM returns a different random integer at each invocation.

#Nominal range: 0 - 32767 (signed 16-bit integer).

MAXCOUNT=10

count=1

#If you need a random int within a certain range, use the 'modulo' operator.

#This returns the remainder of a division operation.

RANGE=500

echo

number=$RANDOM

let "number %= $RANGE"

echo "Random number less than $RANGE --- $number"

echo

#If you need a random int greater than a lower bound,

#then set up a test to discard all numbers below that.

FLOOR=200

number=0 #initialize

while [ "$number" -le $FLOOR ] do

number=$RANDOM done

http://tldp.org/LDP/abs/html/randomvar.html (1 of 6) [7/15/2002 6:35:13 PM]

$RANDOM: generate random integer

echo "Random number greater than $FLOOR --- $number" echo

#May combine above two techniques to retrieve random number between two limits. number=0 #initialize

while [ "$number" -le $FLOOR ] do

number=$RANDOM

let "number %= $RANGE" # Scales $number down within $RANGE. done

echo "Random number between $FLOOR and $RANGE --- $number" echo

#Generate binary choice, that is, "true" or "false" value.

BINARY=2 number=$RANDOM T=1

let "number %= $BINARY"

#let "number >>= 14" gives a better random distribution

#(right shifts out everything except last binary digit). if [ "$number" -eq $T ]

then

echo "TRUE" else

echo "FALSE"

fi

echo

# May generate toss of the dice. SPOTS=7 # Modulo 7 gives range 0 - 6. DICE=2

ZERO=0

die1=0

die2=0

# Tosses each die separately, and so gives correct odds.

let "die1 = $RANDOM % $SPOTS" # Roll first one. done

while [ "$die2" -eq $ZERO ] do

let "die2 = $RANDOM % $SPOTS" # Roll second one. done

let "throw = $die1 + $die2"

echo "Throw of the dice = $throw" echo

http://tldp.org/LDP/abs/html/randomvar.html (2 of 6) [7/15/2002 6:35:13 PM]

$RANDOM: generate random integer

exit 0

Just how random is RANDOM? The best way to test this is to write a script that tracks the distribution of "random"

numbers generated by RANDOM. Let's roll a RANDOM die a few times...

Example 9-22. Rolling the die with RANDOM

#!/bin/bash

# How random is RANDOM?

2)let "threes += 1";;

3)let "fours += 1";;

4)let "fives += 1";;

5)let "sixes += 1";;

esac

}

echo

while [ "$throw" -lt "$MAXTHROWS" ]

http://tldp.org/LDP/abs/html/randomvar.html (3 of 6) [7/15/2002 6:35:13 PM]

$RANDOM: generate random integer

do

let "die1 = RANDOM % $PIPS" update_count $die1

let "throw += 1" done

print_result

#The scores should distribute fairly evenly, assuming RANDOM is fairly random.

#With $MAXTHROWS at 600, all should cluster around 100, plus-or-minus 20 or so.

#Keep in mind that RANDOM is a pseudorandom generator,

#and not a spectacularly good one at that.

#Exercise (easy):

#---------------

#Rewrite this script to flip a coin 1000 times.

#Choices are "HEADS" or "TAILS".

exit 0

As we have seen in the last example, it is best to "reseed" the RANDOM generator each time it is invoked. Using the same seed for RANDOM repeats the same series of numbers. (This mirrors the behavior of the random() function in C.)

Example 9-23. Reseeding RANDOM

#!/bin/bash

# seeding-random.sh: Seeding the RANDOM variable.

random_numbers ()

{

count=0

while [ "$count" -lt "$MAXCOUNT" ] do

number=$RANDOM echo -n "$number " let "count += 1"

done

}

http://tldp.org/LDP/abs/html/randomvar.html (4 of 6) [7/15/2002 6:35:13 PM]

$RANDOM: generate random integer

# RANDOM=$$ seeds RANDOM from process id of script.

#It is also possible to seed RANDOM from 'time' or 'date' commands.

#Getting fancy...

SEED=$(head -1 /dev/urandom | od -N 1 | awk '{ print $2 }')

#Pseudo-random output fetched

#+ from /dev/urandom (system pseudo-random device-file),

#+ then converted to line of printable (octal) numbers by "od", #+ finally "awk" retrieves just one number for SEED. RANDOM=$SEED

random_numbers

echo; echo

exit 0

The /dev/urandom device-file provides a means of generating much more "random" pseudorandom numbers than the $RANDOM variable. dd if=/dev/urandom of=targetfile bs=1 count=XX creates a file of well-scattered pseudorandom numbers. However, assigning these numbers to a variable in a script requires a workaround, such as filtering through od (as in above example) or using dd (see Example 12-41).

There are also other means of generating pseudorandom numbers in a script. Awk provides a convenient means of doing this.

Example 9-24. Pseudorandom numbers, using awk

#!/bin/bash

#random2.sh: Returns a pseudorandom number in the range 0 - 1.

#Uses the awk rand() function.

AWKSCRIPT=' { srand(); print rand() } '

#Command(s) / parameters passed to awk

#Note that srand() reseeds awk's random number generator.

echo -n "Random number between 0 and 1 = " echo | awk "$AWKSCRIPT"

exit 0

#Exercises:

#---------

#1) Using a loop construct, print out 10 different random numbers.

#(Hint: you must reseed the "srand()" function with a different seed

http://tldp.org/LDP/abs/html/randomvar.html (5 of 6) [7/15/2002 6:35:13 PM]

$RANDOM: generate random integer

#in each pass through the loop. What happens if you fail to do this?)

#2) Using an integer multiplier as a scaling factor, generate random numbers

#in the range between 10 and 100.

#3) Same as exercise #2, above, but generate random integers this time.

http://tldp.org/LDP/abs/html/randomvar.html (6 of 6) [7/15/2002 6:35:13 PM]