IT 244: Introduction to Linux/Unix

IT 244: Introduction to Linux/Unix
Class 25

Review

for ... in ... Loops
for Loops
Numeric 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

Microphone

Final Exam

The final exam will be held on Tuesday, May 20th from 3:00 - 6:00 PM.

If for some reason you are not able to take the Final at the time it will be offered, you MUST send an email to me before the exam so we can make alternative arrangements.

60% of the points on this exam will consist of questions from the Weekly Graded Quizzes.

You do not need to study a Graded Quiz question if the topic is not mentioned in either the Midterm or Final review.

There is a link to the answers to the graded quizze on the class web page.

The other questions I will make up specifically for this exam.

For these questions you will have to know

Absolute and relative pathnames
The PATH system variable
Access permissions
Redirection
Metacharacters
Utilities

The last class on Thursday, May 8th, will be a review session.

You will only be responsible for the material in that review session, which you will find here, and the review for the Midterm, 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.

The final is a closed book exam.

To prevent cheating, certain rules will be enforced during the exam.

Remember, the Midterm and Final determine 50% of your grade.

Graded Quiz 10

You can connect to Gradescope to take weekly graded quiz today during the last 15 minutes of the class.

Once you start the quiz you have 15 minutes to finish it.

This will be the last quiz.

Announcement

There will be no graded quiz next week.

Don't forget the Linix InstallFest this coming Saturday, May 3rd, from 9 to 5 in the McCormack Conference Room M03-0721.

Questions

Are there any questions before I begin?

Review

`for ... in ...` Loops

After the conditional, the most common control structure is the loop
Bash provides many kinds of loops
But we'll start with the for ... in loop

Which has the following structure

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 code 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 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 follows the keyword in
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

This type of for loop cannot be used at the command line
It can only be used inside scripts

Numeric `for` Loops

The first two for loops are totally different ...
from the for loops in programming languages
In most 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 (( CMD_1; CMD_2; CMD_3 ))
do
    COMMAND_1
    COMMAND_2
    ...
done

Notice that the three commands 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 run until all their values have been used
A while loop works differently
It runs as long the command following the 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 loop code will continue

`until` Loops

The until loop is similar the while loop
Except that the until loop runs ..
as long as the command folowing until ...
returns a status code that in not 0
So the condition that keeps it running ...
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
But sometimes, you want to skip all or part ...
of the commands in the loop code block
continue causes the shell to stop running the rest of the loop code
Instead, the script 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 loop ends when you run out of values
In the while, until and three statement for loops things are different
These loops run as long as a logical condition is met
But what if you encountered some unusual condition inside the loop
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

Attendance

New Material

`case` Statement

Sometimes a script needs to do different things ...
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

It 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
Otherwise Bash will never see any patterns that follow it ...
because * matches everything

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

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 creates menus for scripts
It needs a list of values
Each of these values becomes a numbered choice ...
on a menu
When the user enters a number ...
the value associated 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 in
Or they can be supplied as arguments at the command line
In other words, the variable can get its values the same way as a for loop
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 construct is a loop
It 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 gives a value to fruit ...
based on the number chosen by the user
The select statement uses a number of keyword shell variables
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
It asks 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 value associated with that number is assigned to the loop variable ...
and the number entered is assigned to REPLY ...
which you can use in the loop code
The script above has one fatal flaw
It will loop 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

Here is a more interesting example of using select in a script

PS3="Select the operation: "

select opt in add subtract multiply divide quit; do

  case $opt in
    add)
      read -p "Enter the first number: " n1
      read -p "Enter the second number: " n2
      echo "$n1 + $n2 = $(($n1+$n2))"
      ;;
    subtract)
      read -p "Enter the first number: " n1
      read -p "Enter the second number: " n2
      echo "$n1 - $n2 = $(($n1-$n2))"
      ;;
    multiply)
      read -p "Enter the first number: " n1
      read -p "Enter the second number: " n2
      echo "$n1 * $n2 = $(($n1*$n2))"
      ;;
    divide)
      read -p "Enter the first number: " n1
      read -p "Enter the second number: " n2
      echo "$n1 / $n2 = $(($n1/$n2))"
      ;;
    quit)
      break
      ;;
    *) 
      echo "Invalid option $REPLY"

Here's what happens when we run the script

1) add
2) subtract
3) multiply
4) divide
5) quit
Select the operation: 1
Enter the first number: 4
Enter the second number: 5
4 + 5 = 9
Select the operation: 2
Enter the first number: 4
Enter the second number: 5
4 - 5 = -1
Select the operation: 9
Invalid option 9
Select the operation: 5

The select statement will not be on the Final

`read` Command

A script can ask the user for input using 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

Here is 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 a value from the terminal

It grabs everything on the command line

$ ./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 if read is called with the -p option ...
and followed by a string ...

read will print the string as a 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

If you make a mistake when entering a value ...
you can backspace to correct your mistake
But you cannot use normal command line editing ...
like Control A and Control E ...
or the arrow keys → or ←
Because read does not use the Readline Library ...
unless you use the -e option
If you don't run read with the -e option ...
and try to do command line editing ...

you will see something like this

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

Here I have hit the left arrow key twice
But the read command ignores this

An Interesting Use for the `read` Command

In the test scripts for Class Exercises I often need to pause the script
I need do this to keep the output from scrolling off the top of the screen
To pause the output ...
I use the read command with the -p option
This stops the script so I can read the output
The line in the script that does this is the following
```
read -p Next?
```
When Bash gets to this line it stops ...
and prints "Next?"
This gives me a chance to look at the output
When I hit Enter ...
the script starts running again

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 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 inside a script
The script can treat this included text as a file

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, <<
This must be followed immediately by a string
In the script above I have used "EOF"
Which stands for End of File
This string will serve to mark the beginning ...
and the end of the here document
This string can be anything can be anything you like
But it cannot have spaces
Bash will look for another occurence of the same string ...
on a line by itself
This second appearance marks 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
Here documents are often use to print instructions ...
for using a script
Install scripts often give instructions as they run
You could do this with echo commands
But you would need one command for each line of instruction

A better idea is to use cat and a here document

$ cat here_instructions.sh
#! /bin/bash

cat <<EOF
This is a silly script to show you how to
use a here document to display instructions
for using a script
---------------------------------------------
Hit Enter when prompted
EOF
read -p "Done? "
echo Goodbye

$ ./here_instructions.sh
This is a silly script to show you how to
use a here document to display instructions
for using a script
---------------------------------------------
Hit Enter when prompted
Done? 
Goodbye

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

Here is an example of a script using the case and for constructs

It's an earlier version of the script I use to collect homework assignments

$ cat -n homework_collect.sh 
1  #! /bin/bash
2  #
3  # creates a new homework 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  homework_dir=$2
16  ext=$3
17  
18  case $course_id in
19      it116)
20          course_dir=$s1cd
21          student_ids=$s1cl
22          ;;
23      it244)
24          course_dir=$lncd
25          student_ids=$lncl
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  homework_no=$($bin/python/two_digits_from_string.py  $homework_dir)
41  if [ $? != 0 ]
42  then
43      echo $homework_dir is not a valid homework directory
44      exit
45  fi
46  
47  error_file=${homework_no}_homework_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/$homework_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

Review

New Material

Final Exam

Graded Quiz 10

Announcement

Questions

Review

for ... in ... Loops

for Loops

Numeric for Loops

while Loops

until Loops

continue

break

Attendance

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

Class Exercise

Class Quiz

`for ... in ...` Loops

`for` Loops

Numeric `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