Linux Shell Scripting with Bash

bash-icone1So back to basics. I am trying to do some shell scripting in Linux using Bash. There’s a vast number of commands that you can use that bash can interpret, so i can’t do it in one posting. From time to time i will be posting some commands that i used for bash. So for the meantime here are the basics of bash commands.


bashBash Keywords
A keyword is a word or symbol that has a special meaning to a computer language.The
following symbols and words have special meanings to Bash when they are unquoted
and the first word of a command.

      !      esac       select            }
      case   fi         then              [[
      do     for        until             ]]
      done   function   while            
      elif   if         time              
      else   in         {

Unlike most computer languages, Bash allows keywords to be used as variable names
even though this can make scripts difficult to read.To keep scripts understandable, keywords
should not be used for variable names.
Command Basics
The commands that can be typed at the Bash shell prompt are usually Linux programs
stored externally on your file system. Some commands are built into the shell for speed,
standardization, or because they can function properly only when they are built-in.

No matter what their source, commands fall into a number of informal categories.
Utilities are general-purpose commands useful in many applications, such as returning the
date or counting the number of lines in a file.
Filters are commands that take the results of one command and modify them in some
way, such as removing unwanted lines or substituting one word for another. Many commands
act as filters under the right circumstances.
To execute a command, type it at the Bash command prompt.The prompt is usually a
$, but often Linux distributions customize it to something else. S.u.S.E., for example, uses
a > command prompt.
The date command prints the current date and time on the screen.

$ date
Wed Apr 4 10:44:52 EDT 2001

All files, including shell commands, are case-sensitive. By convention, all shell commands
are in lowercase.

bash: DATE: command not found

Arguments are additional information supplied to a command to change its behavior.
The date command takes a format argument to change the appearance of the date and

$ date ‘+%H:%M’

Switches (also called “options” or “flags”) are characters proceeded by a minus sign that
enable command features.To see the date in Coordinated Universal Time (UTC, formerly
called GMT), use the -u switch.

$ date -u
Wed Apr 4 14:46:41 UTC 2001

Because the terms “options” and “flags” are used in so many contexts, they are
referred to as switches in this book.
Switches and arguments are collectively called parameters. Some commands allow any
number of parameters or have parameters that can be arranged in complex ways.
The GNU and Linux convention is for longer, more readable options to be proceeded
by a double minus sign.The longer equivalent to the -u switch is –universal.

$ date --universal
Wed Apr 4 14:46:41 UTC 2001

The long switches remind the reader exactly what the switch does.This makes future
debugging of shell scripts much easier because there is no standard convention for the
short switches across Linux commands. Most Linux commands recognize the long
switches –help, –verbose, and –version.
Command-Line Editing 15
Comments can be added to the end of any command or they can be typed on a line
by themselves. Comments are denoted with a number sign (#).

 $ date --universal # show the date in UTC format

Built-in Bash commands and most other GNU software treat — as a special switch
that indicates the end of a list of switches.This can be used when one of the arguments
starts with a minus sign.
Command-Line Editing

There are special key combinations to edit what you type or to repeat previous commands.
Bash has two editing modes.These modes emulate the keys used in two popular
Linux text editors. Vi mode mimics the vi and vim editors. Emacs mode works like emacs,
nano or pico.

The current editing mode can be checked with the shopt command. shopt -o
emacs is on if you are in emacs mode. shopt -o vi is on if you are in vi mode. Only
one mode can be on at a time.

$ shopt -o emacs
emacs on
$ shopt -o vi
vi off

Regardless of the mode, the arrow keys move the cursor and step through the most
recently executed command:
n Left arrow—Moves back one character to the left. No characters are erased.
n Right arrow—Moves forward one character to the right.
n Up arrow—Moves to the previous command in the command history.
n Down arrow—Moves to the next command in the command history (if any).
Using the left and right arrows, the cursor moves to any position in the command. In
the middle of a line, new text is inserted into the line without overwriting any old

Emacs mode is the default mode on all the major Linux distributions.The most common
emacs keys are as follows:

n control-b—Moves back one character to the left. No characters are erased.
n control-f—Moves forward one character to the right.
n control-p—Moves to the previous command in the command history.
n control-n—Moves to the next command in the command history (if any).
n Tab key—Finds a matching filename and completes it if there is one exact match.

The filename completion feature attempts to find a matching filename beginning
with the final word on the line. If a matching filename is found, the rest of the filename
is typed in by Bash. For example,
$ dat
is completed when the Tab key is pressed to

 $ date

if date is the only command that can be found starting with the characters dat.
The vi mode key combinations are as follows:
n Esc—Enters/exits editing mode.
n h—Moves back one character to the left. No characters are erased.
n l—Moves forward one character to the right.
n k—Moves to the previous command in the command history.
n j—Moves to the next command in the command history (if any).
n Esc twice—Finds a matching filename and completes it if there is one exact

A complete list of key combinations (or bindings) is listed in the Bash man page in the
Readline section.The default key combinations can be changed, listed, or reassigned
using the bind command.To avoid confusion, it is best to work with the defaults unless
you have a specific application in mind.

Other editing keys are controlled by the older Linux stty (set teletype) command.
Running stty shows the common command keys as well as other information about
your session. Use the -a (all) switch for all settings.

$ stty
speed 9600 baud; evenp hupcl
intr = ^C; erase = ^?; kill = ^X;
eol2 = ^@; swtch = ^@;
susp = ^Z; dsusp = ^Y;
werase = ^W; lnext = ^@;
-inpck -istrip icrnl -ixany ixoff onlcr
-iexten echo echoe echok
-echoctl -echoke

Many of these settings are used only when you’re working with serial port devices
and can be ignored otherwise.The other settings are control key combinations marked
with a caret (^) symbol. Keys with ^@ (or ASCII 0) are not defined.The keys are as follows:
n erase (usually ^?, which is the backspace key on IBM-style keyboards)—Moves
left and erases one character.
n intr (usually ^C)—Interrupts/stops the current program or cancels the current

n kill (usually ^X)—Erases the current line.
Variable Assignments and Displaying Messages 17
n rprnt (usually ^R)—Redraws the current line.
n stop (usually ^S)—Pauses the program so you can read the results on the screen.
n start (usually ^Q)—Resumes the program.
n susp (usually ^Z)—Suspends the current program.
n werase (usually ^W)—Erases the last word typed.
To change the suspend character to control-v, type
$ stty susp ‘^v’

Changing key combinations can be very difficult. For example, if you are running an
X Windows server (the software that runs on a client computer) on a Microsoft Windows
computer to access a Linux computer, key combinations can be affected by the

n Microsoft Windows
n The X server software
n The Linux window manager
n The stty settings
Each acts like layers of an onion and they must all be in agreement. For example,
shift-insert, often used to paste text, might be handled by your X Window server before
your Linux computer or your shell have a chance to see it.
Variable Assignments and Displaying Messages
Variables can be created and assigned text using an equals sign. Surround the text with
double quotes.

$ FILENAME=”info.txt”

The value of variables can be printed using the printf command. printf has two
arguments: a formatting code, and the variable to display. For simple variables, the formatting
code is “%s\n” and the variable name should appear in double quotes with a
dollar sign in front of the name

$ printf “%s\n” “$FILENAME” 

printf can also display simple messages. Put the message in the place of the formatting

 $ printf “Bash is a great shell.\n”

Bash is a great shell.

printf and variables play an important role in shell scripting and they are described
in greater detail in the chapters to come.
18 Chapter 2 Operating the Shell
The results of a command can be assigned to a variable using backquotes.

$ DATE=`date`
$ printf “%s\n” “$DATE”
Wed Feb 13 15:36:41 EST 2002

The date shown is the date when the variable DATE is assigned its value.The value of
the variable remains the same until a new value is assigned.

$ printf “%s\n” “$DATE”
Wed Feb 13 15:36:41 EST 2002
$ DATE=`date`
$ printf “%s\n” “$DATE”
Wed Feb 13 15:36:48 EST 2002

Multiple Commands
Multiple commands can be combined on a single line. How they are executed depends
on what symbols separate them.
If each command is separated by a semicolon, the commands are executed consecutively,
one after another.

$ printf “%s\n” “This is executed” ; printf “%s\n” “And so is this”
This is executed
And so is this

If each command is separated by a double ampersand (&&), the commands are executed
until one of them fails or until all the commands are executed.

$ date && printf “%s\n” “The date command was successful”
Wed Aug 15 14:36:32 EDT 2001 
The date command was successful

If each command is separated by a double vertical bar (||), the commands are executed
as long as each one fails until all the commands are executed.

$ date ‘duck!’ || printf “%s\n” “The date command failed”
date: bad conversion
The date command failed

Semicolons, double ampersands, and double vertical bars can be freely mixed in a single

 $ date ‘format-this!’ || printf “%s\n” “The date command failed” && \
printf “%s\n” “But the printf didn’t!”
date: bad conversion
The date command failed
But the printf didn’t!

These are primarily intended as command-line shortcuts:When mixed with redirection
operators such as >, a long command chain is difficult to read and you should avoid
it in scripts.

Command History 19
Command History

Bash keeps a list of the most recently typed commands.This list is the command history.
The easiest way to browse the command history is with the Up and Down arrow
keys.The history can also be searched with an exclamation mark (!).This denotes the
start of a command name to be completed by Bash. Bash executes the most recent command
that matches. For example,

$ date
Wed Apr 4 11:55:58 EDT 2001
$ !d
Wed Apr 4 11:55:58 EDT 2001

If there is no matching command, Bash replies with an event not found error

$ !x
bash: !x: event not found

A double ! repeats the last command.

$ date
Thu Jul 5 14:03:25 EDT 2001
$ !!
Thu Jul 5 14:03:28 EDT 2001

There are many variations of the ! command to provide shortcuts in specific situations.
A negative number indicates the relative line number.That is, it indicates the number
of commands to move back in the history to find the one to execute. !! is the same as

$ date
Thu Jul 5 14:04:54 EDT 2001
$ printf “%s\n” $PWD
$ !-2
Thu Jul 5 14:05:15 EDT 2001

The !# repeats the content of the current command line. (Don’t confuse this with #!
in shell scripts.) Use this to run a set of commands twice.

 $ date ; sleep 5 ; !#
date ; sleep 5 ; date ; sleep 5 ;
Fri Jan 18 15:26:54 EST 2002
Fri Jan 18 15:26:59 EST 2002
20 Chapter 2 Operating the Shell

Bash keeps the command history in a file called .bash_history unless a variable
called HISTFILE is defined. Each time you quit a Bash session, Bash saves the history of
your session to the history file. If the histappend shell option is on, the history is
appended to the old history up to the maximum allowed size of the history file. Each
time you start a Bash session, the history is loaded again from the file.
Another shell option, histverify, enables you to edit the command after it’s
retrieved instead of executing it immediately.

Bash has a built-in command, history, which gives full control over the command
history.The history command with no parameters lists the command history. If you
don’t want to see the entire history, specify the number of command lines to show.

$ history 10
1026 set -o emacs
1027 stty
1028 man stty
1029 stty -a
1030 date edhhh
1031 date edhhh
1032 date
1033 date
1034 !
1035 history 10

You can test which command will be matched during a history completion using the
-p switch.

$ history -p !d
history -p date

A particular command line can be referred to by the line number.

$ !1133
Thu Jul 5 14:09:05 EDT 2001

history -d deletes an entry in the history.

$ history -d 1029
$ history 10
1027 stty
1028 man stty
1029 date edhhh
1030 date edhhh
1031 date
1032 date
1033 !
1034 history 10
1035 history -d 1029
1036 history 10
Directory Commands 21

The -s switch adds new history entries. -w (write) and -r (read) save or load the history
from a file, respectively.The -a (append) switch appends the current session history to
the history file.This is done automatically when you quit the shell.The -n switch loads
the complete history from the history file. history -c (clear) deletes the entire history.
The command history can be searched with !? for the most recent command containing
the text. If there is additional typing after the !? search, the command fragment
will be delineated with a trailing ?.

$ date
Thu Jul 5 14:12:33 EDT 2001
$ !?ate
Thu Jul 5 14:12:38 EDT 2001
$ !?da? ‘+%Y’
date ‘+%Y’

The quick substitution history command, ^, runs the last command again, replacing
one string with another.

$ date ‘+%Y’
$ ^%Y^%m^
date ‘+%m’

The Bash history can be turned off by unsetting the -o history shell option.The
cmdhist option saves multiple line commands in the history.The lithist option breaks
up commands separated by semicolons into separate lines.
Directory Commands
The built-in pwd (present working directory) command returns the name of your current

$ pwd

Although you might not think such a simple command needs options, pwd has a couple
of switches.The -P (physical) switchshows the actual directory, whereas the default -L
(logical) switch shows the directory, including any symbolic links. For example, if /home
was a link to a directory called /user_drive/homes, the switches work as follows:

$ pwd -P
$ pwd -L
22 Chapter 2 Operating the Shell

The built-in cd (change directory) command changes your current directory. As discussed
in Chapter 1,“The Linux Environment,” the special directory .. represents the
parent directory, whereas . represents the current directory.

$ pwd
$ cd .
$ pwd
$ cd ..
$ pwd
$ cd dsmith
$ pwd

Each time you change the directory, Bash updates the variable PWD containing the
path to your current working directory. Bash also maintains a second variable called OLDPWD
that contains the last directory you were in.
Using the minus sign (–) with cd, you can switch between the current directory and
the last directory.This is a useful shortcut if you are doing work in two different directories.

$ pwd
$ cd ..
$ pwd
$ cd -
$ pwd
$ cd -
$ pwd

The tilde (~) represents your current directory. Use it to move to a directory relative
to your home directory.To move to a directory called mail in your home directory, type

$ cd ~/mail

Although . and .. work in all Linux programs, ~ and – are features of Bash and only
work with Bash and Bash scripts.

cd by itself returns you to your home directory, the same as cd ~.
If a CDPATH variable exists, it is assumed to contain a list of directories similar to the
PATH variable.This is a throwback to the days when a user was only able to use one shell
session on his terminal and is now considered a security risk. Its use should be avoided.

Specialized Navigation and History 23
Specialized Navigation and History

Because most users can open multiple shell sessions, there is little need for complex
movement between directories. cd – switches between two directories, which is suitable
for most circumstances. However, if you are restricted to a single shell session and want
Bash to remember more directories, there are three built-in commands that maintain a
list of directories.

The built-in dirs command shows the list of saved directories.The current directory
is always the first item in the list.

$ dirs

The built-in pushd (push directory) command adds (or pushes) directories onto the list
and changes the current directory to the new directory.

 $ pushd /home/dsmith/invoices
~/invoices ~ 
$ pushd /home/dsmith/work
~/work ~/invoices ~
$ pwd

There are now three directories in the list.
The -n (no change) switch will put a directory into the list without changing directories.
-N (rotate Nth) moves the nth directory from the left (or, with +N, from the right) to
the top of the list.
The dirs -l switch displays the directory names without any short forms.

$ dirs -l
/home/dsmith/work /home/dsmith/invoices /home/dsmith

The -v switchdisplays the list as a single column, and -p shows the same information
without the list position.The -c switch clears the list.The -N (view Nth) shows the nth
directory from the left (or, with +N, from the right).

$ dirs +1

The built-in popd (pop directory) command is the opposite of the pushd. popd discards
the first directory and moves to the next directory in the list.

 $ popd
~/invoices ~
$ pwd

The switches for popd are similar to pushd: -n to pop without moving, and -N to
delete the Nth entry from the left (or, with +N, the right).
24 Chapter 2 Operating the Shell
The Colon Command
The simplest shell command is the colon (:).This is the colon command (sometimes called
a “no-op” or “null command”) and does nothing.What’s the use of a command that
does nothing? There are some places in shell programs where a statement is required. In
those cases, you can use : to indicate nothing special should be done.
At the command prompt, : has no effect.

$ :

The colon command can have parameters and file redirections.This can have strange
effects, such as running the date command using backquotes, giving the results to the
null command that quietly discards them.

$ : `date`

This has the same effect as redirecting the output of date to the /dev/null file.

$ date > /dev/null


date Command Switches
n –date=s (or -d s)—Displays time described by s.
n –file=f (or -f f)—Displays times listed in file f.
n –iso-8601=t (or -I t)—Displays an ISO-8601 standard time.
n –reference=f (or -r f)—Displays last modification date of file.
n –rfc-822 (or -R)—Uses RFC-822 format.
n –universal (or –utc or -u)—Uses Coordinated Universal Time.

stty Command Switches
n –all (or -a)—Displays all stty settings.
n –save (or -g)—Displays settings so they can be used as parameters to stty.
n –file=d (or -F d)—Opens tty device d instead of stdin.

history Command Switches
n -a—Appends to history file.
n -c—Clears history.
n -d—Deletes history entry.
n -n—Loads from history file.
n -p—Performs history lookup/substitution.
n -r—Reads history from a file.
n -s—Adds new history entries.

pwd Command Switches

n -P—Physical directory
n -L—Logical directory

dirs Command Switches
n -c—Clears all entries
n -l—Shows a long listing (no tildes)
n -p—Lists the entries
n -v—Shows a verbose listing

One thought on “Linux Shell Scripting with Bash

  1. I read this article completely concerning the resemblance of latest and preceding technologies, it’s remarkable article.

Leave a Reply

Fill in your details below or click an icon to log in: Logo

You are commenting using your account. Log Out / Change )

Twitter picture

You are commenting using your Twitter account. Log Out / Change )

Facebook photo

You are commenting using your Facebook account. Log Out / Change )

Google+ photo

You are commenting using your Google+ account. Log Out / Change )

Connecting to %s