See this page as a slide show

Bash Shell Scripting

CS155 ShellScripts

What’s a shell script?

• What is a actor’s script?
  • It’s a bunch of words that the actor should say.
• What is a shell script?
  • It’s a bunch of commands that the shell should execute.

Shell Scripts

• All shell scripts should begin with a line indicating the program that should interpret them.
  #! /bin/bash
• If you write a shell script in the language of another shell, put its path in place of /bin/bash e.g., /bin/tcsh or /usr/bin/perl
• For the rest of this lecture, we’re talking about bash only.

Shell Scripts

#! /bin/bash
mkdir 155tmp
touch 155tmp/helloWorld
echo "Lala it's Saturday" > 155tmp/satdaze
cat 155tmp/satdaze
date

• Put your regular terminal commands in to a shell script to run
• To run a shell script, make sure it has execute permission, then type in the name of the file at the prompt.

A common pitfall

• Do not call your shell script test.
• There’s already a command called test, and the shell will run that test, and not your test.
• To be safe, run your shell script like this: ./whatever
  This will ensure that the shell runs the script that’s in ., your current directory.

Shell Variables

#! /bin/bash
dir=155tmp
mkdir $dir
touch $dir/helloWorld
echo "Lala it's Saturday" > $dir/satdaze
cat $dir/satdaze
date

• To set a non-numeric (string) variable:
  varName=value
  • Example: name=Jack
• To set a number variable:
  let varName=expression
  • Example: let age=2024-1957
• To refer to either type of variable: $varName
• To capture the output of a command:
  varName=$(command)
  • For example: size=$(wc -c <monster)

Examples of setting variables:

An Annoying Special Case

• ${var} – access a variable with stuff after it:
  echo ${HOST}zulu

Special Shell Variables

How do you tell if $2 exists?

More About Shell Variables

#! /bin/bash
if [[ $# -ne 1 ]]
then
    echo "Usage: $0 file"
    exit 1
fi
ls -l $1

• Run the file zot like this: ./zot
• or this: ./zot x
• or this: ./zot x y z
• ./zot hello 543 results in:
  • $0 = ./zot
  • $1 = hello
  • $2 = 543

Basic Math

% echo $UID
2543
% let x="UID*2"
echo $x
5086

All numeric values in the shell are integers. There is no fractional part.

• let name=expr
  assign a numerical expression to name
• let x="100/(2*3+4)"
  for anything complicated, quote the whole darn thing

Control Flow: Conditional Execution

Often, we will only want to execute a command if some condition is true (or false).

if [[ expr ]]
then
     command
     command 
fi

if [[ expr1 ]]
then
    command1
elif [[ expr2 ]]
then
    command2
else
    command3
fi

if [[ expr ]]
then
     command1a
     command1b
else
     command2a
     command2b
fi

Logical operations

if [[ $1 -le 0 || $2 -le 0 ]]
then
    echo "All arguments must be positive."
    exit 1
fi

let age=52
sex="M"
if [[ age -ge 21 && $sex = "M" ]]
then
    echo "Voter in 1916!"
fi
if [[ ! ($sex = "M") ]]
then
    echo "Hello, ma'am!"
fi

• && means “and” (both halves must be true)
• || means “or” (one half or the other half or both halves must be true)
• ! means “not”

Conditional Execution: Examples

Conditional examples:

% cat scrpt
#! /bin/bash
if [[ $HOSTNAME = "denver" ]]
then
    echo "Mile high!"
elif [[ $HOSTNAME = "lansing" ]]
then
    echo "Welcome to the mitten state!"
else
    echo "Where am I?"
fi
% ls -l scrpt
-rwx------  1 cs155 class 193 Nov 23 05:58 scrpt
% ./scrpt
Where am I?

A $? example

#! /bin/bash
grep "foo" xyz >dummy
if [[ $? -eq 0 ]]
then
    echo "Hooray, we found foo in the file xyz!"
else
    echo "Sorry, foo was not found in the file xyz."
fi
rm dummy                        # be tidy

Why didn’t we rm dummy immediately after creating it? We don’t need its contents—why not get rid of it as soon as possible?

Comparison Operators

if [[ COLUMNS -lt 80 ]]
then
    echo "This terminal is too narrow."
    echo "It’s only $COLUMNS characters wide."
    echo "This program requires at least 80 characters."
fi

A $ is not required on variables when doing numeric comparisons. You still need a $ when comparing strings.

Comparing strings

Here’s how to compare strings (not numbers):

Surprisingly, there are no ≤ or ≥ operators.
Remember: spaces around operators!

Comparing numbers

Here’s how to compare numbers:

Remember: spaces around operators!

Combining comparisons:

Remember spaces around operators!

Another conditional example

#! /bin/bash

let hour=$(date "+%k")              # 0–23

if [[ hour -lt 12 ]]                # Is it 0–11?
then
    echo "Good morning!"
elif [[ hour -lt 18 ]]              # Is it 12–17?
then
    echo "Good afternoon!"
else                                # Is it 18–23?
    echo "Good evening!"
fi

Yet another conditional example

#! /bin/bash

# $1 is the first argument to this program.
# $2 is the second argument to this program.
# $3 is the third argument to this program.

if [[ $1 -eq $2 && $2 -eq $3 ]]
then
    echo "They are all the same!"
else
    echo "This is no good—they’re different."
fi

File Inquiry Operators

if [[ -d my_file ]]
then
    rmdir my_file
fi
if [[ -e my_file ]]
then
    echo "my_file still exists"
fi

• Often, we want commands executed if a file has a certain feature (e.g., if it is readable)
• File Inquiry Operators answer questions about files:
  • -r : test if file is readable
  • -w : test if file is writable
  • -x : test if file is executable
  • -e : test if file exists
  • -d : test if file is a directory
  • -s : test if file has non-zero size

Spaces

If the world were consistent, life would be much easier.
In the following examples, spaces look like this.

Spaces are nearly forbidden in a let statement: let a=b+c/2

Spaces are required in an if statement: if [[ $a -eq 42 ]]