Monday, 17 September 2012

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

The path to the Bash binary itself

bash$ echo $BASH

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

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

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 $$

bash4$ echo $BASHPID

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

The version of Bash installed on the system

bash$ echo $BASH_VERSION

Home directory of the user, usually /home/username

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

host type
Like $MACHTYPE, identifies the system hardware.

bash$ echo $HOSTTYPE

machine type
Identifies the system hardware.

bash$ echo $MACHTYPE

operating system type

bash$ echo $OSTYPE


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.)

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

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

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

The tertiary prompt, displayed in a select loop.

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

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

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@new-host ~]$ echo $SHELL
[sankar@new-host ~]$ echo $TERM

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

Note"$*" 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.

NoteOf 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.  

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

bash$ zzy=68
bash$ declare | grep zzy

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.

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

# Listing the planets.

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


[sankar@new-host loops]$ chmod +x
[sankar@new-host loops]$ ./

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

2. Listing all users on the system.



n=1           # User number

for name in $(awk 'BEGIN{FS=":"}{print $1}' < "$PASSWORD_FILE" )
# Field separator = :    ^^^^^^
# Print first field              ^^^^^^^^
# Get input from password file               ^^^^^^
  echo "USER #$n = $name"
  let "n += 1"

# 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?


2.3. Testing and Branching

case "$variable" in  

  "$condition1" ) 
  "$condition2" ) 


  • 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
    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";;
    [sankar@new-host loops]$ ./
    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))                                  #  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.
      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

No comments:

Post a Comment