IT 244: Introduction to Linux/Unix

IT 244: Introduction to Linux/Unix
Class 25

Today's Topics

Review

for ... in ... Loops
for Loops
Three Statement for Loops
while Loops
until Loops
continue
break

New Material

case Statement
select Statement
read Command
An Interesting Use for the read Command
Here Documents
Using case and for in a Real World Script

Homework 11

I have posted homework 11 here.

It is due this coming Sunday at 11:59 PM.

This is the last homework assignment.

Final Exam

The final exam will be given on Tuesday, December 19th from 3:00 - 6:00.

The exam will be given in McCormack 3-430.

There will be 50 questions, which will be similar to the questions on the mid-term and the quizzes.

As with the Mid-term, 60% of the questions will come from the ungraded Class Quizzes.

The questions will cover all of the material for this course.

The last class, Tuesday, December 12th, will be a review session.

You will only be responsible for the material contained in the Class Notes for that class, and the Class Notes for the review session for the Mid-term, which you will find here.

Although the time alloted for the exam is 3 hours, I would expect that most of you would not need that much time.

You will not be able to leave the room until you turn in your exam paper so you should visit the restroom before you take the test.

The final is a closed book exam.

Review

`for ... in ...` Loops

After the conditional statement ...
the most common programming construct is the loop
Bash provides many kinds of loops,

but we'll start with the for ... in loop

    for LOOP_VARIABLE in LIST_OF_VALUES
    do
        COMMAND_1
        COMMAND_2
        ...
    done

The do keyword must be on a different line from the for keyword ...
unless you place a semicolon, ;, before the do
The block of loop commands start after the do keyword ...
and end just before the done keyword
The do keyword is like the then keyword in an if statement
With a for ... in loop, Bash
- Assigns the first value in the LIST_OF_VALUES ...
  to the variable specified by LOOP_VARIABLE
- Executes the block of commands between do and done
- Assigns the next value in the LIST_OF_VALUES
  to the LOOP_VARIABLE
- Executes the commands between do and the done again
- And so on until each value in LIST_OF_VALUES has been used

Here is an example

    $ cat fruit.sh
    #! /bin/bash
    #
    # demonstrates the for in loop

    for fruit in apples oranges pears bananas
    do
        echo $fruit
    done
    echo Task complete.
    
    $ ./fruit.sh 
    apples
    oranges
    pears
    bananas
    Task complete.

Notice that the variable fruit ...
which appears after the for keyword, ...
does not have a dollar sign, $ , in front of it
That's because we are dealing with the variable ...
not its value

`for` Loops

The for loop has a simpler structure than the for ... in ... loop

    for LOOP_VARIABLE
    do
        COMMAND_1
        COMMAND_2
        ...
    done

The difference between the two for loops ...
is where they get the values for the loop variable
The for ... in ... loop gets its values ...
from the list that appears right after the in keyword
These values are "hard coded" into the script
They never change
The simple for loop gets its values from the command line
This for loop can have different values each time it is run

Here is an example

    $ cat for_test.sh 
    #! /bin/bash
    #
    # demonstrates the simple for loop

    for arg
    do
        echo $arg
    done
    
    $ ./for_test.sh foo bar bletch
    foo
    bar
    bletch
    
    $ ./for_test.sh bing bang boom
    bing
    bang
    boom

Three Statement `for` Loops

The first two for loops are totally different ...
from the for loops in programming languages
In programming languages, the for statement
- Initializes a loop variable
- Tests the current value of the loop variable ...
  to determine whether the loop should continue
- Changes the loop variable at the end of the loop code
The for statements in programming languages ...
create the values used in the loop
The two for loops we just have studied ...
must be given the values used in the loop
But there is a third form of for loop in Bash
This form creates loop values the same way ...
as the for loop in programming languages

It has the following form

    for (( STMT_1; STMT_2; STMT_3 ))
    do
        COMMAND_1
        COMMAND_2
        ...
    done

Notice that the three statements after the for keyword ...
are inside double parentheses
That means that anything inside them will be treated as numbers
The first statement sets the initial value of the loop variable
The second is a logical statement
As long as it is true, the loop will continue
The third statement changes the value of the loop variable ...
after each pass through the loop

`while` Loops

The first two for loops keep running ...
until all values supplied to them ...
have been used in the loop
A while loop continues running ...
as long as the command following the keyword while ...
returns a status code of 0

while loops have the form

    while COMMAND
    do
        COMMAND_1
        COMMAND_2
        ...
    done

As long as COMMAND returns an exit status of 0 ...
the code block between do and done will be executed

`until` Loops

The until loop is similar the while loop
Except that the until loop continues running ...
as long as the the command following the keyword while ...
returns a status code that in not 0
So the condition that determines whether until runs ...
is the opposite of that for a while loop

The until loop has the form

    until COMMAND
    do
        COMMAND_1
        COMMAND_2
        ...
    done

In practice, the while loop is used much more often than the until loop

`continue`

Normally, a loop will execute all the commands ...
between do and done ...
in each pass through the loop
But sometimes, you want to skip all or part ...
of the commands in the loop block ...
under specific conditions
continue causes the shell to stop running the rest of the code ...
between the do and done keywords
The script then returns to the top of the loop ...
and begins the next iteration
continue does not cause the script to break out of the loop
It merely stops the execution of the loop code ...
for one iteration

`break`

When you start a loop, you specify the conditions ...
which will cause the loop to end
With for ... in and simple for loops, the code leaves the loop ...
when every value in the argument list has been used
In the while, until and three statement for loops ...
the code exits the loop when a logical condition is met
But what if you encountered some unusual condition ...
and wanted to break out of the loop entirely?
To do this, you would have to use break
When bash comes across the break keyword ...
it jumps completely out of the loop

New Material

`case` Statement

Sometimes a script needs to take a specific path ...
depending on the value of a single variable
You could do this with an if ... then ... elif ... statement
But there is a simpler alternative for such situations ...

the case statement, which has the following format

    case TEST_VARIABLE in
        PATTERN_1)
            COMMAND_1A
            COMMAND_1B
            COMMAND_1C
            ...
            ;;
        PATTERN_2)
            COMMAND_2A
            COMMAND_2B
            COMMAND_2C
            ...
            ;;
        PATTERN_3)
            COMMAND_3A
            COMMAND_3B
            COMMAND_3C
            ...
            ;;
        ...
    esac

When Bash encounters a case statement it
- Finds the first pattern that matches the test variable
- Runs the statements for that pattern
- Leaves the case statement
Notice
- There is a right parenthesis, ), after each pattern
- The statements for each pattern end with two semicolons, ;;
- esac marks the end of the case statement
esac is case spelled backwards

Let's look at an example

    $ cat case_1.sh
    #! /bin/bash
    #
    # demonstrates how the case statement works
    
    echo -n "Enter A, B, or C: "
    read letter
    case $letter in
        A)
            echo You entered A
            ;;
        B)
            echo You entered B
            ;;
        C)
            echo You entered C
            ;;
        *)
            echo You did not enter A, B, or C
            ;;
    esac
    echo Exiting program
    
    $ ./case_1.sh
    Enter A, B, or C: A
    You entered A
    Exiting program
    
    $ ./case_1.sh
    Enter A, B, or C: B
    You entered B
    Exiting program
    
    $ ./case_1.sh
    Enter A, B, or C: d
    You did not enter A, B, or C
    Exiting program

Notice the last pattern, *
This pattern is a catchall ...
that will match any input
You should use this as the final pattern in a case statement
This pattern will match anything ...
that has not matched a previous pattern
The code for this pattern should print an error message ...
because the value of the variable was not expected
You must put the * at the end of the pattern list ...
because Bash will never see any patterns that follow it ...
since * matches everything
If you don't use the asterisk, and a matching pattern is not found ...
Bash will simply execute the code following esac

When creating patterns you can use the meta-characters and the logical OR

* Matches any string of characters

? Matches any single character

[ ] Every character within the brackets can match a single character in the test string

| Logical OR separates alternative patterns

The last symbol, a vertical line, | , which is the symbol for a logical OR
This symbol allows us to put many possible matches ...
on the same line

*	Matches any string of characters
?	Matches any single character
[ ]	Every character within the brackets can match a single character in the test string
\|	Logical OR separates alternative patterns

We can use | to accept letters of either case

    $ cat case_2.sh 
    #! /bin/bash
    #
    # demonstrates the use of the | (logical or)
    # operator in patterns within a case statement
    
    echo -n "Enter A, B, or C: "
    read letter
    case $letter in
        a|A)
            echo You entered A
            ;;
        b|B)
            echo You entered B
            ;;
        c|C)
            echo You entered C
            ;;
        *)
            echo You did not enter A, B, or C
        ;;
    esac
    echo Exiting program
    
    $ ./case_2.sh 
    Enter A, B, or C: A
    You entered A
    Exiting program
    
    $ ./case_2.sh 
    Enter A, B, or C: a
    You entered A
    Exiting program

`select` Statement

The select statement is a special kind of loop ...
that is used to create menus ...
inside a shell script
It needs a list of values ...
which it turns into numbered menu choices
When the user enters a number ...
the variable with that number is assigned to a loop variable

A select statement has following form

    select LOOP_VARIABLE [in LIST_OF_VALUES]
    do
        COMMAND_1
        COMMAND_2
        COMMAND_3
        ...
    done

Notice that
```
    in LIST_OF_VALUES
```
is optional
The select statement needs a list of values
These values can be hard coded into the script ...
following the in keyword ...
or they can be supplied as arguments at the command line
In other words, the select variable can get its values ...
the same way a for loop can
When Bash comes upon a select statement it
- Prints a menu on the screen
- Creates menu items for each of the values ...
  assigning each value a number
- Prints a prompt asking the user for input
- Reads a number from user input
- Assigns the value for that number to the select variable
- Runs the statements between do and done with that value
- Prints another prompt
The select statement is a loop construct that will run forever ...
unless you do something to stop it

Let's look at an example

    $ cat select_1.sh
    #! /bin/bash
    #
    # demonstrates how the select statement works
    
    PS3="Choose your fruit: "
    select fruit in apple banana blueberry orange
    do
        echo You chose $fruit
        echo That is choice number $REPLY
    done
    
    $ ./select_1.sh
    1) apple
    2) banana
    3) blueberry
    4) orange
    Choose your fruit: 1
    You chose apple
    That is choice number 1
    Choose your fruit: 2
    You chose banana
    That is choice number 2
    Choose your fruit: 3
    You chose blueberry
    That is choice number 3
    Choose your fruit: 4
    You chose orange
    That is choice number 4
    Choose your fruit: ^C

Here we have hard coded the values into the script itself

We can also supply the values from the command line

    $ cat select_2.sh
    #! /bin/bash
    #
    # demonstrates how the select structure works 
    # taking argument from the command line
    
    PS3="Choose your fruit: "
    select fruit 
    do
        echo You chose $fruit
        echo That is choice number $REPLY
    done
    
    $ ./select_2.sh peaches pears watermelons
    1) peaches
    2) pears
    3) watermelons
    Choose your fruit: 1
    You chose peaches
    That is choice number 1
    Choose your fruit: 2
    You chose pears
    That is choice number 2
    Choose your fruit: 3
    You chose watermelons
    That is choice number 3
    Choose your fruit: ^C

The only difference between these two scripts ...
is that the first has hard coded values ...
while the second takes the values from the command line
In both scripts, Bash assigned a value to the select variable fruit ...
based on the number chosen by the user
The select statement uses a number of keyword shell variables
Perhaps the most important of these is PS3
Notice that this variable is set on the first line of the script
The value of PS3 is used as a prompt ...
to ask the user to chose a menu item
If we had not done this, PS3 would be set to its default value ...

which is #?

    $ cat select_3.sh
    #! /bin/bash
    #
    # demonstrates the select statement where
    # PS3 has the default value
    
    select fruit in apple banana blueberry orange
    do
        echo You chose $fruit
        echo That is choice number $REPLY
    done
    
    $ ./select_3.sh
    1) apple
    2) banana
    3) blueberry
    4) orange
    #? 3
    You chose blueberry
    That is choice number 3
    #? 4
    You chose orange
    That is choice number 4
    #? ^C

Another keyword shell variable used by select is REPLY
When the user enters a number at the keyboard ...
the the value associated with that number is assigned to the loop variable ...
but the number entered is assigned to REPLY
But the script above has one fatal flaw ...
it will loop forever
Unless you include a menu choice to jump out of the loop ...
the loop will go on forever
That's because the select statement will not stop on its own
You need to write code to make it stop
The usual way of doing this is to have a special menu item ...
like "STOP"
The loop code can then check for this value ...
and break out of the loop when the user selects it

Something like this

    $ cat select_4.sh
    #! /bin/bash
    #
    # demonstrates a select menu with a stop value
    
    PS3="Choose your fruit: "
    select fruit in apple banana blueberry orange STOP
    do
        if [ $fruit = STOP ]
        then
            echo About to leave
            break
        fi
        echo You chose $fruit
        echo That is choice number $REPLY
    done
    echo Exiting program
    
    $ ./select_4.sh
    1) apple
    2) banana
    3) blueberry
    4) orange
    5) STOP
    Choose your fruit: 2
    You chose banana
    That is choice number 2
    Choose your fruit: 5
    About to leave
    Exiting program

Notice that we had to use break to jump out of the loop

`read` Command

In order to get input from the user ...
without using command line arguments ...
we need to use the read command
When Bash comes across a read command it
- Waits for the user to enter some text
- Assigns the text entered by the user to the variable ...
  whose name follows the read command

Let's look at an example

    $ cat read_1.sh 
    #! /bin/bash
    #
    # demonstrate use of the read command

    echo -n "Please enter a word: "
    read reply
    echo You entered: $reply
    
    $ ./read_1.sh 
    Please enter a word: foo
    You entered: foo

When read takes in a value from the terminal ...
it grabs everything the user types ...

until they hit Enter

    $ ./read_1.sh 
    Please enter a word: foo bar bletch
    You entered: foo bar bletch

In the script above, I used echo to print a prompt for the user ...
but I also can read with the -p option ...

to have read print the prompt

    $ cat read_2.sh
    #! /bin/bash
    #
    # demonstrate use of the read command using the prompt option

    read -p "Please enter a word: " reply
    echo You entered: $reply
    
    $ ./read_2.sh
    Please enter a word: foo
    You entered: foo

By default, the read command will not allow you to change the text ...
once you have typed it at the command line
read does not use the Readline Library ...
unless you give it a special option
This means your can't use backspace or the arrow keys...

to change what you have already typed

    $ ./read_2.sh
    Please enter a word: foooo^?^?^?
    You entered: foooo

Here I have hit the backspace key three times
But the read command ignores this
The read command can be forced to allow command line editing
if you use the -e option to read

An Interesting Use for the `read` Command

When I create scripts to test your Class Exercises ...
I often need to pause the script ...
so it doesn't scroll off the top of the page
I used the read command with the -p option ...
to halt the script so I can see the resu
I insert the following line in the code
```
read -p Next?
```
When Bash gets to this line it stops ...
prints "Next?" on the command line ...
and waits for me to enter type something
When I hit Enter it resumes running the script
I can use this trick with a for loop ...
and my lncl variable that holds usernames ...

to run a test script for every memeber of the class

$ for id in $lncl
> do
> ./ex02.sh $id
> finger $id | head -1
> read -p "Next? "
> done

Here Documents

Scripts can read data from a file like any Unix command
But sometimes, you want the data to be contained ...
inside the script itself
You might want to do that to make a script easier to deploy ...
since you would not have to distribute a second, data, file ...
along with the script
This can be accomplished with a here document
A here document is a feature of Bash ...
that allows a file to be included in a script ...
which the script can read for its input

Here is an example

    $ cat here.sh 
    #! /bin/bash
    #
    # demonstrates how here documents work

    read -p "Please enter a city: " city    
    grep $city <<EOF
    Boston Red Sox 
    New York Yankees
    Toronto Blue Jays
    Baltimore Orioles
    Tampa Bay Rays
    EOF
    
    $ ./here.sh 
    Please enter a city: Boston
    Boston Red Sox

The script contains a list of all American League Eastern Division baseball teams ...
along with the cities in which they play
The here document begins with the two less than symbols, << ...
followed immediately by a string
In the script above I have chosen "EOF"
This string will serve to mark the beginning ...
and end of the here document
This string can be anything can be anything you like ...
as long as it contains no whitespace
Bash will look for another occurence of the same string ...
on a line by itself ...
and read that as the end of the here document
Nothing must appear on the line after the first string ...
and the second appearance of the sting must be on a line by itself

Using `case` and `for` in a Real World Script

To see how the case and for statement can be useful ...

let's look at the script I used to use to collect homework

     $ cat -n hw_collect.sh 
     1  #! /bin/bash
     2  #
     3  # creates a new homework a directory for
     4  # each student and copies the relevant files
     5  # created by that student for the current
     6  # homework assignment into it. 
     7  
     8  if [ $# -lt 3 ]
     9  then
    10      echo Usage: $(basename $0) "  COURSE_ID   HOMEWORK_DIRECTORY   EXTENSION"
    11      exit
    12  fi
    13  
    14  course_id=$1
    15  hw_dir=$2
    16  ext=$3
    17  
    18  case $course_id in
    19      it244)
    20          course_dir=$lncd
    21          student_ids=$lncl
    22          ;;
    23      it441)
    24          course_dir=$nacd
    25          student_ids=$nacl
    26          ;;
    27      *)
    28          echo $course_id is not a valid course ID
    29          exit
    30  esac
    31  
    32  case $ext in
    33      txt|sh|py|'*')
    34          ;;
    35      *)
    36          echo $ext is not a valid extension
    37          exit
    38  esac
    39  
    40  hw_no=$($bin/python/two_digits_from_string.py  $hw_dir)
    41  if [ $? != 0 ]
    42  then
    43      echo $hw_dir is not a valid homework directory
    44      exit
    45  fi
    46  
    47  error_file=${hw_no}_hw_submissions_missing.txt
    48  
    49  
    50  echo $course_id
    51  
    52  echo
    53  
    54  if [ -e $error_file ]
    55  then
    56      rm $error_file
    57  fi
    58  
    59  for unix_id in $student_ids
    60  do
    61      echo $unix_id
    62      if [ ! -d $unix_id  ]
    63      then
    64          mkdir $unix_id 
    65      fi
    66      cd $unix_id
    67      cp  $course_dir/$unix_id/hw/$hw_dir/*.$ext . 2>> ../$error_file
    68      cd ..
    69  done

On lines 8 through 12 I check for the right number of command line arguments ...
and print a usage message if they are not there
On lines 14 through 16 I take the values of the command line arguments ...
and assign them to variables with meaningful names
I do not have to do this ...
but it's much easier to remember $course_id than $1

Today's Topics

Review

New Material

Homework 11

Final Exam

Review

for ... in ... Loops

for Loops

Three Statement for Loops

while Loops

until Loops

continue

break

New Material

case Statement

select Statement

read Command

An Interesting Use for the read Command

Here Documents

Using case and for in a Real World Script

Attendance

Class Quiz

`for ... in ...` Loops

`for` Loops

Three Statement `for` Loops

`while` Loops

`until` Loops

`continue`

`break`

`case` Statement

`select` Statement

`read` Command

An Interesting Use for the `read` Command

Using `case` and `for` in a Real World Script