How to Create and Use Bash Scripts in Linux

Learn how to create and use Bash scripts on Unix/Linux, a required skill for system administration and a handy skill for the rest of us.

A Bash script is analogous to a DOS batch file. In its simplest form, you can run multiple commands in sequence. Like DOS batch files, you can build complex scripts with time. For now, we will look at how to create a few simple, useful bash scripts.

Writing a simple Bash script

Each script starts with a "shebang", followed by the path to the shell you want the script to use.

#!/bin/bash

The "#!" characters are called the shebang.

Scripts usually have comments at the top, which include author information, what the script does and usage instructions. Comments start with a hash - #.

#!/bin/bash

# This is a comment

We want to create a bash script to copy some PHP files from our user development directory to the webserver root. We could manually type in the command each time or create a bash script and call that instead.

Create a new file using your favourite text editor (pico for me) and enter the following lines.

#!/bin/bash

cp *.php /usr/web/public_html

Save the file as something meaningful, for example publish and close the editor.

We now need to make this script executable by changing the Linux permissions.

chmod 700 publish

This will let you, and only you, read, write, and execute the script.

From within the directory you created the script in, you can enter publish on the command line, and it will then execute the command to copy the files to the web server.

Using Variables in a Bash script

Variables are a key component of programming. Variables allow a programmer to store data and alter and reuse it throughout the script.

There are two types of variables - system and user. System variables are created and maintained by the system. They are designated with CAPITAL letters. Some examples are:

• USER: The currently logged-in user.
• HOME: The current user's home directory.
• HOSTNAME: The hostname of the computer at this time.
• TERM: This specifies the type of terminal to emulate when running the shell.
• MAIL: The path to the current user's mailbox.

User variables are ones you create inside your script specifically for your script and cannot be accessed outside it.

Never name your user/private variables using UPPERCASE characters. Uppercase variable names are reserved for internal shell variables, and you run a risk of overwriting them.

We can create a backup script to back up the user's home directory to /tmp/.

#!/bin/bash
# This bash script is used to back up a user's home directory to /tmp/.

user=$(whoami)
input=/home/$user
output=/tmp/${user}_home_$(date +%Y-%m-%d_%H%M%S).tar.gz

tar -czf $output $input
echo "Backup of $input completed!"

In this example, we can see that the user variable "user" has been used to capture the output from the whoami command. It is then appended to a string and assigned to the input variable. An output variable is created, again using string concatenation and date formatting.

Using variables like this makes scripts easier to write, read and maintain.

Finally, the command takes in the variables instead of one long line, which is difficult to read as it will probably span multiple lines.

Parameters and User Input in Bash Scripts

Scripts can take in a series of parameters from the user, such as a filename or path.

Parameters are added after the script name in the command line and separated by a space.

Here is a simple bash script to show parameters read in and shown on the screen.

#!/bin/bash

echo $1 $2 $3

When run using script.sh aaa bbb ccc, it automatically assigns 'aaa' to the variable $1, 'bbb' to $2 and 'ccc' to $3. You can then use these like any other variable.

Functions in Bash Scripts

Functions are small reusable blocks of code which perform one specific action. They can be called from multiple locations and prevent code duplication.

Functions in bash scripts are very similar to functions in other programming languages.

#!/bin/bash

showMessage

function showMessage() {
  echo "Hello World"
}

You can also pass parameters into a function like parameters are passed into a function.

#!/bin/bash

showMessage "Hello World" "This is a message" 

function showMessage() {
  echo $1
  echo $2
}

If...Else...Conditional Statements in Bash Scripts

Sometimes, checking a condition before running a section of code or running one bit of code in certain circumstances and another in a different set of circumstances is necessary.

A basic if statement effectively says that if a particular condition is true, perform a given set of actions.

#!/bin/bash


if [ $1 -gt 100 ]
then
  echo That\'s a large number.
fi

When running this script and passing in a number, if the number is greater than 100, the script will output "That's a large number".

We can extend this to cover numbers less than 100 with a different message.

#!/bin/bash


if [ $1 -gt 100 ]
then
  echo That\'s a large number.
else
  echo That\'s a small number.
fi

If a number less than 100 is entered, it will show "That's a small number".

We can also check another possibility: the user entered 100 and showed another message. In bash scripts, elif is short for else if.

#!/bin/bash


if [ $1 -gt 100 ]
then
  echo That\'s a large number.
elif [ $1 -lt 100 ]
  echo That\'s a small number.
else
  echo You entered 100.
fi

You may need to check multiple conditions using boolean operators.

if [ $USER == 'tim' ] || [ $USER == 'lonewolf' ]
then
  ls -alh
else
  ls
fi

Looping and Iteration in Bash Scripts

Looping is very useful in any programming language. It lets you run a series of commands multiple times, usually over a collection of objects, for example, running a command for every file in a directory.

There are several types of loops; I won't go into detail as to which one does what and when you should use one or the other. You can read more about looping in the article below.

While loop in Bash Script

The while loop is the easiest and works by evaluating a condition, similar to an if statement above, and if true, runs a block of code. If the condition is still true, the code will run again, over and over, until the condition is false.

The basic syntax for a while loop is shown below. It will output the numbers 1 through 10 on the screen.

#!/bin/bash

# Basic while loop
counter=1
while [ $counter -le 10 ]
do
  echo $counter
  ((counter++))
done

It is important to remember that the condition must always be evaluated as false at some point. Otherwise, you will have an infinite loop. If you forgot to increment the counter in the loop above, the system would continue to count on the screen until it broke the system.

For loop in Bash Script

For loops are a little harder to write, but they are more flexible and there is much less chance that you will have an infinite loop.

The same counting script using a for loop is below. It's less code but harder to read if you're unfamiliar with the syntax.

for value in {1..10}
do
  echo $value
done

For loops can work on collections of anything, for example, an array of names.

#!/bin/bash

# Basic for loop
names='Brando Hopkins Caine'
for name in $names
do
  echo $name
done

Useful Bash Scripts

Here is a collection of some of my most useful bash scripts, which you can download and use on your system.

Bash Script for Backup Files

This is my bash script for backing up my home NAS. It will first mount a USB3 external hard drive to /media/backup. It will use rsync to back up the main NAS files, my home directory, apache and mysql directories. Finally, it will run a mysqldump to back up my databases.

#!/bin/bash

sudo mount -t ext4 /dev/sdf1 /media/backup
sudo rsync -av /media/megadrive/files /media/backup/files
sudo rsync -av /home/timmy /media/backup/timmy
sudo rsync -av /etc/apache2 /media/backup/apache
sudo rsync -av /var/lib/mysql /media/backup/mysql/data

sudo mysqldump -uroot -p<password> mastersystem | bzip2 -c > /media/backup/mysql/$(date +%Y-%m-%d-%H.%M.%S).sql.bz2

Extract for all file types

This script will detect the file format of an archive and run the appropriate command to extract the files.

#!/bin/bash

if [ -f $1 ] ; then
  case $1 in
    *.tar.bz2)   tar xvjf $1    ;;
    *.tar.gz)    tar xvzf $1    ;;
    *.tar.xz)    tar Jxvf $1    ;;
    *.bz2)       bunzip2 $1     ;;
    *.rar)       rar x $1       ;;
    *.gz)        gunzip $1      ;;
    *.tar)       tar xvf $1     ;;
    *.tbz2)      tar xvjf $1    ;;
    *.tgz)       tar xvzf $1    ;;
    *.zip)       unzip -d `echo $1 | sed 's/\(.*\)\.zip/\1/'` $1;;
    *.Z)         uncompress $1  ;;
    *.7z)        7z x $1        ;;
    *)           echo "don't know how to extract '$1'" ;;
  esac
else
  echo "'$1' is not a valid file!"
fi

Go Up Directory Tree

This little script is useful for directory navigation. Say you are in a deep directory, like /media/megadrive/wwwroot/public_html/lonewolfonline/wp-content/themes/lonewolf/css. If you wanted to go back to the root of public_html, you would either have to cd ../../../.. or you can use this to go up 4 (if you name the script up).

#!/bin/bash

LIMIT=$1
P=$PWD
for ((i=1; i <= LIMIT; i++))
do
    P=$P/..
done
cd $P

Bash Script to Remove Empty Directories

This bash script will scan and remove empty directories.

#!/bin/bash

[ $# -lt 1 ] && set -- .

find "$@" -type d -depth -print |
    while read dir
    do
[ `ls "$dir" | wc -l` -lt 1 ] || continue
echo >&2 "$0: removing empty directory: $dir"
rmdir "$dir" || exit $?
    done
exit 0