Bash Shell Scripting

What are Shell Scripts?

• Files containing a series of commands
  • In other OSs they have the .sh extension
• A shell is a program that passes commands to the operating system
  • ​You interact with the shell using the CLI
• Shells and command languages are also scripting languages
• • You can write programs in Bash to be interpreted and executed by the shell
• Before we start writing shell scripts, let's get used to a few awesome Bash concepts

Bash Tips

• Your ~/.bashrc file gets read and its commands are applied whenever you start a shell session
  • ​This is where you'll put your settings and any shell functions (more on that later)

  • export EDITOR=/usr/bin/vim

  • ​bind "TAB:menu-complete"

  • bind "set show-all-if-ambiguous on"

  • bind "set completion-ignore-case on"

• When writing long commands, you can hold Control and press 'x' then 'e' to edit the command in Vim
• Ctrl+l to clear the terminal screen
• !! is the last run command
  • Ex. sudo !! runs the last command as sudo (if you forgot to do so)

Control Operators

• ; runs commands sequentially

  • command1 ; command2

• & runs commands in the background

  • command1 & command2

• && runs one command after another has successfully executed

  • command1 && command2

  • AND operator
• || runs one command after another fails

  • command1 || command2

  • OR operator

  • Can also be written as an if else statement

echo & shell stuff

• echo is a command that prints out its arguments into the command line
• When you press Enter/Return, the shell translates whatever is typed in before it is interpreted. Try these:

  • echo hello world

  • echo *

• * is an expansion that matches all characters in a filename, the shell doesn't literally read it as *, it reads it as the wildcard expansion results

  • ​​​echo ~/*

Expansions

• Expansions are character sequences that are changed before the shell acts on it

• $((arithmetic expression))

  • echo $(((5*5)+10)) is equal to 35

• Brace expansion is great for working on multiple character sequences and files
  • Separate the different arguments in the curly braces with commas and NO SPACES
  • You can use .. to produce a range of numbers/letters

    • echo front-{A..D}-back
      

    • echo number{1..7..2} 

    • touch {john.py,irene.py,yukio.py}

    • rm {john,irene,yukio}.py

More Shell Stuff

• Parameter expansion uses variables for Bash
  • Use the printenv command to see environment variables
  • Variables are denoted with a $

    • echo $USER

    • echo $PATH

      • The PATH variable is very important! You'll see why soon

• Command substitution allows you to use a command's output as an expansion

• $(command)

  • echo $(ls)

  • sudo pacman -R $(pacman -Qdtq)

Writing Shell Scripts

• The first line of every shell script should be a shebang (#!)
  • Tells the shell which interpreter to use

  • #!/bin/bash

• Like Python, you comment lines in Bash with #
  • Not to be confused with #!
• Let's write our first simple shell script: hello_world

#!/bin/bash

echo "Hello World!"

Executing Shell Scripts

• Before we run our shell script, we have to make it executable
  • Remember file permissions? ls -l

• chmod +x hello_world

  • You could also use the octal modes 755 or just 700
• Now let's run our script!

  • ./hello_world

  • The "./" is writing out the relative path, . denotes the current directory

Script Location

• Why did we have to write the path instead of just typing in hello_world?
  • Remember the PATH environment variable?

    • echo $PATH

  • Whenever you execute a command, the shell searches through the directories in the PATH variable for an executable program. Having the path written out gives the system the file
• If you don't want to have to write the path, you can move the script into one of those directories (like /bin or /usr/bin), or add a directory to your $PATH

Adding Paths to $PATH

• You can either add the path to the beginning or end of the PATH variable
  • The order matters for which directories get searched first
• Add to your .bashrc:

  • export PATH=/path/you/want:$PATH

  • export PATH=$PATH:/path/you/want

Variables

• Like Python, Bash creates variables as they are encountered during assignment

• variable=value

  • No spaces!
• Call the variable how you normally would in Bash
• Unless specified otherwise, all data in variables are stored as strings

#!/bin/bash

title="Detailed Contents of Directory"
stuff=$(ls -alh)

echo "$title

$stuff"

Here Documents

• Another way to output text other than echo is using a here document
  • Embeds a body of text into the script and feeds it to the standard input using redirection

    • command << token

    • text

    • token

  • command is a command that accepts stdin (like cat) and token is a string that's used to indicate the end of the text
    • _EOF_ is usually used as a token, meaning end of file
• Pretty much the same as echo, except single and double quotes aren't expanded and lose their meaning to the shell

Here Documents

#!/bin/bash

title="Detailed Contents of Directory"
stuff=$(ls -alh)

cat << _EOF_
$title
"Here is a list of"
'the contents of the pwd'
    yay!
$stuff
_EOF_

# Change the redirection operator to <<- if you
# want to ignore leading tabs for formatting

Scripting Review Exercise

Create a script that generates a System Information Page. The page should display a timestamp of when it was created (and by who), the shell you're using , how long the computer has been on, and disk space usage.

• Use a here document
• Use the following variables:
  • $USER, $SHELL
  • Create 2 of your own
• Use the following commands:
  • df -h
  • date
  • uptime -p
• For the HTML: Use <h1>, <h2>, <p>, and <pre> tags

<!--The HTML skeleton-->

<html>
    <head>
        <title></title>
    </head>
    <body>
        page content
        goes here
    </body>
</html>

Shell Functions

• Shell functions are like functions in Python, except they're written as "miniscripts" located inside of scripts that can act as programs
• There are 2 different ways to define functions

function name {
    commands
    return
}

name() {
    commands
    return
}

# call functions by 
# writing the name

name

• name is the name of the function
• commands is the series of commands executed by the function
• return is optional
• Local variables are defined with the keyword local preceding the name

Function Positional Parameters

• Shell functions can take in command line arguments
  • Use the variables $1, $2, $3, ..., $n to access the arguments based on its position
  • Call the function like so: functionName foo bar
    • foo is the first argument that is stored in $1
    • bar is the second argument that's stored in $2
• Special variables:
  • $0 holds the command/function name
  • $* or $@ holds all parameters/arguments passed to the function
  • $# holds the number of positional parameters passed to the function

Shell Functions in your .bashrc

• Shell functions can be written in your .bashrc to be executed as commands
• Great replacement for aliases
  • Aliases are limited in shell features, functions are not
• Useful Exercise:
  • Write a function cd() in your .bashrc  that automatically executes ls whenever you cd into a directory
  • Hint: Use the builtin keyword so your function isn't recursive and runs forever
• Since your .bashrc is read whenever you start a new shell session, you have to open a new terminal or source the file to use your new function

  • source ~/.bashrc

read

• read is a built-in command that reads a single line of keyboard input and stores it in a variable(s) that's passed in as an argument

  • read [-options] [variables]

  • A lot of the options are really useful, look them up!

#!/bin/bash

echo -n "Please enter a word: "
read word

echo $word

test

• The best command to use with if statements (covered next) is test

  • ​[ expression ]

  • test expression

  • expression is an expression that's evaluated as either true or false
• Check the manual for test to see how to use it!

  • man test

  • Test equality/inequality in strings and integers
  • Evaluate the status of files

if Statements

# Syntax of if statements

if commands; then
    commands
elif commands; then
    commands
else
    commands
fi

python=5

if [ $python == 5 ]; then
    echo "Python is cool"
elif [ $python == 6 ]; then
    echo "Python isn't cool"
else
    echo "C is annoying"
fi

• commands is a list of commands
• You can also enter it directly into the command line with ; as the newline separator (not after the then though)
• The shell evaluates the success or failure of a command through the exit status

Exit Status

• When a command (or shell function/script) finishes executing and terminates, it issues an integer in the range of 0 to 255 to the system called the exit status
  • ​0 indicates success
  • Any other number (1-254) indicates failure
• The variable $? holds the value of the exit status
• The commands true and false always terminate with a 0 and 1 exit status, respectively

  • true

  • echo $?

  • false

  • echo $?

Scripting Review Exercise

Write a shell script that takes gives the user 5 seconds to enter a number, and then prints out whether that number is even or odd

Other ways to use test

• A more modern, enhanced replacement for test​

  • [[ expression ]]

  • Supports all test expressions/arguments, but has a couple of additions

    • ​string =~ regex where regex is an extended regular expression; used for data validation

    • The == operator supports pathname expansion *

• Operate on integers with ((  ))
  • ​Performs arithmetic truth tests

    • Ex. if ((INT == 0)); then echo "INT is zero"; fi

• Combine expressions using the && and || operators
• ! is the NOT operator