IT 244: Introduction to Linux/Unix

IT 244: Introduction to Linux/Unix
Class 26

Review

case Statement
read Command
Here Documents

New Material

Using Braces, { } , with Variables
Special Parameters
$ - The PID of the Current Shell Process
! - The PID of the Last Process Put into the Background
? - The Exit Status
Positional Parameters
# - The Number of Command Line Arguments
0 - The Pathname of the Script
1 - n - The Command Line Arguments
Using { } With Positional Parameters
* and @ - All the Command Line Arguments
shift - Promotes Command Line Arguments
set - Initialize Command Line Arguments
A Practical Example of a Script Using set
Array Variables

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.

Course Evaluation

At the end of each semester we offer you the opportunity to say what you think about this course.

What have I done right?

What have I done wrong?

What can I do better?

You are not asked for you name.

So the submissions are anonymous.

I will not see your responses until after I have submitted grades for this course.

We collect this feedback through Course Evaluations.

I will use what you say to make this course better.

To complete the course evaluation, use the following link .

You have until Friday, December 20th, to submit the evaluation.

Today's Material Not on Final

The new topics we discuss today with not be on the final exam.

Quiz 10

Let's look at the answers to Quiz 10.

First IT Club Event

The new IT Club will hold it's first event, this coming Thursday, December 5th at 3 PM in the Integrated Sciences Complex, Room 3300.

Jason Agress wil speak about his experiences in the IT industry.

This is a great chance to meet other IT students and expand your network.

Holiday food will be served.

You will find a poster for the event here.

Questions

Are there any questions before I begin?

Review

`case` Statement

Sometimes the value of a variable decides what should be done in a script
You could do this with an if ... elif statement
But a case statement is easier to use

The case statement 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 value of 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 structure 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, asterisk, *
This pattern will match anything ...
that has not matched a previous pattern
The code that follows this pattern should print an error message

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

We can modify the above script to handle both upper and lower case letters

$ 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

`read` Command

The read command sets a variable to a value entered by the user
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

read assigns everything typed on the command line ...

to the variable that is its argument

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

In the script above, I used echo to print a prompt

But read will print a prompt if I use the -p option

$ 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 does not allow you to edit text on the command line
But you can enable the command line editing if you use the -e option to read

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 can do this with a Here document

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 here document is outlined in red
The script treats the here document as if it were a file
The here document begins with the two less than symbols, <<
Immediately after these symbols, you must write a string
In the script above I have chosen "EOF" ...
which stands "End of File"
This string will serve to mark the beginning and end of the here document
This string can be anything can be you like ...
as long as it contains no whitespace
Bash will look for another instance of the same string ...
on a line by itself
The second appearance of the string ...
marks the end of the here document
Nothing must appear on the line after the first string
And the second appearance of the string must be on a line by itself

Attendance

New Material

Using Braces, { } , with Variables

We can use the value of a variable inside a qouted line of text ...

if we use double quotes

$ city=Boston

$ echo "I work in $city Massachusetts"
I work in Boston Massachusetts

But what about adding the value of a variable to a string?
If the variable comes first ...
and following string starts with a period, . , or a slash , / ...

there is no problem

$ filename=test

$ echo Creating $filename.txt
Creating test.txt

$ dirname=test_dir

$ echo Creating $dirname/test.txt
Creating test_dir/test.txt

But with any other characters you run into trouble
```
$ echo Creating $filename_1.txt
Creating .txt
```
Unix did not see the variable filename next to "_1.txt"
Instead, it saw a new variable, filename_1, which was not defined
Since this variable was not defined, it has no value
In order to concatenate the value of a variable with a string ...
that does not begin with . or / ...
we need to use braces
The braces surround the name of the variable
They set off the name of the variable from the text that follows
```
$ echo Creating ${filename}_1.txt
Creating test_1.txt
```
The braces surround the variable name ...
and the opening brace comes after the dollar sign, $
I use braces with variables in one of my scripts
Each semester I create a grades directory ...
which I use to calculate your letter grade
I need to copy text files with assignment scores into this directory
I have scripts to collect these files

Here is the script to collect homework scores

for homework_no in 01 02 03 04 05 06 07 08 09 10 11
do
    scores_list=../../submitted_it244/homework_submitted_it244/${homework_no}_homework_submitted_it244/${homework_no}_homework_scores_it244.txt 
    if [ -f $scores_list ]
    then
        echo homework_$homework_no
        cp $scores_list .
    else
        echo Cannot find $scores_list
    fi
done

I use a for loop to assign values to the loop variable homework_no
I need this value to calculate the long pathname stored in scores_list
Once I have this value I can use it to copy the file I need

Special Parameters

Special parameters are shell variables ...
whose values are automatically set by Bash
The parameters contain information about the current shell environment
They are very useful when writing shell scripts

$ - The PID of the Current Shell Process

The special parameter $ contains the process ID (PID) of the current shell

$ echo $$
6834

$ ps
  PID TTY          TIME CMD
  6834 pts/1    00:00:00 bash
  7024 pts/1    00:00:00 ps

Notice that the value returned is the same ...
as the process ID of the shell
Notice also that $ is the name of the parameter
So I had to put a $ in front of it to get its value

! - The PID of the Last Process Put into the Background

! contains the process ID (PID) of the last process put into the background
```
$ sleep 60 &
[1] 7347

$ echo $!
7347
```

You can use ! to kill a job that you just ran

$ ./bother.sh > /dev/null &
[1] 5274

$ jobs
[1]+  Running                 ./bother.sh > /dev/null &

$ echo $!
5274

$ kill $!
[1]+  Terminated              ./bother.sh > /dev/null

$ jobs

$

? - The Exit Status

The ? special parameter returns the exit status of the last command

$ pwd
/home/it244gh/it244/work

$ echo $?
0

$ ls asdfasd
ls: cannot access asdfasd: No such file or directory

$ echo $?
2

The fist command succeeds and returns an exit status of 0
While the second fails and returns a non-zero exit status

You can set the exit code in a shell script by using the exit built-in

$ cat exit.sh 
#! /bin/bash
#
# demonstrates the use of the exit command with a status code

exit 2

$ ./exit.sh 

$ echo $?
2

The exit status is also called the condition code or the return code

Positional Parameters

Positional parameters contain the value ...
of everything on the command line that runs the script
They can also be used with functions

# - The Number of Command Line Arguments

The # positional parameter contains the number of command line arguments

$ cat arg_count.sh 
#!/bin/bash
#
# Prints the number of arguments given to this script

echo This script received $# arguments

$ ./arg_count.sh foo bar bletch
This script received 3 arguments

This parameter allows you to check ...
if your script has received all the arguments it needs

0 - The Pathname of the Script

The 0 positional parameter contains the full pathname used to call the script

$ cat command_name.sh 
#!/bin/bash
#
# prints the pathname by which called this script

echo This script was called using the pathname $0

$ ./command_name.sh 
This script was called using the pathname ./command_name.sh

$ /home/ghoffman/examples_it244/command_name.sh 
This script was called using the pathname /home/ghoffman/examples_it244/command_name.sh

You should use this parameter when creating a usage message
But you should use it with the basename command ...
run inside command substitution ...

to remove the path part of the pathname

$ basename /home/ghoffman/examples_it244/command_name.sh
command_name.sh

1 - n - The Command Line Arguments

The numbered positional parameters contain ...
the command line arguments to a script ...
or to a function

Here is an example

$ cat print_positionals.sh 
#!/bin/bash
#
# Prints the value of the first four positional arguments

echo 0: $0
echo 1: $1
echo 2: $2
echo 3: $3

$ ./print_positionals.sh foo bar bletch
0: ./print_positionals.sh
1: foo
2: bar
3: bletch

If there is no corresponding command line argument

The parameter will have no value

$ ./print_positionals.sh foo bar
0: ./print_positionals.sh
1: foo
2: bar
3:

You cannot run test on a positional parameter
If there is no corresponding command line argument

If you do, you will get an error

$ cat greater_than_zero.sh 
#! /bin/bash
#
# this script test whether its first command line argument is greater than 0

if [ $1 -gt 0 ]
then
    echo $1 is greater than 0
else
    echo $1 is not greater than 0
fi

$ ./greater_than_zero.sh 
./greater_than_zero.sh: line 5: [: -gt: unary operator expected
is not greater than 0

This is why you need to check that the script ...
gets the right number of command line arguments

Using { } With Positional Parameters

Positional parameters do not stop at 9
You can have two digit positional parameters
But if you try to use them like single digit positional parameters ...
you will run into trouble

Here's a script to print the first 20 positional parameters

$ cat param_test_1.sh
#! /bin/bash

echo '$#'  $#
echo '$1'  $1
echo '$2'  $2
echo '$3'  $3
echo '$4'  $4
echo '$5'  $5
echo '$6'  $6
echo '$7'  $7
echo '$8'  $8
echo '$9'  $9
echo '$10' $10
echo '$11' $11
echo '$12' $12
echo '$13' $13
echo '$14' $14
echo '$15' $15
echo '$16' $16
echo '$17' $17
echo '$18' $18
echo '$19' $19
echo '$20' $20

But when I run it I get

$ ./param_test_1.sh a b c d e f g h i j k l m n o p q r s t            
$# 20
$1 a
$2 b
$3 c
$4 d
$5 e
$6 f
$7 g
$8 h
$9 i
$10 a0
$11 a1
$12 a2
$13 a3
$14 a4
$15 a5
$16 a6
$17 a7
$18 a8
$19 a9
$20 b0

# shows that the script got 20 command line arguments
But you don't see them in the output
If you look carefully you can see what's going on
Each value after 9 consists of a followed by a digit
But a is the first command line argument
This means that Linux reads $10 as $1 followed by 0
Reads $11 as $1 followed by 1
And so on
We saw this above ...
where we needed to follow the value of a variable ...
with some other text ...
that did not begin with . or /
The solution is the same
Enclose both digits of the positional parameter with { }

If we rewrite the above script like this

$ cat param_test_2.sh
#! /bin/bash

echo '$#'  $#
echo '$1'  $1
echo '$2'  $2
echo '$3'  $3
echo '$4'  $4
echo '$5'  $5
echo '$6'  $6
echo '$7'  $7
echo '$8'  $8
echo '$9'  $9
echo '$10' ${10}
echo '$11' ${11}
echo '$12' ${12}
echo '$13' ${13}
echo '$14' ${14}
echo '$15' ${15}
echo '$16' ${16}
echo '$17' ${17}
echo '$18' ${18}
echo '$19' ${19}
echo '$20' ${20}

We get the correct results when running the script

$ ./param_test_2.sh a b c d e f g h i j k l m n o p q r s t
$# 20
$1 a
$2 b
$3 c
$4 d
$5 e
$6 f
$7 g
$8 h
$9 i
$10 j
$11 k
$12 l
$13 m
$14 n
$15 o
$16 p
$17 q
$18 r
$19 s
$20 t

* and @ - All the Command Line Arguments

There are two special parameters ...
that can be used to return all arguments from the command line
The are * and @

Both return all the arguments from the command line

$ cat special_param_test_1.sh
#! /bin/bash
#
# demonstrates some properties of the special
# parameters $* and $@

echo 'Here is $*: ' $*
echo 'Here is $@: ' $@

$ ./special_param_test_1.sh 1 2 3 4 5
Here is $*:  1 2 3 4 5
Here is $@:  1 2 3 4 5

You can use them in for ... in loops

$ cat special_param_test_2.sh
#! /bin/bash
#
# demonstrates some properties of the special  
# parameters $* and $@

echo 'The $* loop'
for arg in $*
do
    echo $arg
done

echo 'The $@ loop'
for arg in $@
do
    echo $arg
done

$ ./special_param_test_2.sh 1 2 3 4 5
The $* loop
1
2
3
4
5
The $@ loop
1
2
3
4
5

So why does Bash give us two different parameters ...
that appear to do the same thing?
Because they are subtly different
$* inside double quotes has a value that is a single string
That string consists of all command line arguments ...
concatenated together with a space between them
But when you enclose $@ within double quotes ...
it's value is a list of separate strings ...
one for each command line argument

Let's look at an example

$ cat special_param_test_3.sh
#! /bin/bash
#
# demonstrates some properties of the special  
# parameters $* and $@

echo 'The $* loop'
for arg in "$*"
do
    echo $arg
done

echo 'The $@ loop'
for arg in "$@"
do
    echo $arg
done

$ ./special_param_test_3.sh 1 2 3 4 5
The $* loop
1 2 3 4 5
The $@ loop
1
2
3
4
5

The difference between $* and $@ only appears ...
when they are placed inside double quotes

`shift` - Promotes Command Line Arguments

The shift built-in promotes command line arguments
This means that the value of positional parameter 2 ...
is assigned to positional parameter 1
And the value of positional parameter 3 ...
is assigned to positional parameter 2

And so on

$ cat shift_1.sh 
#! /bin/bash
#
# demonstrates the use of the shift command

echo '$1: ' $1
echo '$2: ' $2
echo '$3: ' $3
echo '$4: ' $4

echo
echo shifting arguments
shift
echo

echo '$1: ' $1
echo '$2: ' $2
echo '$3: ' $3
echo '$4: ' $4

$ ./shift_1.sh foo bar bletch bling
$1:  foo
$2:  bar
$3:  bletch
$4:  bling

shifting arguments

$1:  bar
$2:  bletch
$3:  bling
$4

After shift is called ...
all arguments move up one position ...
and the first argument value is lost
If shift is called with a numeric argument ...

all arguments are moved up that number of positions

$ cat shift_2.sh 
#! /bin/bash
#
# demonstrates the use of the shift command with an integer argument

echo '$1: ' $1
echo '$2: ' $2
echo '$3: ' $3
echo '$4: ' $4

echo
echo shifting arguments by 2
shift 2
echo

echo '$1: ' $1
echo '$2: ' $2
echo '$3: ' $3
echo '$4: ' $4

$ ./shift_2.sh foo bar bletch bling
$1:  foo
$2:  bar
$3:  bletch
$4:  bling

shifting arguments by 2

$1:  bletch
$2:  bling
$3: 
$4:

The first two command line arguments are lost ...
after shift is called ...
and every positional parameter moves up 2 positions
You can use shift to write a script ...

that loops over all command line arguments

$ cat shift_3.sh
#! /bin/bash
#
# demonstrates the use of the shift in a while loop

while [ ! -z $1  ]
do
    echo 'The value of $1 is ' $1
    shift
done

$ ./shift_3.sh foo bar bletch bling blam
The value of $1 is  foo
The value of $1 is  bar
The value of $1 is  bletch
The value of $1 is  bling
The value of $1 is  blam

shift keeps promoting arguments until there are no more left
The -z option to test returns true if the length of what follows is zero
The not operator, ! makes the test true ...
when the string is greater than zero

`set` - Initialize Command Line Arguments

The set command can create positional arguments ...
from within a script
Normally, the positional parameters take their values ...
from the command line
If you call set and follow it with a list of values ...
set will assign each of those values to a positional parameter
Any values they had from the command line are lost
Each of the values following set ...
are assigned to the corresponding positional parameter ...

starting with 1

$ cat set.sh
#! /bin/bash
#
# demonstrates using the set command to assign values 
# to positional parameters

echo This script received $# arguments from the command line
echo '$1: ' $1
echo '$2: ' $2
echo '$3: ' $3
echo '$4: ' $4

echo
echo 'After  set bloo blah blim blak'
set bloo blah blim blak
echo '$1: ' $1
echo '$2: ' $2
echo '$3: ' $3
echo '$4: ' $4

$ ./set.sh foo fie foe fum
This script received 4 arguments from the command line
$1:  foo
$2:  fie
$3:  foe
$4:  fum

After  set bloo blah blim blak
$1:  bloo
$2:  blah
$3:  blim
$4:  blak

This script was run with one set of positional parameters
But after I ran set the positional parameters had different values
set is a built-in command
set has a completely different behavior when called with the -o or +o options
With those options set sets or unsets a shell option
These options alter the way Bash behaves

A Practical Example of a Script Using `set`

set is one of those commands I thought I would never need
But I now use it in my homework collection script assignment_collect.sh
Normally homework assignments have a filename like hw8.sh
But not homework 11 which has three scripts
- parameters.sh
- log_users.sh
- envir.sh
In earlier versions of the script this was not a problem
Because the name of the script file was given on the command line
But I got tired of having to type the filename each time I ran the script
And I sometimes gave the wrong command line argument
After much thinking I found a solution which involved using set
My solution was to look at the number of command line arguments
If the number was 0 the script would calculate the name of the file
Something like hw10.sh
The script then made this filename the first positional parameter ...

using set

if [ $# -eq 0 ] # construct assignment filename
then
    set hw${assgn_num}.$ext
fi

I then collected files inside a regular for loop ...
without the keyword in ...
so the loop variables came from the positional parameters

Array Variables

Variables in Unix normally hold a single value

$ team='Celtics'

$ echo "Go $team"
Go Celtics

But Unix also allows variables to have more than one value
Such variables are called arrays
An array variable is defined as follows
```
VARIABLE_NAME=(ELEMENT1 ELEMENT2 ... )
```

For example

$ cities=(Boston Chicago Philadelphia Cleveland)

Notice that there are no spaces on either side of the equal sign, =
But spaces are required between individual array values
To access the array values we must
- Follow the name of the variable with square brackets
- Have a number inside the square bracket indicating the desired value
- Enclose the variable name and the square bracket inside braces

Here is an example

$ echo ${cities[0]}
Boston

$ echo ${cities[1]}

Notice that the array elements are numbered starting with 0
If you don't use the square brackets you will get the first value of the array
```
$ echo $cities
Boston
```
If you don't use the braces you will not get the results you expect
```
$ echo $cities[2]
Boston[2]
```
I did not put braces around cities[2] ...
so Bash appended the string "[2]" to the value of the first entry

There are two symbols that can be used to get all the values in an array

$ echo ${cities[*]}
Boston Chicago Philadelphia Cleveland

$ echo ${cities[@]}
Boston Chicago Philadelphia Cleveland

The asterisk, *, turns all the elements of the array into a single string ...
with the values separated by spaces
The at sign, @, reproduces the original array
That is, it creates a new array ...
with the same elements in the same order
Each element of the array remains distinct
We can see this if we use the declare built-in
declare is normally used to set the attributes of a variable
One of those attributes is whether the variable is an array
You can also use declare to list every variable ...
with a certain attribute
To do this run declare with a dash, - ...
followed by an attribute ...
but no argument
So if we run declare with the -a option

It will print all array variables

$ c1=("${cities[*]}")

$ echo $c1
Boston Chicago Philadelphia Cleveland

$ c2=("${cities[@]}")

$ echo $c2
Boston

$ declare -a
...
declare -a c1="([0]="Boston Chicago Philadelphia Cleveland")'
declare -a c2="([0]="Boston" [1]="Chicago" [2]="Philadelphia" [3]="Cleveland")'
declare -a cities="([0]="Boston" [1]="Chicago" [2]="Philadelphia" [3]="Cleveland")'

The variable c1 is an array with only one element
That element is a string composed of all the values in the original array variable
c2 is an array variable with exactly the same entries as cities ...
in the same order
I could have used arrays in the script I showed above ...
to collect homework scores files

Instead of writing

for homework_no in 01 02 03 04 05 06 07 08 09 10 11

I could have used

homework_nums=(01 02 03 04 05 06 07 08 09 10 11)
for homework_no in ${homework_nums[@]}

You can use the hash mark, #
To get the length of any value in the array
Place the # within the curly braces
Immediately in front of the array name
Followed by the index number inside square brackets
```
$ echo ${cities[0]}
Boston
$ echo ${#cities[0]}
6
```
You assign a new value to an element of an array

The same way you assign a value to an ordinary variable

$ cities[3]=Akron

$ echo ${cities[@]}
Boston Chicago Philadelphia Akron