IT 244: Introduction to Linux/Unix

IT 244: Introduction to Linux/Unix
Class Review Final

Today's Topics

Review

Running a Command in the Background
Jobs
Moving a Job from the Foreground into the Background
Aborting a Background Job
Pathname Expansion
The ? Meta-character
The * Meta-character
The [ and ] Meta-characters
Built-ins
Creating Startup Files
Redirecting Standard Error
Shell Scripts
Making a Shell Script Executable
Specifying Which Version of the Shell Will Run a Script
Comments in Shell Scripts
Separating and Grouping Commands
| (pipe) and & (ampersand) as Command Separators
Continuing a Command onto the Next Line
Shell Variables
Local Variables
Global Variables
Keyword Shell Variables
Important Keyword Shell Variables
User-created Variables
Quoting and the Evaluation of Variables
Removing a Variable's Value
Processes
Process Structure
Process Identification
Executing a Command
History
Using the History Mechanism
The Readline Library
Readline Completion
Pathname Completion
Command Completion
Variable Completion
Aliases
Functions
Shell Modification of the Command Line
History Expansion
Alias Substitution
Brace Expansion
Tilde, ~, Expansion
Parameter and Variable Expansion
Command Substitution
Pathname Expansion
Shell Script Control Structures
The if ... then ... Construct
test
The test Operators
Using test in Scripts
The if ... then ... else ... Construct
The if ... then ... elif ... Construct
for ... in ... Loops
for Loops
while Loops
continue
break
read Command

Final Exam

The final exam will be given on Wednesday, April 16th from 6:30pm - 9:00pm.

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.

Today's class will be a review session.

You will only be responsible for the material contained in the Class Notes for today's 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

Running a Command in the Background

Normally, when you run a command ...
you have to wait for it to finish
Such commands are said to be running in the foreground
Unix gives you a way to get the command prompt back ...
after running a command that will take a long time to finish
You can run the command in the background
The background job loses it's connection to the keyboard ...
and the shell will give you a prompt
The shell will tell you when the background job has finished
Every time a program runs, a process is created
The process has access to system resources ...
like memory (RAM) and a connection to the filesystem
Unix, like most OSs, is a multitasking operating system
This means you can have more than one process running at a time
To run a command in the background ...
enter an ampersand, & , at the end of the command line ...
just before hitting Enter:
```
    $ sleep 5 &
    [1] 17895
    $
```

Jobs

Every time you type something at the command line ...
and hit Enter ...
you are creating a job
Every time a program runs ...
a process is created for that program
A pipeline is a collection of commands joined by pipes
Each command will generate its own process ...
but the collection of all the separate processes ...
is a single job
Each process in a pipeline will have its own process ID
So as the pipeline progresses, the currently running process will change ...
but the job number does not change
The job is the collection of all processes created ...
by an entry at the command line
You can have multiple jobs running at the same time ...
but only one job can be in the foreground at any one time
Every process has a process ID number ...
and every job has a job number
When you tell the shell to run a job in the background ...
it returns two numbers
```
    $ sleep 5 &
    [1] 7431
    $
```
The job number is enclosed in brackets and comes first
The second, larger, number is the process identification number ...
of the first process in the job
The process identification number is also known as the PID
When the job finishes, the shell prints out a message
```
    [1]+  Done                    sleep 5
```
The message does not appear the moment the job finishes
The shell waits for the next time you hit Enter ...
and it prints the message after the output from the command

To see the status of all background jobs run the jobs command

$ sleep 10 & sleep 10 & sleep 10 &
[1] 13256
[2] 13257
[3] 13258

$ jobs
[1]   Running                 sleep 10 &
[2]-  Running                 sleep 10 &
[3]+  Running                 sleep 10 &

Moving a Job from the Foreground into the Background

There can only be one foreground job ...
though you can have many background jobs
Unix will let you move a job from the foreground ...
to the background
To do this, you must first suspend the foreground job
A suspended job is not dead ...
it is in a state of suspended animation
You can reactivate it later
To suspend a foreground job you must use the suspend key sequence
On our systems you suspend a job by hitting Control Z
After you do this, the shell stops the current process
It also disconnects it from the keyboard
Once the job is suspended ...
you can place it in the background using the bg command
bg stands for background
Once placed in the background, the job resumes running
If more than one job is suspended ...
you must give bg the job number

Aborting a Background Job

There are two ways to abort a background job
You can bring a job from the background to the foreground ...
using the fg (foreground) command
Once you have the job in the foreground ...
you can abort it using Control C
When there is more than one job in the background ...
you must specify the job number when using fg
You can also terminate any job using the kill command
But to use kill you must tell it what to kill
The usual way to do this is to give kill a process ID
If you don't remember the process ID ...
run ps (process status) to get the process ID (PID)
You can also use the job number with kill ...
but you must precede a job number with a percent sign, %
You can get the job number by using the jobs command

Pathname Expansion

Pathname expansion allows you to specify a file or directory ...
without typing the full name
It also allows you to specify more than one file or directory ...
with a single string of characters
Pathname expansion uses characters with special meaning to the shell
These special characters are called meta-characters
Meta-characters are also sometimes called wildcards
They allow you to specify a pattern
When the shell sees one of these characters on the command line ...
it replaces the pattern with a sorted list ...
of all pathnames that match the pattern
The shell then runs this altered command line
The pattern is called an ambiguous file reference
You can use as many meta-characters as you want to form a pattern
Pathname expansion is different from pathname completion ...
which you get by hitting Tab

The ? Meta-character

The question mark, ?, meta-character stands for a single instance of any character
? can be used with any command ...
even those that don't normally deal with files
```
    $ echo dir?
    dir1 dir2 dir3 dir4
```
The ? meta-character does not match a leading period in a filename
You must explicitly enter a leading period, . ...
when specifying an "invisible" file

The * Meta-character

An asterisk, * , will match any number of characters in a pathname
It will even match no characters
* can be used with any command ...

even those that don't normally deal with files

    $ echo dir*
    dir dir1 dir10 dir2 dir3 dir4

* cannot be used to match the initial period, . , in a hidden filename
But you can list all the hidden file in a directory using * ...

if you put it after a period

    $ ls .*
    .addressbook   .bashrc  .forward  .pinerc
    .bash_history  .cshrc   .login    .plan
    .bash_profile  .emacs   .msgsrc

The [ and ] Meta-characters

The square brackets, [ and ], are also meta-characters
They work somewhat like ?
They only match a single character in a pathname ...
but the pathname character must match one of the characters ...
within the brackets
No matter how many characters are within the bracket ...
the pattern can match only a single character
You can use the bracket meta-characters with any program
You can use a range to avoid listing all characters
A range is specified by listing the first and last characters of a sequence ...
separated by a dash, -
The sequence is specified in alphabetical order
The square brackets provide another shortcut
If you insert an exclamation mark, ! , or a caret, ^ ...
immediately after the opening bracket ...
the shell will match any single character ...
that is NOT included within the brackets

Built-ins

Not all commands can be found on disk as executable files
Some are actually written as part of the shell
Such commands are called built-ins
When you run a built-in ...
the shell does not have to create a new process ...
when you run these programs
Instead the command runs in the same process as the shell
This makes execution faster

Creating Startup Files

A startup file contains Unix commands ...
that are run just before you get a prompt
The startup file normally used by Bash is .bash_profile
This file must be placed in your home directory
The commands in this file are run after you enter your password ...
but before you get a prompt

Redirecting Standard Error

Standard error is the "file" into which error messages are sent ...
if they are not explicitly sent somewhere else
Redirecting standard error allows a program to separate its output stream ..
from its error messages

To redirect standard error, you place a 2 in front of the greater than symbol

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

    $ ls xxxx 2> error.txt

    $ cat error.txt 
    ls: cannot access xxxx: No such file or directory

Remember, 2 is the file descriptor for standard error
Unix also gives you a way to redirect both standard output and standard input ...
to the same file
You can do this using the ampersand and greater than symbols together, &>

Shell Scripts

A shell script can use any shell feature ...
that is available at the command line
- Ambiguous file references using the metacharacters ?, * and [ ]
- Redirection
- Pipes
But not those features which are provided by tty
- Command line editing (arrow keys, control key combinations)
- >Pathname completion (hit Tab to get more of a filename)
- The history mechanism (up arrow to recall previous command line)
Unix also provides control structures
- Conditionals
- Loops

Making a Shell Script Executable

You must have both read and execute permission ...
to run a shell script
Because the shell has to read the contents of the script ...
you need read permission
You need execute permission so the script can actually be run ...
without calling bash
Normally you would give a shell script file 755 permissions
The owner can read, write and execute
The group and everyone else can read and execute

Specifying Which Version of the Shell Will Run a Script

When the shell runs a shell script ...
it creates a new shell ...
inside the process that will run the script
Normally this sub-shell will be the same version of the shell ...
as your current shell
A script can use the hashbang line ...
to specify which shell version to use ...
when running a script
The hashbang line must be the first line of the script
The first two characters on the line
must be a hash symbol, # ...
followed by an exclamation mark, !
After these two characters, you need to have the absolute pathname ...
of the version of the shell which will run the script

Comments in Shell Scripts

Scripts have to be read by the people
- Who write the program
- Who maintain the program
- Who use the program
To make clear what is happening inside a program ...
use comments
Anything following a hash mark, # , is a comment ...
except for the hashbang line

Separating and Grouping Commands

You can enter many commands on a single command line ...

if you separate them with a semi-colon, ;

    $ echo Here are the contents of my home directory ; ls ; echo
    Here are the contents of my home directory
    error.txt  foo  it244  work

When you hit Enter each command is executed ...
in the order it was typed at the command line

| (pipe) and & (ampersand) as Command Separators

The pipe, | , and ampersand, & , characters are also command separators
When we separate commands with the pipe character, | ...
each command takes its input from the previous command
We use an ampersand, & , after a command ...
to run that command in the background
When we do this, two things happen
- The command is disconnected from the keyboard
- The command will run at the same time
  as the next command you enter
But the ampersand is also a command separator
So we can use it to run many commands at the same time

Continuing a Command onto the Next Line

A command line can be as long as you like
If your command goes beyond the edge of your window ...
it will wrap to the next line
But the line wrap can occur in the middle of a word ...
which can make it hard to read
If you want to break the command at a specific point ...
you can type a backslash, \

followed immediately by the Enter key

    $ echo A man \
    > A plan \
    > A canal \
    > Panama
    A man A plan A canal Panama

After hitting \ and newline ...
the shell responds with the greater than symbol, >
This is the secondary prompt
The shell is telling you it expects more input

Shell Variables

A variable is a place in memory with a name ...
that holds a value
To get the value of a variable ...
put a dollar sign, $, in front of its name
Some variables are set and maintained by the shell itself
They are called keyword shell variables ...
or just keyword variables
Other variables are created by the user
They are called are called user-created variables
The environment in which a variable can be used is called the scope
Shell variables have two scopes
- Local
- Global

Local Variables

Local variables only exist in the shell in which they are defined
To create a local variable, use the following format
```
    VARIABLE_NAME=VALUE
```
There are no spaces on either side of the equal sign ...
when setting Bash variables
Variables are local unless you explicitly make them global
If the value assigned to a variable has spaces or tabs ...
you must quote it ...
or put a backslash in front of each whitespace character
If you want to use the value of a variable inside quotes ...
you must use double quotes
If you run a shell script, the local variables will not be visible ...
because the script is running in a sub-shell ...
and the local variables are not defined there

Global Variables

Global variables are defined in one shell ...
and keep their values in all sub-shells created by that shell
Global variables are defined in Bash using the export command
like .bash_profile
The env command, when used without an argument ...
displays the values of all global variables
To make a variable global use the export command
```
export VARIABLE_NAME=VALUE
```

Keyword Shell Variables

Keyword shell variables have special meaning to the shell
By convention, the names of keyword variables are always capitalized
Most keyword variables can be changed by the user
This is normally done in the startup file .bash_profile

Important Keyword Shell Variables

There are a number of keyword variables that affect your Unix session

Some of the more important are

Variable Value

HOME The absolute pathname of your home directory

PATH The list of directories the shell will search when looking for the executable file associated with a command you entered at the command line

SHELL The absolute pathname of your default shell

PS1 Your command line prompt - what you see after entering each command

PS2 The secondary prompt - what you see if you continue a command to a second line

Variable	Value
HOME	The absolute pathname of your home directory
PATH	The list of directories the shell will search when looking for the executable file associated with a command you entered at the command line
SHELL	The absolute pathname of your default shell
PS1	Your command line prompt - what you see after entering each command
PS2	The secondary prompt - what you see if you continue a command to a second line

User-created Variables

User-created variables are any variables you create
By convention, the names of user-created variables are lower case
User-created variables can be either local or global in scope

Quoting and the Evaluation of Variables

Whenever the value of a variable contains spaces or tabs ...
you must quote the string or escape the whitespace character
There are three ways this
- Single quotes (' ')
- Double quotes (" ")
- Backslash (\)
Everything surrounded by single quotes ...
appears in the variable exactly as you entered it
Double quotes also preserve spaces and tabs ...
in the strings they contain
But you can use a $ in front of a variable name ...
to get the value of a variable ...
inside double quotes
Quotes affect everything they enclose
The backslash, \ , only effects the character immediately following it

Removing a Variable's Value

There are two ways of removing the value of a variable
You can use the unset command
Or you can set the value of the variable to the empty string

Processes

A process is a running program
Unix is a multitasking operating system
Many processes can run at the same time
The shell runs in a process like any other program
Every time you run a program ...
a process is created ...
except when you run a built-in
When you run a shell script ...
your current shell creates a sub-shell to run the script
This sub-shell runs in a new process
When each command in the script is run ...
a process is created for that command

Process Structure

Processes are created in a hierarchical fashion
When the machine is started, there is only one process
This process is called either init ...
or systemd ...
depandending on what technology is used to start other programs
init or systemd then creates other processes
These new processes are child process of init or systemd
These child processes can create other processes
init or systemd has PID (Process ID) of 1
init or systemd is the ancestor of every other processes ...
that ever runs on the machine

Process Identification

Each process has a unique Process ID (PID) number

ps -f displays a full listing of information about each process running for the current user

    $ ps -f
    UID        PID  PPID  C STIME TTY          TIME CMD
    it244gh  26374 26373  0 13:41 pts/5    00:00:00 -bash
    it244gh  27891 26374  0 13:57 pts/5    00:00:00 ps -f

The UID column shows the user's Unix username
The PID column is the process ID of the process
The PPID column is the process ID of the parent process ...
the process that created this process
The CMD column gives the command line that started the process

Executing a Command

When you run a command from the shell ...
the shell asks the operating system to create a process ...
to run the command
Then it sleeps ...
waiting for the child process to finish
When the child process finishes ...
it notifies its parent process of its success or failure ...
by returning an exit status ...
and then it dies

History

The history mechanism maintains a list of the command lines you type
These command line entries are called events
To view the history list, use the history command
If you run history without an argument ...
it will display all the events in this history list
By default, this list contains 500 values
To restrict how many lines are displayed ...
run history followed by a number
You cannot have a - in front of the number ...
as there must be when using head or tail

Using the History Mechanism

If you know the event number of a previous command ...
you can run it again by using an exclamation mark, ! ...

followed by the event number

    $ !517
    echo $PATH
    /usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin:/usr/games

The history mechanism prints out the old command line ...
before running it
There must be no space between the ! and the number ...

The Readline Library

The readline library is a collection of procedures ...
which let you edit the command line
When you use Control key combinations on the command line ...
you are using the readline library
Any program running under Bash and written in C can use the readline library

Here are some of the more useful commands for the emacs version of the readline library

Command Meaning

Control A Move to the beginning of the line

Control E Move to the end of the line

Control U Remove everything from the text entry point to the beginning of the line

Control K Remove everything from the text entry point to the end of the line

→ Move the text entry point one character to the left

← Move the text entry point one character to the right

↑ Recall the previous command line entry in the history list

↓ Recall the following command line entry in the history list

Command	Meaning
Control A	Move to the beginning of the line
Control E	Move to the end of the line
Control U	Remove everything from the text entry point to the beginning of the line
Control K	Remove everything from the text entry point to the end of the line
→	Move the text entry point one character to the left
←	Move the text entry point one character to the right
↑	Recall the previous command line entry in the history list
↓	Recall the following command line entry in the history list

Readline Completion

The readline library provides a completion mechanism
Type a few letters of something ...
and readline completion will try to supply the rest
There are three forms of completion provided by the readline library
- Pathname completion
- Command completion
- Variable completion

Pathname Completion

The readline library provides pathname completion
You begin typing a pathname, then hit Tab
If there is only one pathname that matches ...
the readline library will provide the the rest of the pathname
If there is more than one possible completion ...
the readline library will beep
You can then enter more characters ...´
before hitting Tab again ...
or you can hit Tab right after the first beep ...
and the readline library will give you a list of possible completions
If the second Tab still gives you a beep ...
there are no possible completions

Command Completion

The readline library will complete the name of a command for you
Begin typing a command ...
then hit Tab ...
and the readline library will try to supply the rest of the command
If there is more than one possibility ...
you will hear a beep
If you hit Tab a second time ...
you will see a list of possible completions

Variable Completion

When you type a dollar sign, $ , followed immediately by some text ...
you are entering a variable name
The readline library knows this
and will attempt to complete the name of the variable
If there is more than one possibility, you will hear a beep
If you then hit Tab another time
you will see a list of possible completions
If no list appears after the second Tab ...
there are no possible variable name completions

Aliases

An alias is a string ..
that the shell replaces with some other string
Usually, the value assigned to the alias ...
is a command or part of a command
To define an alias, you use the alias command
alias uses the following format in Bash
```
    alias ALIAS_NAME=ALIAS_VALUE
```
In Bash, there must be no spaces on either side of the equal sign, =
If the value assigned to the alias has spaces, it must be quoted
If you follow alias with the name of an alias, it will display the definition
```
    $ alias ll
    alias ll="ls -l'
```
In Bash, an alias cannot accept an argument
Instead of allowing Bash to have aliases that accept an argument ...
Bash has functions
Aliases are not global
They only work in the shell in which they are defined

Functions

A function is a collection of commands that is given a name
Functions can accept arguments from the command line
Functions can be run anywhere you happen to be in the filesystem ...
because function exist in memory ...
not on the disk
Functions, unlike aliases, can have arguments
They use the same positional arguments that shell scripts use
Functions differ from shell scripts in a number of ways
- They are stored in memory (RAM), rather than in a file on disk
- The shell preprocesses the function so it can execute more quickly
- The shell executes the function in it's own process
Functions are local to the shell in which they are defined
They do not work in subshells

Functions definitions have the following form

    FUNCTION_NAME ()
    {
        COMMANDS
    }

For clarity you can precede the function name ...
with the keyword function
The keyword function is optional

Shell Modification of the Command Line

But before the shell executes the commands ...
if first looks to see if it needs to make changes ...
to the tokens on the command line
The shell actually rewrites the command line before executing it
It does this to implement features of the shell ...
like command substitution and pathname expansion
These are features that make the shell more powerful ...
but they require the shell to change what you typed on the command line ...
before executing it
There are 10 different ways in which the shell can modify the command line
You are only responsible for the following

History Expansion

History expansion occurs when you use the exclamation mark, ! ...

to run again a previous command using the history mechanism

    $ history 5
      540  cat output.txt 
      541  echo "Go Red Sox" > output.txt
      542  cat output.txt 
      543  echo foo
      544  history 5
      
    $ !543
    echo foo
    foo

Alias Substitution

After history expansion, bash performs alias substitution
The shell replaces the name of the alias ...
with the value of the alias
Aliases allow you to run complicated commands ...
by typing only a few characters

Brace Expansion

Braces, { }, allow you to specify several strings ...
all at once
Braces can appear with strings of characters in front ...
or behind
The braces contain strings of characters separated by commas
The shell expands a brace by creating many strings ...
one for each string contained within the braces

If I wanted to create 5 foo files I could use braces expansion as follows

    $ touch foo{1,2,3,4,5}.txt
    
    $ ls
    foo1.txt  foo2.txt  foo3.txt  foo4.txt  foo5.txt

Tilde, ~, Expansion

Whenever bash sees a tilde, ~ , by itself ...
it substitutes the absolute pathname of your home directory
Whenever bash sees a tilde, ~ , followed by a Unix user name,
it substitutes the absolute pathname of the home directory ...
of that account

Parameter and Variable Expansion

After tilde expansion, bash performs parameter and variable expansion
```
    $ echo $SHELL
    /bin/bash
```
bash notices the $ in front of a string ...
and looks to see if that string is the name of a variable
If the string is a variable, bash subsitutes the value of the variable ...
for the dollar sign and variable name

Command Substitution

In command substitution, a command is run in a sub-shell ...
and the output of that command ...
replaces the command itself
Command substitution uses the following format
```
    $(COMMAND)
```
Where COMMAND is any valid Unix command

Pathname Expansion

Pathname expansion is where you use meta-characters ...
to specify one or more pathnames
The metacharacters are used to create patterns ...
that are called ambiguous file references
The meta-characters are
- ?
- *
- [ ]

Shell Script Control Structures

Control structures are Unix statements that change the order of execution ...
of commands within a program or script
There are two basic types of control structures
- Loops
- Conditionals

The `if ... then ...` Construct

The first conditional is the if ... then statement ...

which has the format

    if COMMAND
    then
        COMMAND_1
        COMMAND_2
        ...
    fi

COMMAND is any Unix command
COMMAND_1, COMMAND_2, ... are a series of Unix commands
The most common comman used with if is test
which must be followed by arguments that form a logical expression
It is used to test the truth or falsity of a condition
The keyword fi must close the conditional statement
The statements between then and fi are executed ...
depending on the status code ...
given by the command that follows if
If the command following if runs without error ...
then it will return an exit status of 0 ...
which the if ... then statment treats as true

`test`

The test command evaluates a logical expression ...
given to it as an argument ...
and returns a status code of 0 ...
if the expression evaluates to true
It returns a status code of 1 ...
if the expression evaluates to false
In an if statement, a status code of 0 means true ...
and a status code greater than 0 means means false

The `test` Operators

test has a number of operators
The operators test for different conditions
When used with two arguments, the operators are placed between

Some operators work only on numbers

Operator Condition Tested

-eq Two numbers are equal

-ne Two numbers are not equal

-ge The first number is greater than, or equal to, the second

-gt The first number is greater than the second

-le The first number is less than, or equal to, the second

-lt The first number is less than the second

Operator	Condition Tested
-eq	Two numbers are equal
-ne	Two numbers are not equal
-ge	The first number is greater than, or equal to, the second
-gt	The first number is greater than the second
-le	The first number is less than, or equal to, the second
-lt	The first number is less than the second

test uses the different operators when comparing strings

Operator Condition Tested

= When placed between strings, are the two strings the same

!= When placed between strings, are the two strings not the same

Note that test uses symbols (=) when comparing strings
But letters preceded by a dash (-eq) when comparing numbers
There are two additional operators ...
that test uses when evaluating two expressions

Operator	Condition Tested
=	When placed between strings, are the two strings the same
!=	When placed between strings, are the two strings not the same

It is placed between the two expressions

Operator Condition Tested

-a Logical AND meaning both expressions must be true

-o Logical OR meaning either of the two expressions must be true

The exclamation mark, ! is a negation operator
It changes the value of the following logical expression
- It changes a false expression to true
- And a true expression to false

Operator	Condition Tested
-a	Logical AND meaning both expressions must be true
-o	Logical OR meaning either of the two expressions must be true

Using `test` in Scripts

Bash provides a synonym for test ...
a pair of square brackets, [ ]
To test whether the value of the variable number1
is greater than the value of the variable number2

you could write either

    test $number1 -gt $number2

    [ $number1 -gt $number2 ]

Whenever you use this construction
there must be a space ...
before and after each square bracket

The `if ... then ... else ...` Construct

The another conditional is the if ... then ... else ... construct ...

which has the following format

    if  COMMAND
    then
      COMMAND_1
      COMMAND_2
      ....
    else
      COMMAND_A
      COMMAND_B
      ...
    fi

If COMMAND returns an exit status of 0 ...
COMMAND_1, COMMAND_2, ... will be executed ...
otherwise COMMAND_A, COMMAND_B, ..., will be run

The `if ... then ... elif ...` Construct

The if ... then ... elif ... construct allows you to create nested if statements

    if COMMAND
    then
      COMMAND_1
      COMMAND_2
      ...
    elif ANOTHER_COMMAND
    then
      COMMAND_A
      COMMAND_B
      ...
    ...
    [else
      COMMAND_N1
      COMMAND_N2
      ...]
    fi

elif stands for "else if"
Notice that elif must be followed by then
The else section is optional

`for ... in ...` Loops

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

`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

`while` Loops

The first two for loops keep running ...
until all values supplied to them ...
have been used in the loop
A while loop continue 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 is returns and exit status of 0 ...
the code block between do and done will be executed

`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 expression 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 out of the loop

`read` Command

The read command sets a variable ...
to a value entered by the user
When Bash is running a script and comes across a line like this
```
read value
```
Bash does the following
- It waits for the user to enter some text
- It assigns the text entered by the user to the variable ...
  whose name follows the read command
When read takes in a value from the terminal ...
it grabs everything the user types ...
until they hit Enter
I can use the -p option to read
to have read issue a prompt
```
read -p "Please enter a number: " num
```
By default, the read command does not allow you to edit text at the terminal ...
the way you can a the command line
But you can enable the readline library to make it possible to edit the line ..
if you use the -e option to read

Today's Topics

Review

Final Exam

Review

Running a Command in the Background

Jobs

Moving a Job from the Foreground into the Background

Aborting a Background Job

Pathname Expansion

The ? Meta-character

The * Meta-character

The [ and ] Meta-characters

Built-ins

Creating Startup Files

Redirecting Standard Error

Shell Scripts

Making a Shell Script Executable

Specifying Which Version of the Shell Will Run a Script

Comments in Shell Scripts

Separating and Grouping Commands

| (pipe) and & (ampersand) as Command Separators

Continuing a Command onto the Next Line

Shell Variables

Local Variables

Global Variables

Keyword Shell Variables

Important Keyword Shell Variables

User-created Variables

Quoting and the Evaluation of Variables

Removing a Variable's Value

Processes

Process Structure

Process Identification

Executing a Command

History

Using the History Mechanism

The Readline Library

Readline Completion

Pathname Completion

Command Completion

Variable Completion

Aliases

Functions

Shell Modification of the Command Line

History Expansion

Alias Substitution

Brace Expansion

Tilde, ~, Expansion

Parameter and Variable Expansion

Command Substitution

Pathname Expansion

Shell Script Control Structures

The if ... then ... Construct

test

The test Operators

Using test in Scripts

The if ... then ... else ... Construct

The if ... then ... elif ... Construct

for ... in ... Loops

for Loops

while Loops

continue

break

read Command

Attendance

The `if ... then ...` Construct

`test`

The `test` Operators

Using `test` in Scripts

The `if ... then ... else ...` Construct

The `if ... then ... elif ...` Construct

`for ... in ...` Loops

`for` Loops

`while` Loops

`continue`

`break`

`read` Command