Beginner's Introduction to Shell Script: PART 2

Beginner's Introduction to Shell Script: PART 1

Beginner's Introduction to Shell Script:PART 2
1. Beyond the Basics

1.1. Internal Variables:

Builtin variables:

variables affecting bash script behavior

$BASH

The path to the Bash binary itself

bash$ echo $BASH /bin/bash

$BASH_ENV

An environmental variable pointing to a Bash startup file to be read when a script is invoked

$BASH_SUBSHELL

A variable indicating the subshell level. This is a new addition to Bash, version 3.
See Example 21-1 for usage.

$BASHPID

Process ID of the current instance of Bash. This is not the same as the $$ variable, but it often gives the same result.

bash4$ echo $$ 11015 bash4$ echo $BASHPID 11015 bash4$ ps ax | grep bash4 11015 pts/2 R 0:00 bash4

$BASH_VERSION

The version of Bash installed on the system

bash$ echo $BASH_VERSION 3.2.25(1)-release

$HOME

Home directory of the user, usually /home/username

$HOSTNAME

The hostname command assigns the system host name at bootup in an init script. However, the gethostname() function sets the Bash internal variable$HOSTNAME.

$HOSTTYPE

host type
Like $MACHTYPE, identifies the system hardware.

bash$ echo $HOSTTYPE i686

$MACHTYPE

machine type
Identifies the system hardware.

bash$ echo $MACHTYPE i686

$OSTYPE

operating system type

bash$ echo $OSTYPE linux

$PPID

The $PPID of a process is the process ID (pid) of its parent process. [2]
Compare this with the pidof command.(pidof -- find the process ID of a running program.)

$PROMPT_COMMAND

A variable holding a command to be executed just before the primary prompt, $PS1 is to be displayed.

$PS1

This is the main prompt, seen at the command-line.

$PS2

The secondary prompt, seen when additional input is expected. It displays as ">".

$PS3

The tertiary prompt, displayed in a select loop.

$PS4

The quartenary prompt, shown at the beginning of each line of output when invoking a script with the -x option. It displays as "+".

$PWD

Working directory (directory you are in at the time)
This is the analog to the pwd builtin command.

$UID

User ID number

The variables $ENV, $LOGNAME, $MAIL, $TERM, $USER, and $USERNAME are not Bash builtins. 

These are, however, often set asenvironmental variables in one of the Bash startup files. $SHELL, the name of the user's login shell, may be set from /etc/passwd or in an "init" script, and it is likewise not a Bash builtin.

sankar@new-host ~]$ echo $LOGNAME
sankar
[sankar@new-host ~]$ echo $SHELL
/bin/bash
[sankar@new-host ~]$ echo $TERM
xterm

Positional Parameters

$0, $1, $2, etc.

Positional parameters, passed from command line to script, passed to a function, or set to a variable..

$#

Number of command-line arguments [4] or positional parameters..

$*

All of the positional parameters, seen as a single word

"$*" must be quoted.

$@

Same as $*, but each parameter is a quoted string, that is, the parameters are passed on intact, without interpretation or expansion. This means, among other things, that each parameter in the argument list is seen as a separate word.

Of course, "$@" should be quoted.

$?

Exit status of a command, function, or the script itself..

$$

Process ID (PID) of the script itself. The $$ variable often finds use in scripts to construct "unique" temp file names . This is usually simpler than invoking mktemp.

1.2. Typing variables: declare or typeset

 permit modifying the properties of variables. This is a very weak form of the typing.

declare/typeset options:

 -r readonly

(declare -r var1 works the same as readonly var1)

     declare -r var1=1
     echo "var1 = $var1"   # var1 = 1

  

 -i integer

declare -i number # The script will treat subsequent occurrences of "number" as an integer. number=3 echo "Number = $number" # Number = 3

-a array

declare -a indices

-f function(s)

    declare -f function_name

-x export

declare -x var3

This declares a variable as available for exporting outside the environment of the script itself.

-x var=$value

declare -x var3=373

NOTE:The declare command can be helpful in identifying variables, environmental..

bash$ declare | grep HOME
HOME=/home/bozo

bash$ zzy=68
bash$ declare | grep zzy
zzy=68

1.3. $RANDOM: generate random integer

   $RANDOM is an internal Bash function (not a constant) that returns a pseudo random integer in the range 0 - 32767. 

1.4. Manipulating Variables
Bash supports a surprising number of string manipulation operations.

2. Loops and Branches

2.1. Loops
for loops



This is the basic looping construct.


Syntax: 

for arg  in [list]
do 
 command(s)... 
done

----------------
If do is on same line as for..

for arg  in [list] ; do 


Note: During each pass through the loop, arg takes on the value of each successive variable in the list.

The argument list may contain wild cards.

Example  Simple for loops

1. $vim sfloop.sh

#!/bin/bash

# Listing the planets.

for planet in Mercury Venus Earth Mars Jupiter Saturn Uranus Neptune Pluto
do
  echo $planet  # Each planet on a separate line.
done

:wq

[sankar@new-host loops]$ chmod +x sfloop.sh
[sankar@new-host loops]$ ./sfloop.sh
Mercury
Venus
Earth
Mars
Jupiter
Saturn
Uranus
Neptune
Pluto

Each [list] element may contain multiple parameters. This is useful when processing parameters in groups.

2. Listing all users on the system.

$vim listallusers.sh

#!/bin/bash
# userlist.sh

PASSWORD_FILE=/etc/passwd
n=1           # User number

for name in $(awk 'BEGIN{FS=":"}{print $1}' < "$PASSWORD_FILE" )

# Field separator = :    ^^^^^^
# Print first field              ^^^^^^^^
# Get input from password file               ^^^^^^
do
  echo "USER #$n = $name"
  let "n += 1"
done  


# USER #1 = root
# USER #2 = bin
# USER #3 = daemon
# ...
# USER #30 = bozo

exit $?

#  Discussion:
#  ----------
#How is it that an ordinary user, or a script run by same,
#+ can read /etc/passwd? (Hint: Check the /etc/passwd file permissions.)
#  Isn't this a security hole? Why or why not?

:wq

2.3. Testing and Branching
case "$variable" in  

  "$condition1" ) 
 command... 
 ;;  

  "$condition2" ) 
 command... 
 ;;  

esac






Quoting the variables is not mandatory, since word splitting does not take place.
Each test line ends with a right paren ).
Each condition block ends with a double semicolon ;;.
If a condition tests true, then the associated commands execute and the case block terminates.
The entire case block ends with an esac (case spelled backwards).




eg:

$vim machinetype.sh





case $( arch ) in   # $( arch ) returns machine architecture.
  ( i386 ) echo "80386-based machine";;
# ^      ^
  ( i486 ) echo "80486-based machine";;
  ( i586 ) echo "Pentium-based machine";;
  ( i686 ) echo "Pentium2+-based machine";;
  (    * ) echo "Other type of machine";;
esac


:wq


[sankar@new-host loops]$ ./machinetype.sh
Pentium2+-based machine




3. Arithmetic Expansion
Arithmetic expansion provides a powerful tool for performing (integer) arithmetic operations in scripts. 


z=`expr $z + 3`          # The 'expr' command performs the expansion.


Arithmetic expansion with double parentheses, and using let


z=$(($z+3))
z=$((z+3))                                  #  Also correct.
                                            #  Within double parentheses,
                                            #+ parameter dereferencing
                                            #+ is optional.

# $((EXPRESSION)) is arithmetic expansion.  #  Not to be confused with
                                            #+ command substitution.



# You may also use operations within double parentheses without assignment.

  n=0
  echo "n = $n"                             # n = 0

  (( n += 1 ))                              # Increment.
# (( $n += 1 )) is incorrect!
  echo "n = $n"                             # n = 1


let z=z+3
let "z += 3"  #  Quotes permit the use of spaces in variable assignment.
              #  The 'let' operator actually performs arithmetic evaluation,
              #+ rather than expansion.












Beginner's Introduction to Shell Script: PART 3
Beginner's Introduction to Shell Script: PART 4
Beginner's Introduction to Shell Script: PART 5
Beginner's Introduction to Shell Script: PART 6