How to Invoke Script made using Bash

So you made your script. Now you need to test it by running it. You can invoke it by sh <scriptname>, or alternatively bash <scriptname>.(Not recommended is using sh <scriptname>, since this effectively disables reading from stdin within the script.) Much more convenient is to make the script itself directly executable with a chmod.
Either:

chmod 555 scriptname

(gives everyone read/execute permission)

or

chmod +rx scriptname

(gives everyone read/execute permission)

 or

chmod u+rx scriptname

(gives only the script owner read/execute permission)

 

Having made the script executable, you may now test it by ./scriptname.  If it begins with a “sha−bang” line, invoking the script calls the correct command interpreter to run it.

As a final step, after testing and debugging, you would likely want to move it to /usr/local/bin (as root,of course), to make the script available to yourself and all other users as a system−wide executable. The script could then be invoked by simply typing scriptname[ENTER] from the command line.

Linux Shell Scripting with Bash(Bash Commands)

Getting Help

The Bash shell comes with a built-in help command to describe the various built-in Bash commands.The -s switch displays a summary for the command you specify.

$ help -s printf
printf: printf format [arguments]

Help only describes Bash commands.To get help on Linux commands, you need to use the man (manual) command.

 $ man date
32 Chapter 3 Files, Users, and Shell Customization

Linux divides its manual pages into a number of logical volumes. man displays any matching entries from any volume.Volume 1 contains the commands you can execute from the shell.To restrict your search to shell commands, use man 1.

 $ man 1 date

If there are pages in more than one manual volume, only the page from the first volume that matches your search is displayed.To find matching pages across all manual volumes, use the -a (all) switch.
The -k switch searches the Linux manual for a particular keyword and lists all man pages referring to that keyword.

 $ man 1 -k alias

The command help type gives you different information than man 1 type.The help type command tells you about Bash’s built-in type command, whereas the man 1 type command tells you about the Linux type command. If you are not sure whether a command is a Bash command, always try the help command before using the man command.

Fixing the Display

There will be times when a Bash session becomes unusable. Certain character sequences can lock your display, hide what you type, or change the characters being shown into strange symbols.This can happen, for example, when you’re trying to display a binary file.

The reset command attempts to restore a Bash session to a safe, sane state. If reset fails, you might also need to use stty sane to restore the session to a normal state. The clear command clears the display and returns the cursor to the upper-left corner.
There are several Linux commands for removing, copying, and moving files. mkdir (make directory) creates a new directory. Use mkdir to organize your files.

$ mkdir prototypes
$ ls -l
total 4
drwxr-xr-x 2 ken users 4096 Jan 24 12:50 prototypes

There are two switches for mkdir:
n –mode=m (-m)—Sets the permission mode (as in chmod)
n –parents (-p)—Makes all necessary directories even if they don’t currently exist

$ mkdir --parents --mode=550 read_only/backup/january
$ ls -l
Working with Files 33
total 4
drwxr-xr-x 2 ken users 4096 Jan 24 12:50 backup
drwxr-xr-x 3 ken users 4096 Jan 24 12:51 read_only
$ ls -l read_only/backup
total 4
dr-xr-x--- 2 ken users 4096 Jan 24 12:51 january

The values for mode are discussed with the chmod command in Chapter 15,“Shell Security.” However, when –parents is used, the –mode affects only the final directory in the list.

rmdir (remove directory) deletes a directory.The directory must be empty before it can be removed.There are two switches: n –ignore-fail-on-non-empty—Doesn’t report an error when it can’t delete a directory with files still in it
n –parents (-p)—Removes all parent directories as well as the subdirectory

 $ rmdir read_only
rmdir: read_only: Directory not empty
$ rmdir --parents read_only/backup/january/

The rm (remove) command permanently deletes files. If the file is a symbolic or hard link, it removes the link but leaves the file intact.

$ rm old_notes.txt
$ ls old_notes.txt
ls: old_notes.txt: No such file or directory

There are several switches for rm:
n –directory (-d)—Removes a directory
n –force (-f)—Never prompts the user and ignores missing files
n –interactive (-i)—Always prompts the user
n –recursive (-r or -R)—Removes contents of all subdirectories

Using the –recursive and –force switches simultaneously removes all the specified files, including all sub directories, without warning. Make sure you are deleting the correct files.

Some Linux distributions have the –interactive switch on by default so that rm requires that you confirm when you want to delete a particular file.

$ rm --interactive old_notes.txt
rm: remove ‘old_notes.txt’? y
$

Normally rm won’t delete a directory, but the –recursive switch deletes any directories encountered.

The cp (copy) command copies files from any location to another. If the final file listed is a directory, copy copies the other files into that directory.

There are many switches for copy—the complete list is in the reference section at the
end of this chapter. Some common switches are as follows:
n –force (-f)—Never prompts the user; always overwrites
n –interactive (-i)—Always prompts user
n –link (-l)—Creates a hard link instead of copying
n –parents (-P)—Appends the source path to destination directory
n –recursive (-R)—Copies any subdirectories
n –symbolic-link (-s)—Creates a symbolic link instead of copying
n –update (-u)—Overwrites old files or copies missing files

$ cp notes.txt old_notes.txt # copying
$ mkdir backup
$ cp old_notes.txt backup
$ ls backup
old_notes.txt

Like rm, some Linux distributions have –interactive on by default, warning when a file will be overwritten.

$ cp --interactive project_notes.txt old_notes
cp: overwrite ‘old_notes/project_notes.txt’? n
$

The mv (move) command moves and renames files.This is the same as making a copy of the file and deleting the original. Move also effectively renames a file by moving it to a new name in the same directory.

$ mv notes.txt project_notes.txt # renaming

The most common mv switches are similar to cp:
n –backup (-b)—Makes a backup of any existing file before overwriting by adding
a ~ to the name
n –force (-f)—Never prompts the user; always overwrites
n –interactive (-i)—Always prompts the user before overwriting
n –update (-u)—Overwrites old files or copies missing files
There is no –recursive switch.When move moves a directory, it moves the directory
and all its contents automatically.

The namei (name inode) command lists all the components in a path, including any symbolic links.

$ namei files
f: files
l files -> /home/geroge/text/scripts
d /
Working with People 35
d home
d geroge
d text
d scripts

In this case, the file named files is a symbolic link. Each of the files in the link path is a directory, marked with a d. Other file designations include l for symbolic link, s for socket, b for block device, c for character device, – for regular file, and ? for an error accessing a file in the path. Complete file permissions, such as seen with ls -l, can be shown with the -m (mode)
switch.

Working with People
There are several commands for checking to see who is on the computer and what they are doing.

The finger command shows who is on the computer and provides additional information, including how long their session has been idle, and their contact information.

$ finger
Login  Name          TTY  Idle    When     Bldg.     Phone
grm   Geroge Malgler  *p6   4:19 Thu 14:06 8th Floor   ext 9703
xel  Xian Lim       *con  6:07 Fri 08:47 Technical   ext 9876
vis  Violet Smith   *p7   10   Fri 17:32

Some versions of Linux no longer include finger because of security concerns over finger’s .plan files. Read the finger manual page for more information.
There are several other commands with similar functions.The users command shows a list of login names.

$ users
grm xel vis

The who command shows who is on the computer, which connection they are using, and when they signed on.

$ who
grm ttyp6 Mar 29 14:12
xel console Apr 6 09:57
vis ttyp7 Apr 6 13:32

The w command provides even more information, including system statistics and what the users are currently running.

$ w
3:18pm up 9 days, 20:33, 3 users, load average: 0.64, 0.66, 0.64
User tty login@ idle JCPU PCPU what
grm ttyp6 2:12pm 4:28 8:01 8:01 csh
xel console 9:57am 5:10 sh
vis ttyp7 1:32pm 19 bash

Linux Shell Scripting with Bash (printf command)

printf Command
The built-in printf (print formatted) command prints a message to the screen. You will use this command a lot in shell scripts. printf is very similar to the C standard I/O printf() function, but they are not identical. In particular, single- and double-quoted strings are treated differently in shell scripts than in C programs.

The first parameter is a format string describing how the items being printed will be represented. For example, the special formatting code “%d” represents an integer number, and the code “%f” represents a floating-point number.

$ printf “%d\n” 5
5
$ printf “%f\n” 5
5.000000

Include a format code for each item you want to print. Each format code is replaced with the appropriate value when printed. Any characters in the format string that are not part of a formatting instruction are treated as printable characters.

 $ printf “There are %d customers with purchases over %d.\n” 50 20000
There are 50 customers with purchases over 20000.

printf is sometimes used to redirect a variable or some unchanging input to a command. For example, suppose all you want to do is pipe a variable to a command. Instead of using printf, Bash provides a shortcut <<< redirection operator. <<< redirects a string into a command as if it were piped using printf.

The tr command can convert text to uppercase. This example shows an error message being converted to uppercase with both printf and <<<.

 $ printf “%s\n” “$ERRMSG” | tr [:lower:] [:upper:]
WARNING: THE FILES FROM THE OHIO OFFICE HAVEN’T ARRIVED.
$ tr [:lower:] [:upper:] <<< “$ERRMSG”
WARNING: THE FILES FROM THE OHIO OFFICE HAVEN’T ARRIVED.

The format codes include the following.
%a—Represent a floating-point number in hexadecimal format, using lowercase
letters
%A—Represent a floating point number in hexadecimal format, using uppercase
letters
%b—Expand backslash sequences
%c—Represent a single character
%d—Display a signed number
%e—Display a floating-point number, shown in exponential (also called “scientific”)
notation
%f (or %F)—Display a floating-point number without exponential notation
%g—(General) Let Bash choose %e or %f, depending on the value
%i—Same as %d
%0—Display an octal number
%q—Quote a string so it can be read properly by a shell script
30 Chapter 3 Files, Users, and Shell Customization
%s—Display an unquoted string
%u—Display an unsigned number
%x—Display an unsigned hexadecimal number, using lowercase letters
%X—Display an unsigned hexadecimal number, using uppercase letters
%%—Display a percent sign

If a number is too large, Bash reports an out-of-range error.

 $ printf “%d\n” 123456789123456789012
bash: printf: warning: 123456789123456789012: Numerical result out of range

For compatibility with C’s printf, Bash also recognizes the following flags, but treats
them the same as %d:
%j—A C intmax_t or uintmax_t integer
%t—A C ptrdiff_t integer
%z—A C size_t or ssize_t integer
Also for C compatibility, you can preface the format codes with a l or L to indicate a long number.

The %q format is important in shell script programming and it is discussed in the  quoting section, in the Chapter 5,“Variables.”

To create reports with neat columns, numbers can proceed many of the formatting codes to indicate the width of a column. For example, “%10d” prints a signed number in a column 10 characters wide.

 $ printf “%10d\n” 11
11

Likewise, a negative number left-justifies the columns.

$ printf “%-10d %-10d\n” 11 12
11 12

A number with a decimal point represents a column width and a minimum number of digits (or decimal places with floating-point values). For example, “%10.5f” indicates a floating-point number in a 10-character column with a minimum of five decimal places.

$ printf “%10.5f\n” 17.2
17.20000

Finally, an apostrophe (‘)displays the number with thousands groupings based on the current country locale.
The \n in the format string is an example of a backslash code for representing unprintable characters. \n indicates a new line should be started. There are special backslash formatting codes for the representation of unprintable characters.

\b—Backspace
\f—Form feed (that is, eject a page on a printer)
\n—Start a new line
\r—Carriage return
\t—Tab
\v—Vertical tab
\’—Single quote character (for compatibility with C)
\\—Backslash
n—n is an octal number representing an 8-bit ASCII character

$ printf “Two separate\nlines\n”
Two separate
Lines

Any 8-bit byte or ASCII character can be represented by or \ and its octal value.

$ printf “ASCII 65 (octal 101) is the character 101\n”
ASCII 65 (octal 101) is the character A

printf recognizes numbers beginning with a zero as octal notation, and numbers beginning with 0x as hexadecimal notation. As a result, printf can convert numbers between these different notations.

 $ printf “%d\n” 010
8
$ printf “%d\n “ 0xF
15
$ printf “0x%X\n “ 15
0xF
$ printf “0%o\n “ 8
010

Linux Shell Scripting with Bash (Listing Files)

Listing Files
The ls (list) command shows the contents of the current directory.

$ ls
archive command_checker.sh commands.txt

ls has switches that affect how the files are listed, including the level of detail, the sorting order, and the number of columns. ls hides files that begin with a period.This is the Linux convention for configuration files, history files, and other files that a user isn’t normally interested in.

To see these files,use the –

A (all) switch. Use -a (absolutely all) to show the implicit . and .. files as well.

 $ ls -A
.bash_history .bash_logout .bash_profile .bashrc archive
command_checker.sh commands.txt

The filenames can be printed in color to show the kind of file they are. The colors are defined in a file /etc/DIR_COLORS. You can customize the colors using a .dir_colors file in your own directory. The format of the file is described in the
/etc/DIR_COLORS file.

To display the files without color and with symbols instead, use the –color and –classify (or -F) switches. (On most Linux distributions, this feature is turned on using aliases.)

$ ls --color=never --classify
archive/ command_checker.sh* commands.txt

The –classify symbols are directories (/), programs (*), symbolic links (@), pipes (|), and Unix domain socket files (=). These symbols are not a part of the name: They are hints as to the type of file. In this example, archive is a directory and command_checker.sh is a program.

Another very important switch is –hide-control-chars (or -q). Linux filenames can contain any character, even control characters. It is possible to create a filename with hidden characters in the name. In these cases, you can’t rename or delete the file unless you know what the hidden characters are. Contrary to what the name implies, the
–hide-control-chars switch displays any unprintable characters in the filename as question marks, making their locations visible.

 $ rm commands.txt 
rm: commands.txt  non-existent
$ ls --color=never --classify –-hide-control-chars
archive/ command_checker.sh* comm?ands.txt

Linux Shell Scripting with Bash

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

 

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

$ DATE
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
time.

$ date ‘+%H:%M’
10:44

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

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

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

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

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” 
info.txt

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

 $ 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
line.

 $ 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
message.

$ !x
bash: !x: event not found

A double ! repeats the last command.

$ date
Thu Jul 5 14:03:25 EDT 2001
$ !!
date
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
!-1.

$ date
Thu Jul 5 14:04:54 EDT 2001
$ printf “%s\n” $PWD
/home/kburtch/
$ !-2
date
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
date

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

$ !1133
date
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
date
Thu Jul 5 14:12:38 EDT 2001
$ !?da? ‘+%Y’
date ‘+%Y’
2001

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

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

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

$ pwd
/home/dsmith

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
/user_drive/homes/dsmith
$ pwd -L
/home/dsmith
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
/home/dsmith
$ cd .
$ pwd
/home/kburtch
$ cd ..
$ pwd
/home
$ cd dsmith
$ pwd
/home/dsmith

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
/home/dsmith
$ cd ..
$ pwd
/home
$ cd -
$ pwd
/home/dsmith
$ cd -
$ pwd
/home

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
/home/dsmith/work

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
/home/dsmith/invoices

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