Linux Bash Command
Bash is both a command interpreter and a programming language. As a command interpreter, bash provides the user interface to the rich set of GNU utilities. The programming language features allow these utilities to be combined. Files containing commands can be created, and become commands themselves. These new commands have the same status as system commands in directories such as `/bin', allowing users or groups to establish custom environments to automate their common tasks.
This document briefly summarizes the bash command interpreter and programming language. It includes examples of bash sessions and scripts, the complete bash man page and excerpts from the bash info documentation.
Examples
profile, .profile, .bashrc, ...
Changing shell configuration files
Debugging - bash -xv, -n, bash -vx
Debugging on part(s) of the script
Overview of set debugging options
Escape characters
Single quotes
Double quotes
ANSI-C quoting
Locales
Shell expansion
Brace expansion
Tilde expansion
Shell parameter and variable expansion
Command substitution
Arithmetic expansion
Process substitution
Word splitting
File name expansion
Aliases Info
More Bash options
Regular expressions
Pattern matching
Conditional execution
Conditional statements
bash -eq -lt -gt
Checking command line arguments
Testing that a file exists
if/then/elif/else statements
Using case statements
Redirection and file descriptors
Redirection of errors
File descriptors - input and output
Here documents
for loop
while loop
Calculating an average
Variables
Types of variables
Global variables
Local variables
Using the declare built-in
Constants
Array variables
Examples of arrays
Functions
Command Line Interpreter or shell
The bash command line interpreter (shell) is simply a macro processor that executes commands. The term macro processor means functionality where text and symbols are expanded to create larger expressions. Bash is an acronym for `Bourne-Again SHell'. The Bourne shell is the traditional Unix shell originally written by Stephen Bourne. All of the Bourne shell builtin commands are available in Bash, The rules for evaluation and quoting are taken from the POSIX specification for the `standard' Unix shell.
Bash may be used interactively or non-interactively. In interactive mode, they accept input typed from the keyboard. When executing non-interactively, shells execute commands read from a file.
Bash allows execution of GNU commands, both synchronously and asynchronously. The shell waits for synchronous commands to complete before accepting more input; asynchronous commands continue to execute in parallel with the shell while it reads and executes additional commands. The "redirection" constructs permit fine-grained control of the input and output of those commands. Moreover, the shell allows control over the contents of commands' environments.
Bash also provides a small set of built-in commands ("builtins") implementing functionality impossible or inconvenient to obtain via separate utilities. For example, `cd', `break', `continue', and `exec') cannot be implemented outside of the shell because they directly manipulate the shell itself. The `history', `getopts', `kill', or `pwd' builtins, among others, could be implemented in separate utilities, but they are more convenient to use as builtin commands. All of the shell builtins are described in subsequent sections.
Bash offers features geared specifically for interactive use rather than to augment the programming language. These interactive features include job control, command line editing, command history and aliases. Each of these features is described in this document.
The command line interpreter(shell) is your primary interface to the computer. The function of the shell is to interpret and execute commands read from a command line string, the standard input, or a specified file. The shell is also a program and there are many versions to choose from; see csh(1), zsh(1), chsh(1). When a command is presented to the shell it checks the syntax, executes the called built-in or Linux commands and takes control when these commands complete.
The shell prints a prompt (character or string) to let the user know that the system is ready to receive input. Input is provided by the user typing in commands (requests to do something) followed by a carriage return.
A command is a sequence of words and potentially options, separated by blanks and/or redirections and terminated by a control operator. The first word of the command string is the name of the program/command to execute. The shell searches for a program matching that name in the "path" that is defined for the shell. The first instance of a command matching the command name is executed. The options/arguments if there are any are passed to the command at execution time. The return value of the command is its exit status.
Executing commands
Bash determines the type of program that is to be executed. Normal programs are system commands that exist in compiled form on your system. When such a program is executed, a new process is created because Bash makes an exact copy of itself. This child process has the same environment as its parent, only the process ID number is different. This procedure is called forking.
After the forking process, the address space of the child process is overwritten with the new process data. This is done through an exec call to the system.
The fork-and-exec mechanism thus switches an old command with a new, while the environment in which the new program is executed remains the same, including configuration of input and output devices, environment variables and priority. This mechanism is used to create all UNIX processes, so it also applies to the Linux operating system. Even the first process, init, with process ID 1, is forked during the boot procedure in the so-called bootstrapping procedure.
Simple interactive shell commands
% cd % pwd /u/adam % echo hello hello % touch newfile % ls -l newfile -rw-r--r-- 1 adam users 0 Jun 15 23:12 newfile
Simple shell commands such as "cd, pwd, echo, touch and ls" consist of the commands themselves followed by arguments, separated by spaces (as shown above).
In the example above, the commands issued have the following effects:
- cd - change the users current directory to the home directory as defined by their account profile
- pwd - report the value of the present working directory
- touch - update file time stamp - create file if it does not exist
- ls -l - list directory/file information in long format
Core Concepts
Linux commands and bash scripts share a standard input/output model (stdin/stdout ) and interact with the command line interpreter (bash,tcsh,etc) in a standard way. In order to understand and leverage Linux/Unix commands, a basic understanding of i/o, pipes, command line interpretation, signals, redirection and the shell(s) are useful. These concepts and others are described in the following examples.
pipes and redirection example
% find /usr/bin -name "m*" -print | less % find /usr/bin -name "m*" -print > mlist
More complex shell commands are composed of simple commands arranged together in a variety of ways: in a pipeline in which the output of one command becomes the input of a second, in a loop or conditional construct, or in some other grouping.
In the examples above the find is used to search the "/usr/bin" directory for files that start with the letter "m" and print their names on the output.
In the first example the output of find is directed to the "less" program using a pipe ("|"). The pipe make the output of the find command the input of less which allows the user to page forward and backward through the list of commands.
In the second example the output of find is directed to a file by using a redirect (">"). The redirect causes the output of find to be sent to the file mlist.
bash script
Bash can take it's input from a file. When the program being executed is a shell script, bash will create a new bash process using a fork. This subshell reads the lines from the shell script one line at a time. Commands on each line are read, interpreted and executed as if they would have come directly from the keyboard.
While the subshell processes each line of the script, the parent shell waits for its child process to finish. When there are no more lines in the shell script to read, the subshell terminates. The parent shell awakes and displays a new prompt.
The following is an example of a bash script that prints information about the system that it is run on.
adam@moon:~> cat -n mysys.sh
1 #!/bin/bash
2
3 clear
4 echo "Running mysys.sh"
5
6 echo "Hello, $USER"
7 echo
8
9 echo "Today's date is `date`, this is week `date +"%V"`."
10 echo
11
12 echo "Unique users currently connected:"
13 w | cut -d " " -f 1 - | grep -v USER | sort -u
14 echo
15
16 echo "Kernel is `uname -s` running on a `uname -m` processor."
17 echo
18
19 echo "System uptime information:"
20 uptime
21 echo
22
23 echo "Script complete!"
adam@moon:~>
The script mysys.sh can be executed by calling bash followed by the name of the script as in "% bash mysys.sh" or by calling the name of the script directly from the bash prompt as in "% ./mysys.sh". To run the script directly from the prompt the mysys.sh must have execute permissions set.
Interactive shell
An interactive shell generally reads from, and writes to, a user's terminal: input and output are connected to a terminal. Bash interactive behavior is started when the bash command is called upon without non-option arguments, except when the option is a string to read from or when the shell is invoked to read from standard input, which allows for positional parameters to be set.
Is this shell interactive?
Test by looking at the content of the special parameter -, it contains an 'i' when the shell is interactive:
eddy:~> echo $- himBH
In non-interactive shells, the prompt, PS1, is unset.
Interactive shell behavior
Differences in interactive mode:
-
Bash reads startup files.
-
Job control enabled by default.
-
Prompts are set, PS2 is enabled for multi-line commands, it is usually set to ">". This is also the prompt you get when the shell thinks you entered an unfinished command, for instance when you forget quotes, command structures that cannot be left out, etc.
-
Commands are by default read from the command line using readline.
-
Bash interprets the shell option ignoreeof instead of exiting immediately upon receiving EOF (End Of File).
-
Command history and history expansion are enabled by default. History is saved in the file pointed to by HISTFILE when the shell exits. By default, HISTFILE points to ~/.bash_history.
-
Alias expansion is enabled.
-
In the absence of traps, the SIGTERM signal is ignored.
-
In the absence of traps, SIGINT is caught and handled. Thus, typing Ctrl+C, for example, will not quit your interactive shell.
-
Sending SIGHUP signals to all jobs on exit is configured with the huponexit option.
-
Commands are executed upon read.
-
Bash checks for mail periodically.
-
Bash can be configured to exit when it encounters unreferenced variables. In interactive mode this behavior is disabled.
-
When shell built-in commands encounter redirection errors, this will not cause the shell to exit.
-
Special built-ins returning errors when used in POSIX mode don't cause the shell to exit.
-
Failure of exec will not exit the shell.
-
Parser syntax errors don't cause the shell to exit.
-
Simple spell check for the arguments to the cd built-in is enabled by default.
-
Automatic exit after the length of time specified in the TMOUT variable has passed, is enabled.
Shell functions
Shell functions are a way to group commands for later execution using a single name for the group. They are executed just like a "regular" command. When the name of a shell function is used as a simple command name, the list of commands associated with that function name is executed.
Shell functions are executed in the current shell context; no new process is created to interpret them.
Shell parameters
A parameter is an entity that stores values. It can be a name, a number or a special value. For the shell's purpose, a variable is a parameter that stores a name. A variable has a value and zero or more attributes. Variables are created with the declare shell built-in command.
If no value is given, a variable is assigned the null string. Variables can only be removed with the unset built-in.
Shell arithmetic
The shell allows arithmetic expressions to be evaluated, as one of the shell expansions or by the let built-in.
Evaluation is done in fixed-width integers with no check for overflow, though division by 0 is trapped and flagged as an error. The operators and their precedence and associativity are the same as in the C language.
Aliases
Aliases allow a string to be substituted for a word when it is used as the first word of a simple command. The shell maintains a list of aliases that may be set and unset with the alias and unalias commands.
Bash always reads at least one complete line of input before executing any of the commands on that line. Aliases are expanded when a command is read, not when it is executed. Therefore, an alias definition appearing on the same line as another command does not take effect until the next line of input is read. The commands following the alias definition on that line are not affected by the new alias.
Aliases are expanded when a function definition is read, not when the function is executed, because a function definition is itself a compound command. As a consequence, aliases defined in a function are not available until after that function is executed.
Arrays
Bash provides one-dimensional array variables. Any variable may be used as an array; the declare built-in will explicitly declare an array. There is no maximum limit on the size of an array, nor any requirement that members be indexed or assigned contiguously. Arrays are zero-based.
Directory stack
The directory stack is a list of recently-visited directories. The pushd built-in adds directories to the stack as it changes the current directory, and the popd built-in removes specified directories from the stack and changes the current directory to the directory removed.
Content can be displayed issuing the dirs command or by checking the content of the DIRSTACK variable.
More information about the workings of this mechanism can be found in the Bash info pages.
Shell functions
Shell functions are a way to group commands for later execution using a single name for the group. They are executed just like a "regular" command. When the name of a shell function is used as a simple command name, the list of commands associated with that function name is executed.
Shell functions are executed in the current shell context; no new process is created to interpret them.
Shell parameters
A parameter is an entity that stores values. It can be a name, a number or a special value. For the shell's purpose, a variable is a parameter that stores a name. A variable has a value and zero or more attributes. Variables are created with the declare shell built-in command.
If no value is given, a variable is assigned the null string. Variables can only be removed with the unset built-in.
Debugging scripts - bash -x
When things don't go according to plan, you need to determine what exactly causes the script to fail. Bash provides extensive debugging features. The most common is to start up the subshell with the -x option, which will run the entire script in debug mode. Traces of each command plus its arguments are printed to standard output after the commands have been expanded but before they are executed.
This is the commented-script1.sh script ran in debug mode. Note again that the added comments are not visible in the output of the script.
willy:~/scripts> bash -x script1.sh + clear + echo 'The script starts now.' The script starts now. + echo 'Hi, willy!' Hi, willy! + echo + echo 'I will now fetch you a list of connected users:' I will now fetch you a list of connected users: + echo + w 4:50pm up 18 days, 6:49, 4 users, load average: 0.58, 0.62, 0.40 USER TTY FROM LOGIN@ IDLE JCPU PCPU WHAT root tty2 - Sat 2pm 5:36m 0.24s 0.05s -bash willy :0 - Sat 2pm ? 0.00s ? - willy pts/3 - Sat 2pm 43:13 36.82s 36.82s BitchX willy ir willy pts/2 - Sat 2pm 43:13 0.13s 0.06s /usr/bin/screen + echo + echo 'I'\''m setting two variables now.' I'm setting two variables now. + COLOUR=black + VALUE=9 + echo 'This is a string: ' This is a string: + echo 'And this is a number: ' And this is a number: + echo + echo 'I'\''m giving you back your prompt now.' I'm giving you back your prompt now. + echo
There is now a full-fledged debugger for Bash, available at SourceForge. These debugging features are available in most modern versions of Bash, starting from 3.x.
Debugging on part(s) of the script
Using the set Bash built-in you can run in normal mode those portions of the script of which you are sure they are without fault, and display debugging information only for troublesome zones. Say we are not sure what the w command will do in the example commented-script1.sh, then we could enclose it in the script like this:
set -x # activate debugging from here w set +x # stop debugging from hereOutput then looks like this:
willy: ~/scripts> script1.sh The script starts now. Hi, willy! I will now fetch you a list of connected users: + w 5:00pm up 18 days, 7:00, 4 users, load average: 0.79, 0.39, 0.33 USER TTY FROM LOGIN@ IDLE JCPU PCPU WHAT root tty2 - Sat 2pm 5:47m 0.24s 0.05s -bash willy :0 - Sat 2pm ? 0.00s ? - willy pts/3 - Sat 2pm 54:02 36.88s 36.88s BitchX willyke willy pts/2 - Sat 2pm 54:02 0.13s 0.06s /usr/bin/screen + set +x I'm setting two variables now. This is a string: And this is a number: I'm giving you back your prompt now. willy: ~/scripts>
You can switch debugging mode on and off as many times as you want within the same script.
The table below gives an overview of other useful Bash options:
Overview of set debugging options
| Short notation | Long notation | Result |
|---|---|---|
| set -f | set -o noglob | Disable file name generation using metacharacters (globbing). |
| set -v | set -o verbose | Prints shell input lines as they are read. |
| set -x | set -o xtrace | Print command traces before executing command. |
The dash is used to activate a shell option and a plus to deactivate it. Don't let this confuse you!
In the example below, we demonstrate these options on the command line:
willy:~/scripts> set -v willy:~/scripts> ls ls commented-scripts.sh script1.sh willy:~/scripts> set +v set +v willy:~/scripts> ls * commented-scripts.sh script1.sh willy:~/scripts> set -f willy:~/scripts> ls * ls: *: No such file or directory willy:~/scripts> touch * willy:~/scripts> ls * commented-scripts.sh script1.sh willy:~/scripts> rm * willy:~/scripts> ls commented-scripts.sh script1.sh
Alternatively, these modes can be specified in the script itself, by adding the desired options to the first line shell declaration. Options can be combined, as is usually the case with UNIX commands:
#!/bin/bash -xvOnce you found the buggy part of your script, you can add echo statements before each command of which you are unsure, so that you will see exactly where and why things don't work. In the example commented-script1.sh script, it could be done like this, still assuming that the displaying of users gives us problems:
echo "debug message: now attempting to start w command"; w
In more advanced scripts, the echo can be inserted to display the content of variables at different stages in the script, so that flaws can be detected:
echo "Variable VARNAME is now set to $VARNAME."
bash -n command
Running bash with the -n option instructs bash to read the script command and report syntax errors. The following example shows a script with an error and the output generated by the commands "bash -n command" and "bash -vn command".
adam@moon:~> cat command #!/bin/bash for i in /bin/a* do ls -l $i ; done adam@moon:~> bash -n command command: line 3: syntax error near unexpected token `done' command: line 3: `for i in /bin/a* do ls -l $i ; done' adam@moon:~> bash -vn command #!/bin/bash for i in /bin/a* do ls -l $i ; done' command: line 3: unexpected EOF while looking for matching `'' command: line 5: syntax error: unexpected end of file
bash -vx command
bash -v instructs bash to display each line in the script before performing file, variable or command substition.
bash -x instructs bash to display each line in the script after performing file, variable or command substition but before execution.
bash -xv instructs bash to display each line before and after performing file, variable or command substition but before execution.
adam@moon:~> cat -n command
1 #!/bin/bash
2
3 ((count = 0))
4 for i in /bin/a*; do ((count++)); ls $i ; done
5 echo $count files start with the letter "a"
adam@moon:~> bash -n command
adam@moon:~> bash -v command
#!/bin/bash
((count = 0))
for i in /bin/a*; do ((count++)); ls $i ; done
/bin/arch
/bin/awk
echo $count files start with the letter "a"
2 files start with the letter a
adam@moon:~> bash -x command
+ (( count = 0 ))
+ for i in '/bin/a*'
+ (( count++ ))
+ ls /bin/arch
/bin/arch
+ for i in '/bin/a*'
+ (( count++ ))
+ ls /bin/awk
/bin/awk
+ echo 2 files start with the letter a
2 files start with the letter a
adam@moon:~> bash -vx command
#!/bin/bash
((count = 0))
+ (( count = 0 ))
for i in /bin/a*; do ((count++)); ls $i ; done
+ for i in '/bin/a*'
+ (( count++ ))
+ ls /bin/arch
/bin/arch
+ for i in '/bin/a*'
+ (( count++ ))
+ ls /bin/awk
/bin/awk
echo $count files start with the letter "a"
+ echo 2 files start with the letter a
2 files start with the letter a
adam@moon:~> bash -xv command
#!/bin/bash
((count = 0))
+ (( count = 0 ))
for i in /bin/a*; do ((count++)); ls $i ; done
+ for i in '/bin/a*'
+ (( count++ ))
+ ls /bin/arch
/bin/arch
+ for i in '/bin/a*'
+ (( count++ ))
+ ls /bin/awk
/bin/awk
echo $count files start with the letter "a"
+ echo 2 files start with the letter a
2 files start with the letter a
adam@moon:~>
Shell configuration files
/etc/profile/etc/bashrc
~/.bash_login
~/.profile
~/.bashrc
~/.bash_logout
/etc/profile
When invoked interactively with the --login option or when invoked as sh, Bash reads the /etc/profile instructions. These usually set the shell variables PATH, USER, MAIL, HOSTNAME and HISTSIZE.
On some systems, the umask value is configured in /etc/profile; on other systems this file holds pointers to other configuration files such as:
-
/etc/inputrc, the system-wide Readline initialization file where you can configure the command line bell-style.
-
the /etc/profile.d directory, which contains files configuring system-wide behavior of specific programs.
All settings that you want to apply to all your users' environments should be in this file. It might look like this:
# /etc/profile
# System wide environment and startup programs, for login setup
PATH=$PATH:/usr/X11R6/bin
# No core files by default
ulimit -S -c 0 > /dev/null 2>&1
USER="`id -un`"
LOGNAME=$USER
MAIL="/var/spool/mail/$USER"
HOSTNAME=`/bin/hostname`
HISTSIZE=1000
# Keyboard, bell, display style: the readline config file:
if [ -z "$INPUTRC" -a ! -f "$HOME/.inputrc" ]; then
INPUTRC=/etc/inputrc
fi
PS1="\u@\h \W"
export PATH USER LOGNAME MAIL HOSTNAME HISTSIZE INPUTRC PS1
# Source initialization files for specific programs (ls, vim, less, ...)
for i in /etc/profile.d/*.sh ; do
if [ -r "$i" ]; then
. $i
fi
done
# Settings for program initialization
source /etc/java.conf
export NPX_PLUGIN_PATH="$JRE_HOME/plugin/ns4plugin/:/usr/lib/netscape/plugins"
PAGER="/usr/bin/less"
unset i
This configuration file sets some basic shell environment variables as well as some variables required by users running Java and/or Java applications in their web browser.
The Bash source contains sample profile files for general or individual use. These and the one in the example above need changes in order for them to work in your environment!
/etc/bashrc
On systems offering multiple types of shells, it might be better to put Bash-specific configurations in this file, since /etc/profile is also read by other shells, such as the Bourne shell. Errors generated by shells that don't understand the Bash syntax are prevented by splitting the configuration files for the different types of shells. In such cases, the user's ~/.bashrc might point to /etc/bashrc in order to include it in the shell initialization process upon login.
You might also find that /etc/profile on your system only holds shell environment and program startup settings, while /etc/bashrc contains system-wide definitions for shell functions and aliases. The /etc/bashrc file might be referred to in /etc/profile or in individual user shell initialization files.
The source contains sample bashrc files, or you might find a copy in /usr/share/doc/bash-2.05b/startup-files. This is part of the bashrc that comes with the Bash documentation:
alias ll='ls -l'
alias dir='ls -ba'
alias c='clear'
alias ls='ls --color'
alias mroe='more'
alias pdw='pwd'
alias sl='ls --color'
pskill()
{
local pid
pid=$(ps -ax | grep $1 | grep -v grep | gawk '{ print $1 }')
echo -n "killing $1 (process $pid)..."
kill -9 $pid
echo "slaughtered."
}
Apart from general aliases, it contains useful aliases which make commands work even if you misspell them.
~/.bash_profile
This is the preferred configuration file for configuring user environments individually. This file might not have been created in your home directory by default; You can create it if needed. In this file, users can add extra configuration options or change default settings:
franky~> cat .bash_profile
#################################################################
# #
# .bash_profile file #
# #
# Executed from the bash shell when you log in. #
# #
#################################################################
source ~/.bashrc
source ~/.bash_login
case "$OS" in
IRIX)
stty sane dec
stty erase
;;
# SunOS)
# stty erase
# ;;
*)
stty sane
;;
esac
This user configures the backspace character for login on different operating systems. Apart from that, the user's .bashrc and .bash_login are read.
~/.bash_login
This file contains specific settings that are normally only executed when you log in to the system. In the example, we use it to configure the umask value and to show a list of connected users upon login. This user also gets the calendar for the current month:
####################################################################### # # # Bash_login file # # # # commands to perform from the bash shell at login time # # (sourced from .bash_profile) # # # ####################################################################### # file protection umask 002 # all to me, read to group and others # miscellaneous w cal `date +"%m"` `date +"%Y"`
In the absence of ~/.bash_profile, this file will be read.
~/.profile
In the absence of ~/.bash_profile and ~/.bash_login, ~/.profile is read. It can hold the same configurations, which are then also accessible by other shells. Mind that other shells might not understand the Bash syntax.
~/.bashrc
Today, it is more common to use a non-login shell, for instance when logged in graphically using X terminal windows. Upon opening such a window, the user does not have to provide a user name or password; no authentication is done. Bash searches for ~/.bashrc when this happens, so it is referred to in the files read upon login as well, which means you don't have to enter the same settings in multiple files.
In this user's .bashrc a couple of aliases are defined and variables for specific programs are set after the system-wide /etc/bashrc is read:
franky ~> cat .bashrc
# /home/franky/.bashrc
# Source global definitions
if [ -f /etc/bashrc ]; then
. /etc/bashrc
fi
# shell options
set -o noclobber
# my shell variables
export PS1="\[\033[1;44m\]\u \w\[\033[0m\] "
export PATH="$PATH:~/bin:~/scripts"
# my aliases
alias cdrecord='cdrecord -dev 0,0,0 -speed=8'
alias ss='ssh octarine'
alias ll='ls -la'
# mozilla fix
MOZILLA_FIVE_HOME=/usr/lib/mozilla
LD_LIBRARY_PATH=/usr/lib/mozilla:/usr/lib/mozilla/plugins
MOZ_DIST_BIN=/usr/lib/mozilla
MOZ_PROGRAM=/usr/lib/mozilla/mozilla-bin
export MOZILLA_FIVE_HOME LD_LIBRARY_PATH MOZ_DIST_BIN MOZ_PROGRAM
# font fix
alias xt='xterm -bg black -fg white &'
# BitchX settings
export IRCNAME="frnk"
# THE END
franky ~>
More examples can be found in the Bash package. Remember that sample files might need changes in order to work in your environment.
~/.bash_logout
This file contains specific instructions for the logout procedure. In the example, the terminal window is cleared upon logout. This is useful for remote connections, which will leave a clean window after closing them.
franky ~> cat .bash_logout ####################################################################### # # # Bash_logout file # # # # commands to perform from the bash shell at logout time # # # ####################################################################### clear franky ~>
Changing shell configuration files
When making changes to any of the above files, users have to either reconnect to the system or source the altered file for the changes to take effect. By interpreting the script this way, changes are applied to the current shell session:
Most shell scripts execute in a private environment: variables are not inherited by child processes unless they are exported by the parent shell. Sourcing a file containing shell commands is a way of applying changes to your own environment and setting variables in the current shell.
This example also demonstrates the use of different prompt settings by different users. In this case, red means danger. When you have a green prompt, don't worry too much.
Note that source resourcefile is the same as . resourcefile.
Should you get lost in all these configuration files, and find yourself confronted with settings of which the origin is not clear, use echo statements, just like for debugging scripts.
echo "Now executing .bash_profile.."
or like this:
echo "Now setting PS1 in .bashrc:" export PS1="[some value]" echo "PS1 is now set to $PS1"
Escape characters
Escape characters are used to remove the special meaning from a single character. A non-quoted backslash, \, is used as an escape character in Bash. It preserves the literal value of the next character that follows, with the exception of newline. If a newline character appears immediately after the backslash, it marks the continuation of a line when it is longer that the width of the terminal; the backslash is removed from the input stream and effectively ignored.
franky ~> date=20021226 franky ~> echo $date 20021226 franky ~> echo \$date $date
In this example, the variable date is created and set to hold a value. The first echo displays the value of the variable, but for the second, the dollar sign is escaped.
Single quotes
Single quotes ('') are used to preserve the literal value of each character enclosed within the quotes. A single quote may not occur between single quotes, even when preceded by a backslash.
We continue with the previous example:
franky ~> echo '$date' $date
Double quotes
Using double quotes the literal value of all characters enclosed is preserved, except for the dollar sign, the backticks (backward single quotes, ``) and the backslash.
The dollar sign and the backticks retain their special meaning within the double quotes.
The backslash retains its meaning only when followed by dollar, backtick, double quote, backslash or newline. Within double quotes, the backslashes are removed from the input stream when followed by one of these characters. Backslashes preceding characters that don't have a special meaning are left unmodified for processing by the shell interpreter.
A double quote may be quoted within double quotes by preceding it with a backslash.
franky ~> echo "$date" 20021226 franky ~> echo "`date`" Sun Apr 20 11:22:06 CEST 2003 franky ~> echo "I'd say: \"Go for it!\"" I'd say: "Go for it!" franky ~> echo "\" More input>" franky ~> echo \"\\"
ANSI-C quoting
Words in the form "$'STRING'" are treated in a special way. The word expands to a string, with backslash-escaped characters replaced as specified by the ANSI-C standard. Backslash escape sequences can be found in the Bash documentation.
Locales
A double-quoted string preceded by a dollar sign will cause the string to be translated according to the current locale. If the current locale is "C" or "POSIX", the dollar sign is ignored. If the string is translated and replaced, the replacement is double-quoted.
Shell expansion
After the command has been split into tokens, these tokens or words are expanded or resolved. There are eight kinds of expansion performed, which we will discuss in the next sections, in the order that they are expanded.
After all expansions, quote removal is performed.
Brace expansion
Brace expansion is a mechanism by which arbitrary strings may be generated. Patterns to be brace-expanded take the form of an optional PREAMBLE, followed by a series of comma-separated strings between a pair of braces, followed by an optional POSTSCRIPT. The preamble is prefixed to each string contained within the braces, and the postscript is then appended to each resulting string, expanding left to right.
Brace expansions may be nested. The results of each expanded string are not sorted; left to right order is preserved:
franky ~> echo sp{el,il,al}l
spell spill spall
Brace expansion is performed before any other expansions, and any characters special to other expansions are preserved in the result. It is strictly textual. Bash does not apply any syntactic interpretation to the context of the expansion or the text between the braces. To avoid conflicts with parameter expansion, the string "${" is not considered eligible for brace expansion.
A correctly-formed brace expansion must contain unquoted opening and closing braces, and at least one unquoted comma. Any incorrectly formed brace expansion is left unchanged.
Tilde expansion
If a word begins with an unquoted tilde character ("~"), all of the characters up to the first unquoted slash (or all characters, if there is no unquoted slash) are considered a tilde-prefix. If none of the characters in the tilde-prefix are quoted, the characters in the tilde-prefix following the tilde are treated as a possible login name. If this login name is the null string, the tilde is replaced with the value of the HOME shell variable. If HOME is unset, the home directory of the user executing the shell is substituted instead. Otherwise, the tilde-prefix is replaced with the home directory associated with the specified login name.
If the tilde-prefix is "~+", the value of the shell variable PWD replaces the tilde-prefix. If the tilde-prefix is "~-", the value of the shell variable OLDPWD, if it is set, is substituted.
If the characters following the tilde in the tilde-prefix consist of a number N, optionally prefixed by a "+" or a "-", the tilde-prefix is replaced with the corresponding element from the directory stack, as it would be displayed by the dirs built-in invoked with the characters following tilde in the tilde-prefix as an argument. If the tilde-prefix, without the tilde, consists of a number without a leading "+" or "-", "+" is assumed.
If the login name is invalid, or the tilde expansion fails, the word is left unchanged.
Each variable assignment is checked for unquoted tilde-prefixes immediately following a ":" or "=". In these cases, tilde expansion is also performed. Consequently, one may use file names with tildes in assignments to PATH, MAILPATH, and CDPATH, and the shell assigns the expanded value.
Example:
franky ~> export PATH="$PATH:~/testdir"
~/testdir will be expanded to $HOME/testdir, so if $HOME is /var/home/franky, the directory /var/home/franky/testdir will be added to the content of the PATH variable.
Shell parameter and variable expansion
The "$" character introduces parameter expansion, command substitution, or arithmetic expansion. The parameter name or symbol to be expanded may be enclosed in braces, which are optional but serve to protect the variable to be expanded from characters immediately following it which could be interpreted as part of the name.
When braces are used, the matching ending brace is the first "}" not escaped by a backslash or within a quoted string, and not within an embedded arithmetic expansion, command substitution, or parameter expansion.
The basic form of parameter expansion is "${PARAMETER}". The value of "PARAMETER" is substituted. The braces are required when "PARAMETER" is a positional parameter with more than one digit, or when "PARAMETER" is followed by a character that is not to be interpreted as part of its name.
If the first character of "PARAMETER" is an exclamation point, Bash uses the value of the variable formed from the rest of "PARAMETER" as the name of the variable; this variable is then expanded and that value is used in the rest of the substitution, rather than the value of "PARAMETER" itself. This is known as indirect expansion.
You are certainly familiar with straight parameter expansion, since it happens all the time, even in the simplest of cases, such as the one above or the following:
franky ~> echo $SHELL /bin/bash
The following is an example of indirect expansion:
franky ~> echo ${!N*}
NNTPPORT NNTPSERVER NPX_PLUGIN_PATH
Note that this is not the same as echo $N*.
The following construct allows for creation of the named variable if it does not yet exist:
${VAR:=value}
Example:
franky ~> echo $FRANKY
franky ~> echo ${FRANKY:=Franky}
Franky
Special parameters, among others the positional parameters, may not be assigned this way, however.
More information on the use of the curly braces for can be found in the Bash info pages.
Command substitution
Command substitution allows the output of a command to replace the command itself. Command substitution occurs when a command is enclosed like this:
$(command)
or like this using backticks:
`command`
Bash performs the expansion by executing COMMAND and replacing the command substitution with the standard output of the command, with any trailing newlines deleted. Embedded newlines are not deleted, but they may be removed during word splitting.
franky ~> echo `date` Thu Feb 6 10:06:20 CET 2003
When the old-style backquoted form of substitution is used, backslash retains its literal meaning except when followed by "$", "`", or "\". The first backticks not preceded by a backslash terminates the command substitution. When using the "$(COMMAND)" form, all characters between the parentheses make up the command; none are treated specially.
Command substitutions may be nested. To nest when using the backquoted form, escape the inner backticks with backslashes.
If the substitution appears within double quotes, word splitting and file name expansion are not performed on the results.
Arithmetic expansion
Arithmetic expansion allows the evaluation of an arithmetic expression and the substitution of the result. The format for arithmetic expansion is:
$(( EXPRESSION ))
The expression is treated as if it were within double quotes, but a double quote inside the parentheses is not treated specially. All tokens in the expression undergo parameter expansion, command substitution, and quote removal. Arithmetic substitutions may be nested.
Evaluation of arithmetic expressions is done in fixed-width integers with no check for overflow - although division by zero is trapped and recognized as an error. The operators are roughly the same as in the C programming language. In order of decreasing precedence, the list looks like this:
Arithmetic operators
| Operator | Meaning |
|---|---|
| VAR++ and VAR-- | variable post-increment and post-decrement |
| ++VAR and --VAR | variable pre-increment and pre-decrement |
| - and + | unary minus and plus |
| ! and ~ | logical and bitwise negation |
| ** | exponentiation |
| *, / and % | multiplication, division, remainder |
| + and - | addition, subtraction |
| << and >> | left and right bitwise shifts |
| <=, >=, < and > | comparison operators |
| == and != | equality and inequality |
| & | bitwise AND |
| ^ | bitwise exclusive OR |
| | | bitwise OR |
| && | logical AND |
| || | logical OR |
| expr ? expr : expr | conditional evaluation |
| =, *=, /=, %=, +=, -=, <<=, >>=, &=, ^= and |= | assignments |
| , | separator between expressions |
Shell variables are allowed as operands; parameter expansion is performed before the expression is evaluated. Within an expression, shell variables may also be referenced by name without using the parameter expansion syntax. The value of a variable is evaluated as an arithmetic expression when it is referenced. A shell variable need not have its integer attribute turned on to be used in an expression.
Constants with a leading 0 (zero) are interpreted as octal numbers. A leading "0x" or "0X" denotes hexadecimal. Otherwise, numbers take the form "[BASE'#']N", where "BASE" is a decimal number between 2 and 64 representing the arithmetic base, and N is a number in that base. If "BASE'#'" is omitted, then base 10 is used. The digits greater than 9 are represented by the lowercase letters, the uppercase letters, "@", and "_", in that order. If "BASE" is less than or equal to 36, lowercase and uppercase letters may be used interchangably to represent numbers between 10 and 35.
Operators are evaluated in order of precedence. Sub-expressions in parentheses are evaluated first and may override the precedence rules above.
Wherever possible, Bash users should try to use the syntax with square brackets:
$[ EXPRESSION ]
However, this will only calculate the result of EXPRESSION, and do no tests:
franky ~> echo $[365*24] 8760
Process substitution
Process substitution is supported on systems that support named pipes (FIFOs) or the /dev/fd method of naming open files. It takes the form of
<(LIST)
or
>(LIST)
The process LIST is run with its input or output connected to a FIFO or some file in /dev/fd. The name of this file is passed as an argument to the current command as the result of the expansion. If the ">(LIST)" form is used, writing to the file will provide input for LIST. If the "<(LIST)" form is used, the file passed as an argument should be read to obtain the output of LIST. Note that no space may appear between the < or > signs and the left parenthesis, otherwise the construct would be interpreted as a redirection.
When available, process substitution is performed simultaneously with parameter and variable expansion, command substitution, and arithmetic expansion.
Word splitting
The shell scans the results of parameter expansion, command substitution, and arithmetic expansion that did not occur within double quotes for word splitting.
The shell treats each character of $IFS as a delimiter, and splits the results of the other expansions into words on these characters. If IFS is unset, or its value is exactly "'<space><tab><newline>'", the default, then any sequence of IFS characters serves to delimit words. If IFS has a value other than the default, then sequences of the whitespace characters "space" and "Tab" are ignored at the beginning and end of the word, as long as the whitespace character is in the value of IFS (an IFS whitespace character). Any character in IFS that is not IFS whitespace, along with any adjacent IF whitespace characters, delimits a field. A sequence of IFS whitespace characters is also treated as a delimiter. If the value of IFS is null, no word splitting occurs.
Explicit null arguments ("""" or "''") are retained. Unquoted implicit null arguments, resulting from the expansion of parameters that have no values, are removed. If a parameter with no value is expanded within double quotes, a null argument results and is retained.
Expansion and word splitting
If no expansion occurs, no splitting is performed.
File name expansion
After word splitting, unless the -f option has been set, Bash scans each word for the characters "*", "?", and "[". If one of these characters appears, then the word is regarded as a PATTERN, and replaced with an alphabetically sorted list of file names matching the pattern. If no matching file names are found, and the shell option nullglob is disabled, the word is left unchanged. If the nullglob option is set, and no matches are found, the word is removed. If the shell option nocaseglob is enabled, the match is performed without regard to the case of alphabetic characters.
When a pattern is used for file name generation, the character "." at the start of a file name or immediately following a slash must be matched explicitly, unless the shell option dotglob is set. When matching a file name, the slash character must always be matched explicitly. In other cases, the "." character is not treated specially.
The GLOBIGNORE shell variable may be used to restrict the set of file names matching a pattern. If GLOBIGNORE is set, each matching file name that also matches one of the patterns in GLOBIGNORE is removed from the list of matches. The file names . and .. are always ignored, even when GLOBIGNORE is set. However, setting GLOBIGNORE has the effect of enabling the dotglob shell option, so all other file names beginning with a "." will match. To get the old behavior of ignoring file names beginning with a ".", make ".*" one of the patterns in GLOBIGNORE. The dotglob option is disabled when GLOBIGNORE is unset.
Aliases Info
An alias allows a string to be substituted for a word when it is used as the first word of a simple command. The shell maintains a list of aliases that may be set and unset with the alias and unalias built-in commands. Issue the alias without options to display a list of aliases known to the current shell.
franky: ~> alias alias ..='cd ..' alias ...='cd ../..' alias ....='cd ../../..' alias PAGER='less -r' alias Txterm='export TERM=xterm' alias XARGS='xargs -r' alias cdrecord='cdrecord -dev 0,0,0 -speed=8' alias e='vi' alias egrep='grep -E' alias ewformat='fdformat -n /dev/fd0u1743; ewfsck' alias fgrep='grep -F' alias ftp='ncftp -d15' alias h='history 10' alias fformat='fdformat /dev/fd0H1440' alias j='jobs -l' alias ksane='setterm -reset' alias ls='ls -F --color=auto' alias m='less' alias md='mkdir' alias od='od -Ax -ta -txC' alias p='pstree -p' alias ping='ping -vc1' alias sb='ssh blubber' alias sl='ls' alias ss='ssh octarine' alias tar='gtar' alias tmp='cd /tmp' alias unaliasall='unalias -a' alias vi='eval `resize`;vi' alias vt100='export TERM=vt100' alias which='type' alias xt='xterm -bg black -fg white &' franky ~>
Aliases are useful for specifying the default version of a command that exists in several versions on your system, or to specify default options to a command. Another use for aliases is for correcting incorrect spelling.
The first word of each simple command, if unquoted, is checked to see if it has an alias. If so, that word is replaced by the text of the alias. The alias name and the replacement text may contain any valid shell input, including shell metacharacters, with the exception that the alias name may not contain "=". The first word of the replacement text is tested for aliases, but a word that is identical to an alias being expanded is not expanded a second time. This means that one may alias ls to ls -F, for instance, and Bash will not try to recursively expand the replacement text. If the last character of the alias value is a space or tab character, then the next command word following the alias is also checked for alias expansion.
Aliases are not expanded when the shell is not interactive, unless the expand_aliases option is set using the shopt shell built-in.
Creating and removing aliases
Aliases are created using the alias shell built-in. For permanent use, enter the alias in one of your shell initialization files; if you just enter the alias on the command line, it is only recognized within the current shell.
franky ~> alias dh='df -h' franky ~> dh Filesystem Size Used Avail Use% Mounted on /dev/hda7 1.3G 272M 1018M 22% / /dev/hda1 121M 9.4M 105M 9% /boot /dev/hda2 13G 8.7G 3.7G 70% /home /dev/hda3 13G 5.3G 7.1G 43% /opt none 243M 0 243M 0% /dev/shm /dev/hda6 3.9G 3.2G 572M 85% /usr /dev/hda5 5.2G 4.3G 725M 86% /var franky ~> unalias dh franky ~> dh bash: dh: command not found franky ~>
Bash always reads at least one complete line of input before executing any of the commands on that line. Aliases are expanded when a command is read, not when it is executed. Therefore, an alias definition appearing on the same line as another command does not take effect until the next line of input is read. The commands following the alias definition on that line are not affected by the new alias. This behavior is also an issue when functions are executed. Aliases are expanded when a function definition is read, not when the function is executed, because a function definition is itself a compound command. As a consequence, aliases defined in a function are not available until after that function is executed. To be safe, always put alias definitions on a separate line, and do not use alias in compound commands.
Aliases are not inherited by child processes. Bourne shell (sh) does not recognize aliases.
Functions are faster
Aliases are looked up after functions and thus resolving is slower. While aliases are easier to understand, shell functions are preferred over aliases for almost every purpose.
More Bash options
We already discussed a couple of Bash options that are useful for debugging your scripts. In this section, we will take a more in-depth view of the Bash options.
Use the -o option to set to display all shell options:
willy:~> set -o allexport off braceexpand on emacs on errexit off hashall on histexpand on history on ignoreeof off interactive-comments on keyword off monitor on noclobber off noexec off noglob off nolog off notify off nounset off onecmd off physical off posix off privileged off verbose off vi off xtrace off
See the Bash Info pages, section Shell Built-in Commands->The Set Built-in for a description of each option. A lot of options have one-character shorthands: the xtrace option, for instance, is equal to specifying set -x.
Changing options
Shell options can either be set different from the default upon calling the shell, or be set during shell operation. They may also be included in the shell resource configuration files.
The following command executes a script in POSIX-compatible mode:
willy:~/scripts> bash --posix script.sh
For changing the current environment temporarily, or for use in a script, we would rather use set. Use - (dash) for enabling an option, + for disabling:
willy:~/test> set -o noclobber willy:~/test> touch test willy:~/test> date > test bash: test: cannot overwrite existing file willy:~/test> set +o noclobber willy:~/test> date > test
The above example demonstrates the noclobber option, which prevents existing files from being overwritten by redirection operations. The same goes for one-character options, for instance -u, which will treat unset variables as an error when set, and exits a non-interactive shell upon encountering such errors:
willy:~> echo $VAR willy:~> set -u willy:~> echo $VAR bash: VAR: unbound variable
This option is also useful for detecting incorrect content assignment to variables: the same error will also occur, for instance, when assigning a character string to a variable that was declared explicitly as one holding only integer values.
One last example follows, demonstrating the noglob option, which prevents special characters from being expanded:
willy:~/testdir> set -o noglob willy:~/testdir> touch * willy:~/testdir> ls -l * -rw-rw-r-- 1 willy willy 0 Feb 27 13:37 *
Regular expressions
A regular expression is a pattern that describes a set of strings. Regular expressions are constructed analogously to arithmetic expressions by using various operators to combine smaller expressions.
The fundamental building blocks are the regular expressions that match a single character. Most characters, including all letters and digits, are regular expressions that match themselves. Any metacharacter with special meaning may be quoted by preceding it with a backslash.
Regular expression metacharacters
A regular expression may be followed by one of several repetition operators (metacharacters):
Regular expression operators
| Operator | Effect |
|---|---|
| . | Matches any single character. |
| ? | The preceding item is optional and will be matched, at most, once. |
| * | The preceding item will be matched zero or more times. |
| + | The preceding item will be matched one or more times. |
| {N} | The preceding item is matched exactly N times. |
| {N,} | The preceding item is matched N or more times. |
| {N,M} | The preceding item is matched at least N times, but not more than M times. |
| - | represents the range if it's not first or last in a list or the ending point of a range in a list. |
| ^ | Matches the empty string at the beginning of a line; also represents the characters not in the range of a list. |
| $ | Matches the empty string at the end of a line. |
| Matches the empty string at the edge of a word. | |
| \B | Matches the empty string provided it's not at the edge of a word. |
| \< | Match the empty string at the beginning of word. |
| \> | Match the empty string at the end of word. |
Two regular expressions may be concatenated; the resulting regular expression matches any string formed by concatenating two substrings that respectively match the concatenated subexpressions.
Two regular expressions may be joined by the infix operator "|"; the resulting regular expression matches any string matching either subexpression.
Repetition takes precedence over concatenation, which in turn takes precedence over alternation. A whole subexpression may be enclosed in parentheses to override these precedence rules.
Basic versus extended regular expressions
In basic regular expressions the metacharacters "?", "+", "{", "|", "(", and ")" lose their special meaning; instead use the backslashed versions "\?", "\+", "\{", "\|", "\(", and "\)".
Check in your system documentation whether commands using regular expressions support extended expressions.
Pattern matching
The asterisk (*) and the question mark (?) match any string or any single character, respectively. Quote these special characters to match them literally:
cathy ~> touch "*" cathy ~> ls "*" *
But you can also use the square braces to match any enclosed character or range of characters, if pairs of characters are separated by a hyphen. An example:
cathy ~> ls -ld [a-cx-z]* drwxr-xr-x 2 cathy cathy 4096 Jul 20 2002 app-defaults/ drwxrwxr-x 4 cathy cathy 4096 May 25 2002 arabic/ drwxrwxr-x 2 cathy cathy 4096 Mar 4 18:30 bin/ drwxr-xr-x 7 cathy cathy 4096 Sep 2 2001 crossover/ drwxrwxr-x 3 cathy cathy 4096 Mar 22 2002 xml/
This lists all files in cathy's home directory, starting with "a", "b", "c", "x", "y" or "z".
If the first character within the braces is "!" or "^", any character not enclosed will be matched. To match the dash ("-"), include it as the first or last character in the set. The sorting depends on the current locale and of the value of the LC_COLLATE variable, if it is set. Mind that other locales might interpret "[a-cx-z]" as "[aBbCcXxYyZz]" if sorting is done in dictionary order. If you want to be sure to have the traditional interpretation of ranges, force this behavior by setting LC_COLLATE or LC_ALL to "C".
Character classes
Character classes can be specified within the square braces, using the syntax [:CLASS:], where CLASS is defined in the POSIX standard and has one of the values
"alnum", "alpha", "ascii", "blank", "cntrl", "digit", "graph", "lower", "print", "punct", "space", "upper", "word" or "xdigit".
Some examples:
cathy ~> ls -ld [[:digit:]]* drwxrwxr-x 2 cathy cathy 4096 Apr 20 13:45 2/ cathy ~> ls -ld [[:upper:]]* drwxrwxr-- 3 cathy cathy 4096 Sep 30 2001 Nautilus/ drwxrwxr-x 4 cathy cathy 4096 Jul 11 2002 OpenOffice.org1.0/ -rw-rw-r-- 1 cathy cathy 997376 Apr 18 15:39 Schedule.sdc
When the extglob shell option is enabled (using the shopt built-in), several extended pattern matching operators are recognized. Read more in the Bash info pages, section Basic shell features->Shell Expansions->Filename Expansion->Pattern Matching.
Conditional Execution
Bash supports conditional execution and expressions. Conditional expressions are used by the [[ compound command and the test and [ builtin commands to test file attributes and perform string and arithmetic comparisons. These include tests for file, strings and arithmetic binary operators such as -eq, -ne, -gt, -lt, -le and -ge.
bash -eq -lt -gt
The following scripts illustrates conditional execution within bash using -eq, -lt, -gt and similar operators. See the section below on conditional statements and primary expressions for more detail.
adam@moon:~> cat busy.sh #!/bin/bash ((users=`w | cut -d " " -f 1 - | grep -v USER | sort -u|wc -l`)) if [ $users -eq 2 ] then echo you are the only one logged on fi if [ $users -gt 6 ] then echo $users users: you have a lot of company fi if [ $users -gt 2 ] && [ $users -lt 7 ] then echo $users users: a few friends are logged on fi adam@moon:~> ./busy.sh 3 users: a few friends are logged on adam@moon:~>
Conditional statements
At times you need to specify different courses of action to be taken in a shell script, depending on the success or failure of a command. The if construction allows you to specify such conditions.
The most compact syntax of the if command is:
if TEST-COMMANDS; then CONSEQUENT-COMMANDS; fi
The TEST-COMMAND list is executed, and if its return status is zero, the CONSEQUENT-COMMANDS list is executed. The return status is the exit status of the last command executed, or zero if no condition tested true.
The TEST-COMMAND often involves numerical or string comparison tests, but it can also be any command that returns a status of zero when it succeeds and some other status when it fails. Unary expressions are often used to examine the status of a file. If the FILE argument to one of the primaries is of the form /dev/fd/N, then file descriptor "N" is checked. stdin, stdout and stderr and their respective file descriptors may also be used for tests.
Expressions used with if statement
The table below contains an overview of the so-called "primaries" that make up the TEST-COMMAND command or list of commands. These primaries are put between square brackets to indicate the test of a conditional expression.
Primary expressions
| Primary | Meaning |
|---|---|
| [ -a FILE ] | True if FILE exists. |
| [ -b FILE ] | True if FILE exists and is a block-special file. |
| [ -c FILE ] | True if FILE exists and is a character-special file. |
| [ -d FILE ] | True if FILE exists and is a directory. |
| [ -e FILE ] | True if FILE exists. |
| [ -f FILE ] | True if FILE exists and is a regular file. |
| [ -g FILE ] | True if FILE exists and its SGID bit is set. |
| [ -h FILE ] | True if FILE exists and is a symbolic link. |
| [ -k FILE ] | True if FILE exists and its sticky bit is set. |
| [ -p FILE ] | True if FILE exists and is a named pipe (FIFO). |
| [ -r FILE ] | True if FILE exists and is readable. |
| [ -s FILE ] | True if FILE exists and has a size greater than zero. |
| [ -t FD ] | True if file descriptor FD is open and refers to a terminal. |
| [ -u FILE ] | True if FILE exists and its SUID (set user ID) bit is set. |
| [ -w FILE ] | True if FILE exists and is writable. |
| [ -x FILE ] | True if FILE exists and is executable. |
| [ -O FILE ] | True if FILE exists and is owned by the effective user ID. |
| [ -G FILE ] | True if FILE exists and is owned by the effective group ID. |
| [ -L FILE ] | True if FILE exists and is a symbolic link. |
| [ -N FILE ] | True if FILE exists and has been modified since it was last read. |
| [ -S FILE ] | True if FILE exists and is a socket. |
| [ FILE1 -nt FILE2 ] | True if FILE1 has been changed more recently than FILE2, or if FILE1 exists and FILE2 does not. |
| [ FILE1 -ot FILE2 ] | True if FILE1 is older than FILE2, or is FILE2 exists and FILE1 does not. |
| [ FILE1 -ef FILE2 ] | True if FILE1 and FILE2 refer to the same device and inode numbers. |
| [ -o OPTIONNAME ] | True if shell option "OPTIONNAME" is enabled. |
| [ -z STRING ] | True of the length if "STRING" is zero. |
| [ -n STRING ] or [ STRING ] | True if the length of "STRING" is non-zero. |
| [ STRING1 == STRING2 ] | True if the strings are equal. "=" may be used instead of "==" for strict POSIX compliance. |
| [ STRING1 != STRING2 ] | True if the strings are not equal. |
| [ STRING1 < STRING2 ] | True if "STRING1" sorts before "STRING2" lexicographically in the current locale. |
| [ STRING1 > STRING2 ] | True if "STRING1" sorts after "STRING2" lexicographically in the current locale. |
| [ ARG1 OP ARG2 ] | "OP" is one of -eq, -ne, -lt, -le, -gt or -ge. These arithmetic binary operators return true if "ARG1" is equal to, not equal to, less than, less than or equal to, greater than, or greater than or equal to "ARG2", respectively. "ARG1" and "ARG2" are integers. |
Expressions may be combined using the following operators, listed in decreasing order of precedence:
| Operation | Effect |
|---|---|
| [ ! EXPR ] | True if EXPR is false. |
| [ ( EXPR ) ] | Returns the value of EXPR. This may be used to override the normal precedence of operators. |
| [ EXPR1 -a EXPR2 ] | True if both EXPR1 and EXPR2 are true. |
| [ EXPR1 -o EXPR2 ] | True if either EXPR1 or EXPR2 is true. |
The [ (or test) built-in evaluates conditional expressions using a set of rules based on the number of arguments. More information about this subject can be found in the Bash documentation. Just like the if is closed with fi, the opening square bracket should be closed after the conditions have been listed.
Commands following the then statement
The CONSEQUENT-COMMANDS list that follows the then statement can be any valid UNIX command, any executable program, any executable shell script or any shell statement, with the exception of the closing fi. It is important to remember that the then and fi are considered to be separated statements in the shell. Therefore, when issued on the command line, they are separated by a semi-colon.
In a script, the different parts of the if statement are usually well-separated. Below, a couple of simple examples.
Checking files
The first example checks for the existence of a file:
anny ~> cat msgcheck.sh
#!/bin/bash
echo "This scripts checks the existence of the messages file."
echo "Checking..."
if [ -f /var/log/messages ]
then
echo "/var/log/messages exists."
fi
echo
echo "...done."
anny ~> ./msgcheck.sh
This scripts checks the existence of the messages file.
Checking...
/var/log/messages exists.
...done.
Checking shell options
To add in your Bash configuration files:
# These lines will print a message if the noclobber option is set:
if [ -o noclobber ]
then
echo "Your files are protected against accidental overwriting using redirection."
fi
The environment
The above example will work when entered on the command line:
anny ~> if [ -o noclobber ] ; then echo ; echo "your files are protected against overwriting." ; echo ; fi your files are protected against overwriting. anny ~>
However, if you use testing of conditions that depend on the environment, you might get different results when you enter the same command in a script, because the script will open a new shell, in which expected variables and options might not be set automatically.
if statement - Testing exit status
The ? variable holds the exit status of the previously executed command (the most recently completed foreground process).
The following example shows a simple test:
anny ~> if [ $? -eq 0 ] More input> then echo 'That was a good job!' More input> fi That was a good job! anny ~>
The following example demonstrates that TEST-COMMANDS might be any UNIX command that returns an exit status, and that if again returns an exit status of zero:
anny ~> if ! grep $USER /etc/passwd More input> then echo "your user account is not managed locally"; fi your user account is not managed locally anny > echo $? 0 anny >
The same result can be obtained as follows:
anny > grep $USER /etc/passwd anny > if [ $? -ne 0 ] ; then echo "not a local account" ; fi not a local account anny >
if statement - Numeric comparisons
The examples below use numerical comparisons:
anny > num=`wc -l work.txt` anny > echo $num 201 anny > if [ "$num" -gt "150" ] More input> then echo ; echo "you've worked hard enough for today." More input> echo ; fi you've worked hard enough for today. anny >
This script is executed by cron every Sunday. If the week number is even, it reminds you to put out the garbage cans:
#!/bin/bash # Calculate the week number using the date command: WEEKOFFSET=$[ $(date +"%V") % 2 ] # Test if we have a remainder. If not, this is an even week so send a message. # Else, do nothing. if [ $WEEKOFFSET -eq "0" ]; then echo "Sunday evening, put out the garbage cans." | mail -s "Garbage cans out" your@your_domain.org fi
String comparisons
An example of comparing strings for testing the user ID:
if [ "$(whoami)" != 'root' ]; then
echo "You have no permission to run $0 as non-root user."
exit 1;
fi
With Bash, you can shorten this type of construct. The compact equivalent of the above test is as follows:
[ "$(whoami)" != 'root' ] && ( echo you are using a non-privileged account; exit 1 )
Similar to the "&&" expression which indicates what to do if the test proves true, "||" specifies what to do if the test is false.
Regular expressions may also be used in comparisons:
anny > gender="female" anny > if [[ "$gender" == f* ]] More input> then echo "Pleasure to meet you, Madame."; fi Pleasure to meet you, Madame. anny >
Programmers
Most programmers will prefer to use the test built-in command, which is equivalent to using square brackets for comparison, like this:
test "$(whoami)" != 'root' && (echo you are using a non-privileged account; exit 1)
No exit?
If you invoke the exit in a subshell, it will not pass variables to the parent. Use { and } instead of ( and ) if you do not want Bash to fork a subshell.
See the info pages for Bash for more information on pattern matching with the "(( EXPRESSION ))" and "[[ EXPRESSION ]]" constructs.
if/then/else constructs
This is the construct to use to take one course of action if the if commands test true, and another if it tests false. An example:
freddy scripts> gender="male" freddy scripts> if [[ "$gender" == "f*" ]] More input> then echo "Pleasure to meet you, Madame." More input> else echo "How come the lady hasn't got a drink yet?" More input> fi How come the lady hasn't got a drink yet? freddy scripts>
[] vs. [[]]
Contrary to [, [[ prevents word splitting of variable values. So, if VAR="var with spaces", you do not need to double quote $VAR in a test - eventhough using quotes remains a good habit. Also, [[ prevents pathname expansion, so literal strings with wildcards do not try to expand to filenames. Using [[, == and != interpret strings to the right as shell glob patterns to be matched against the value to the left, for instance: [[ "value" == val* ]].
Like the CONSEQUENT-COMMANDS list following the then statement, the ALTERNATE-CONSEQUENT-COMMANDS list following the else statement can hold any UNIX-style command that returns an exit status.
Another example.
anny ~> su - Password: [root@elegance root]# if ! grep ^$USER /etc/passwd 1> /dev/null > then echo "your user account is not managed locally" > else echo "your account is managed from the local /etc/passwd file" > fi your account is managed from the local /etc/passwd file [root@elegance root]#
We switch to the root account to demonstrate the effect of the else statement - your root is usually a local account while your own user account might be managed by a central system, such as an LDAP server.
Checking command line arguments
Instead of setting a variable and then executing a script, it is frequently more elegant to put the values for the variables on the command line.
We use the positional parameters $1, $2, ..., $N for this purpose. $# refers to the number of command line arguments. $0 refers to the name of the script.
Here's anexample, using two arguments:
anny ~> cat weight.sh #!/bin/bash # This script prints a message about your weight if you give it your # weight in kilos and height in centimeters. weight="$1" height="$2" idealweight=$[$height - 110] if [ $weight -le $idealweight ] ; then echo "You should eat a bit more fat." else echo "You should eat a bit more fruit." fi anny ~> bash -x weight.sh 55 169 + weight=55 + height=169 + idealweight=59 + '[' 55 -le 59 ']' + echo 'You should eat a bit more fat.' You should eat a bit more fat.
Testing the number of arguments
The following example shows how to change the previous script so that it prints a message if more or less than 2 arguments are given:
anny ~> cat weight.sh #!/bin/bash # This script prints a message about your weight if you give it your # weight in kilos and height in centimeters. if [ ! $# == 2 ]; then echo "Usage: $0 weight_in_kilos length_in_centimeters" exit fi weight="$1" height="$2" idealweight=$[$height - 110] if [ $weight -le $idealweight ] ; then echo "You should eat a bit more fat." else echo "You should eat a bit more fruit." fi anny ~> weight.sh 70 150 You should eat a bit more fruit. anny ~> weight.sh 70 150 33 Usage: ./weight.sh weight_in_kilos length_in_centimeters
The first argument is referred to as $1, the second as $2 and so on. The total number of arguments is stored in $#.
Testing that a file exists
This test is done in a lot of scripts, because there's no use in starting a lot of programs if you know they're not going to work:
#!/bin/bash
# This script gives information about a file.
FILENAME="$1"
echo "Properties for $FILENAME:"
if [ -f $FILENAME ]; then
echo "Size is $(ls -lh $FILENAME | awk '{ print $5 }')"
echo "Type is $(file $FILENAME | cut -d":" -f2 -)"
echo "Inode number is $(ls -i $FILENAME | cut -d" " -f1 -)"
echo "$(df -h $FILENAME | grep -v Mounted | awk '{ print "On",$1", \
which is mounted as the",$6,"partition."}')"
else
echo "File does not exist."
fi
Note that the file is referred to using a variable; in this case it is the first argument to the script. Alternatively, when no arguments are given, file locations are usually stored in variables at the beginning of a script, and their content is referred to using these variables. Thus, when you want to change a file name in a script, you only need to do it once.
Filenames with spaces
The above example will fail if the value of $1 can be parsed as multiple words. In that case, the if command can be fixed either using double quotes around the filename, or by using [[ instead of [.
if/then/elif/else statements
This is the full form of the if statement:
if TEST-COMMANDS; then
CONSEQUENT-COMMANDS;
elif MORE-TEST-COMMANDS; then
MORE-CONSEQUENT-COMMANDS;
else ALTERNATE-CONSEQUENT-COMMANDS;
fi
The TEST-COMMANDS list is executed, and if its return status is zero, the CONSEQUENT-COMMANDS list is executed. If TEST-COMMANDS returns a non-zero status, each elif list is executed in turn, and if its exit status is zero, the corresponding MORE-CONSEQUENT-COMMANDS is executed and the command completes. If else is followed by an ALTERNATE-CONSEQUENT-COMMANDS list, and the final command in the final if or elif clause has a non-zero exit status, then ALTERNATE-CONSEQUENT-COMMANDS is executed. The return status is the exit status of the last command executed, or zero if no condition tested true.
Example
This is an example that you can put in your crontab for daily execution:
anny /etc/cron.daily> cat disktest.sh
#!/bin/bash
# This script does a very simple test for checking disk space.
space=`df -h | awk '{print $5}' | grep % | grep -v Use | sort -n | tail -1 | cut -d "%" -f1 -`
alertvalue="80"
if [ "$space" -ge "$alertvalue" ]; then
echo "At least one of my disks is nearly full!" | mail -s "daily diskcheck" root
else
echo "Disk space normal" | mail -s "daily diskcheck" root
fi
Nested if statements
Inside the if statement, you can use another if statement. You may use as many levels of nested ifs as you can logically manage.
This is an example testing leap years:
anny ~/testdir> cat testleap.sh
#!/bin/bash
# This script will test if we're in a leap year or not.
year=`date +%Y`
if [ $[$year % 400] -eq "0" ]; then
echo "This is a leap year. February has 29 days."
elif [ $[$year % 4] -eq 0 ]; then
if [ $[$year % 100] -ne 0 ]; then
echo "This is a leap year, February has 29 days."
else
echo "This is not a leap year. February has 28 days."
fi
else
echo "This is not a leap year. February has 28 days."
fi
anny ~/testdir> date
Tue Jan 14 20:37:55 CET 2003
anny ~/testdir> testleap.sh
This is not a leap year.
Using the exit statement and if
The exit statement terminates execution of the entire script. It is most often used if the input requested from the user is incorrect, if a statement did not run successfully or if some other error occurred.
The exit statement takes an optional argument. This argument is the integer exit status code, which is passed back to the parent and stored in the $? variable.
A zero argument means that the script ran successfully. Any other value may be used by programmers to pass back different messages to the parent, so that different actions can be taken according to failure or success of the child process. If no argument is given to the exit command, the parent shell uses the current value of the $? variable.
Below is an example with a slightly adapted penguin.sh script, which sends its exit status back to the parent, feed.sh:
anny ~/testdir> cat penguin.sh
#!/bin/bash
# This script lets you present different menus to Tux. He will only be happy
# when given a fish. We've also added a dolphin and (presumably) a camel.
if [ "$menu" == "fish" ]; then
if [ "$animal" == "penguin" ]; then
echo "Hmmmmmm fish... Tux happy!"
elif [ "$animal" == "dolphin" ]; then
echo "Pweetpeettreetppeterdepweet!"
else
echo "*prrrrrrrt*"
fi
else
if [ "$animal" == "penguin" ]; then
echo "Tux don't like that. Tux wants fish!"
exit 1
elif [ "$animal" == "dolphin" ]; then
echo "Pweepwishpeeterdepweet!"
exit 2
else
echo "Will you read this sign?!"
exit 3
fi
fi
This script is called upon in the next one, which therefore exports its variables menu and animal:
anny ~/testdir> cat feed.sh
#!/bin/bash
# This script acts upon the exit status given by penguin.sh
export menu="$1"
export animal="$2"
feed="/nethome/anny/testdir/penguin.sh"
$feed $menu $animal
case $? in
1)
echo "Guard: You'd better give'm a fish, less they get violent..."
;;
2)
echo "Guard: It's because of people like you that they are leaving earth all the time..."
;;
3)
echo "Guard: Buy the food that the Zoo provides for the animals, you ***, how
do you think we survive?"
;;
*)
echo "Guard: Don't forget the guide!"
;;
esac
anny ~/testdir> ./feed.sh apple penguin
Tux don't like that. Tux wants fish!
Guard: You'd better give'm a fish, less they get violent...
As you can see, exit status codes can be chosen freely. Existing commands usually have a series of defined codes; see the programmer's manual for each command for more information.
Using case statements
Nested if statements might be nice, but as soon as you are confronted with a couple of different possible actions to take, they tend to confuse. For the more complex conditionals, use the case syntax:
case EXPRESSION in CASE1) COMMAND-LIST;; CASE2) COMMAND-LIST;; ... CASEN) COMMAND-LIST;; esac
Each case is an expression matching a pattern. The commands in the COMMAND-LIST for the first match are executed. The "|" symbol is used for separating multiple patterns, and the ")" operator terminates a pattern list. Each case plus its according commands are called a clause. Each clause must be terminated with ";;". Each case statement is ended with the esac statement.
In the example, we demonstrate use of cases for sending a more selective warning message with the disktest.sh script:
anny ~/testdir> cat disktest.sh
#!/bin/bash
# This script does a very simple test for checking disk space.
space=`df -h | awk '{print $5}' | grep % | grep -v Use | sort -n | tail -1 | cut -d "%" -f1 -`
case $space in
[1-6]*)
Message="All is quiet."
;;
[7-8]*)
Message="Start thinking about cleaning out some stuff. There's a partition that is $space % full."
;;
9[1-8])
Message="Better hurry with that new disk... One partition is $space % full."
;;
99)
Message="I'm drowning here! There's a partition at $space %!"
;;
*)
Message="I seem to be running with an nonexistent amount of disk space..."
;;
esac
echo $Message | mail -s "disk report `date`" anny
anny ~/testdir>
You have new mail.
anny ~/testdir> tail -16 /var/spool/mail/anny
From anny@octarine Tue Jan 14 22:10:47 2003
Return-Path: <anny@octarine>
Received: from octarine (localhost [127.0.0.1])
by octarine (8.12.5/8.12.5) with ESMTP id h0ELAlBG020414
for <anny@octarine>; Tue, 14 Jan 2003 22:10:47 +0100
Received: (from anny@localhost)
by octarine (8.12.5/8.12.5/Submit) id h0ELAltn020413
for anny; Tue, 14 Jan 2003 22:10:47 +0100
Date: Tue, 14 Jan 2003 22:10:47 +0100
From: Anny <anny@octarine>
Message-Id: <200301142110.h0ELAltn020413@octarine>
To: anny@octarine
Subject: disk report Tue Jan 14 22:10:47 CET 2003
Start thinking about cleaning out some stuff. There's a partition that is 87 % full.
anny ~/testdir>
Of course you could have opened your mail program to check the results; this is just to demonstrate that the script sends a decent mail with "To:", "Subject:" and "From:" header lines.
Many more examples using case statements can be found in your system's init script directory. The startup scripts use start and stop cases to run or stop system processes. A theoretical example can be found in the next section.
Redirection and file descriptors
As you know from basic shell usage, input and output of a command may be redirected before it is executed, using a special notation - the redirection operators - interpreted by the shell. Redirection may also be used to open and close files for the current shell execution environment.
Redirection can also occur in a script, so that it can receive input from a file, for instance, or send output to a file. Later, the user can review the output file, or it may be used by another script as input.
File input and output are accomplished by integer handles that track all open files for a given process. These numeric values are known as file descriptors. The best known file descriptors are stdin, stdout and stderr, with file descriptor numbers 0, 1 and 2, respectively. These numbers and respective devices are reserved. Bash can take TCP or UDP ports on networked hosts as file descriptors as well.
The output below shows how the reserved file descriptors point to actual devices:
michel ~> ls -l /dev/std* lrwxrwxrwx 1 root root 17 Oct 2 07:46 /dev/stderr -> ../proc/self/fd/2 lrwxrwxrwx 1 root root 17 Oct 2 07:46 /dev/stdin -> ../proc/self/fd/0 lrwxrwxrwx 1 root root 17 Oct 2 07:46 /dev/stdout -> ../proc/self/fd/1 michel ~> ls -l /proc/self/fd/[0-2] lrwx------ 1 michel michel 64 Jan 23 12:11 /proc/self/fd/0 -> /dev/pts/6 lrwx------ 1 michel michel 64 Jan 23 12:11 /proc/self/fd/1 -> /dev/pts/6 lrwx------ 1 michel michel 64 Jan 23 12:11 /proc/self/fd/2 -> /dev/pts/6
Note that each process has its own view of the files under /proc/self, as it is actually a symbolic link to /proc/<process_ID>.
You might want to check info MAKEDEV and info proc for more information about /proc subdirectories and the way your system handles standard file descriptors for each running process.
When excuting a given command, the following steps are excuted, in order:
-
If the standard output of a previous command is being piped to the standard input of the current command, then /proc/<current_process_ID>/fd/0 is updated to target the same anonymous pipe as /proc/<previous_process_ID/fd/1.
-
If the standard output of the current command is being piped to the standard input of the next command, then /proc/<current_process_ID>/fd/1 is updated to target another anonymous pipe.
-
Redirection for the current command is processed from left to right.
-
Redirection "N>&M" or "N<&M" after a command has the effect of creating or updating the symbolic link /proc/self/fd/N with the same target as the symbolic link /proc/self/fd/M.
-
The redirections "N> file" and "N< file" have the effect of creating or updating the symbolic link /proc/self/fd/N with the target file.
-
File descriptor closure "N>&-" has the effect of deleting the symbolic link /proc/self/fd/N.
-
Only now is the current command executed.
When you run a script from the command line, nothing much changes because the child shell process will use the same file descriptors as the parent. When no such parent is available, for instance when you run a script using the cron facility, the standard file descriptors are pipes or other (temporary) files, unless some form of redirection is used. This is demonstrated in the example below, which shows output from a simple at script:
michel ~> date Fri Jan 24 11:05:50 CET 2003 michel ~> at 1107 warning: commands will be executed using (in order) a) $SHELL b) login shell c)/bin/sh at> ls -l /proc/self/fd/ > /var/tmp/fdtest.at at> <EOT> job 10 at 2003-01-24 11:07 michel ~> cat /var/tmp/fdtest.at total 0 lr-x------ 1 michel michel 64 Jan 24 11:07 0 -> /var/spool/at/!0000c010959eb (deleted) l-wx------ 1 michel michel 64 Jan 24 11:07 1 -> /var/tmp/fdtest.at l-wx------ 1 michel michel 64 Jan 24 11:07 2 -> /var/spool/at/spool/a0000c010959eb lr-x------ 1 michel michel 64 Jan 24 11:07 3 -> /proc/21949/fd
And one with cron:
michel ~> crontab -l # DO NOT EDIT THIS FILE - edit the master and reinstall. # (/tmp/crontab.21968 installed on Fri Jan 24 11:30:41 2003) # (Cron version -- $Id: chap8.xml,v 1.9 2006/09/28 09:42:45 tille Exp $) 32 11 * * * ls -l /proc/self/fd/ > /var/tmp/fdtest.cron michel ~> cat /var/tmp/fdtest.cron total 0 lr-x------ 1 michel michel 64 Jan 24 11:32 0 -> pipe:[124440] l-wx------ 1 michel michel 64 Jan 24 11:32 1 -> /var/tmp/fdtest.cron l-wx------ 1 michel michel 64 Jan 24 11:32 2 -> pipe:[124441] lr-x------ 1 michel michel 64 Jan 24 11:32 3 -> /proc/21974/fd
Redirection of errors
From the previous examples, it is clear that you can provide input and output files for a script, but some tend to forget about redirecting errors - output which might be depended upon later on. Also, if you are lucky, errors will be mailed to you and eventual causes of failure might get revealed. If you are not as lucky, errors will cause your script to fail and won't be caught or sent anywhere, so that you can't start to do any worthwhile debugging.
When redirecting errors, note that the order of precedence is significant. For example, this command, issued in /var/spool
ls -l * 2> /var/tmp/unaccessible-in-spool
will redirect standard output of the ls command to the file unaccessible-in-spool in /var/tmp. The command
ls -l * > /var/tmp/spoollist 2>&1
will direct both standard input and standard error to the file spoollist. The command
ls -l * 2 >& 1 > /var/tmp/spoollist
directs only the standard output to the destination file, because the standard error is copied to standard output before the standard output is redirected.
For convenience, errors are often redirected to /dev/null, if it is sure they will not be needed. Hundreds of examples can be found in the startup scripts for your system.
Bash allows for both standard output and standard error to be redirected to the file whose name is the result of the expansion of FILE with this construct:
&> FILE
This is the equivalent of > FILE 2>&1, the construct used in the previous set of examples. It is also often combined with redirection to /dev/null, for instance when you just want a command to execute, no matter what output or errors it gives.
File descriptors - input and output
The /dev/fd directory contains entries named 0, 1, 2, and so on. Opening the file /dev/fd/N is equivalent to duplicating file descriptor N. If your system provides /dev/stdin, /dev/stdout and /dev/stderr, you will see that these are equivalent to /dev/fd/0, /dev/fd/1 and /dev/fd/2, respectively.
The main use of the /dev/fd files is from the shell. This mechanism allows for programs that use pathname arguments to handle standard input and standard output in the same way as other pathnames. If /dev/fd is not available on a system, you'll have to find a way to bypass the problem. This can be done for instance using a hyphen (-) to indicate that a program should read from a pipe. An example:
michel ~> filter body.txt.gz | cat header.txt - footer.txt This text is printed at the beginning of each print job and thanks the sysadmin for setting us up such a great printing infrastructure. Text to be filtered. This text is printed at the end of each print job.
The cat command first reads the file header.txt, next its standard input which is the output of the filter command, and last the footer.txt file. The special meaning of the hyphen as a command-line argument to refer to the standard input or standard output is a misconception that has crept into many programs. There might also be problems when specifying hyphen as the first argument, since it might be interpreted as an option to the preceding command. Using /dev/fd allows for uniformity and prevents confusion:
michel ~> filter body.txt | cat header.txt /dev/fd/0 footer.txt | lp
In this clean example, all output is additionally piped through lp to send it to the default printer.
Assigning file descriptors to files
Another way of looking at file descriptors is thinking of them as a way to assign a numeric value to a file. Instead of using the file name, you can use the file descriptor number. The exec built-in command can be used to replace the shell of the current process or to alter the file descriptors of the current shell. For example, it can be used to assign a file descriptor to a file. Use
exec fdN> file
for assigning file descriptor N to file for output, and
exec fdN< file
for assigning file descriptor N to file for input. After a file descriptor has been assigned to a file, it can be used with the shell redirection operators, as is demonstrated in the following example:
michel ~> exec 4> result.txt michel ~> filter body.txt | cat header.txt /dev/fd/0 footer.txt >& 4 michel ~> cat result.txt This text is printed at the beginning of each print job and thanks the sysadmin for setting us up such a great printing infrastructure. Text to be filtered. This text is printed at the end of each print job.
Closing file descriptors
Since child processes inherit open file descriptors, it is good practice to close a file descriptor when it is no longer needed. This is done using the
exec fd<&-
syntax. In the above example, file descriptor 7, which has been assigned to standard input, is closed each time the user needs to have access to the actual standard input device, usually the keyboard.
The following is a simple example redirecting only standard error to a pipe:
michel ~> cat listdirs.sh
#!/bin/bash
# This script prints standard output unchanged, while standard error is
# redirected for processing by awk.
INPUTDIR="$1"
# fd 6 targets fd 1 target (console out) in current shell
exec 6>&1
# fd 1 targets pipe, fd 2 targets fd 1 target (pipe),
# fd 1 targets fd 6 target (console out), fd 6 closed, execute ls
ls "$INPUTDIR"/* 2>&1 >&6 6>&- \
# Closes fd 6 for awk, but not for ls.
| awk 'BEGIN { FS=":" } { print "YOU HAVE NO ACCESS TO" $2 }' 6>&-
# fd 6 closed for current shell
exec 6>&-
Here documents
Frequently, your script might call on another program or script that requires input. The here document provides a way of instructing the shell to read input from the current source until a line containing only the search string is found (no trailing blanks). All of the lines read up to that point are then used as the standard input for a command.
The result is that you don't need to call on separate files; you can use shell-special characters, and it looks nicer than a bunch of echo's:
michel ~> cat startsurf.sh #!/bin/bash # This script provides an easy way for users to choose between browsers. echo "These are the web browsers on this system:" # Start here document cat << BROWSERS mozilla links lynx konqueror opera netscape BROWSERS # End here document echo -n "Which is your favorite? " read browser echo "Starting $browser, please wait..." $browser & michel ~> startsurf.sh These are the web browsers on this system: mozilla links lynx konqueror opera netscape Which is your favorite? opera Starting opera, please wait...
Although we talk about a here document, it is supposed to be a construct within the same script. This is an example that installs a package automatically, eventhough you should normally confirm:
#!/bin/bash
# This script installs packages automatically, using yum.
if [ $# -lt 1 ]; then
echo "Usage: $0 package."
exit 1
fi
yum install $1 << CONFIRM
y
CONFIRM
And this is how the script runs. When prompted with the "Is this ok [y/N]" string, the script answers "y" automatically:
[root@picon bin]# ./install.sh tuxracer Gathering header information file(s) from server(s) Server: Fedora Linux 2 - i386 - core Server: Fedora Linux 2 - i386 - freshrpms Server: JPackage 1.5 for Fedora Core 2 Server: JPackage 1.5, generic Server: Fedora Linux 2 - i386 - updates Finding updated packages Downloading needed headers Resolving dependencies Dependencies resolved I will do the following: [install: tuxracer 0.61-26.i386] Is this ok [y/N]: EnterDownloading Packages Running test transaction: Test transaction complete, Success! tuxracer 100 % done 1/1 Installed: tuxracer 0.61-26.i386 Transaction(s) Complete
for loop
The for loop is the first of the three shell looping constructs. This loop allows for specification of a list of values. A list of commands is executed for each value in the list.
The syntax for this loop is:
for NAME [in LIST ]; do COMMANDS; done
If [in LIST] is not present, it is replaced with in $@ and for executes the COMMANDS once for each positional parameter that is set.
The return status is the exit status of the last command that executes. If no commands are executed because LIST does not expand to any items, the return status is zero.
NAME can be any variable name, although i is used very often. LIST can be any list of words, strings or numbers, which can be literal or generated by any command. The COMMANDS to execute can also be any operating system commands, script, program or shell statement. The first time through the loop, NAME is set to the first item in LIST. The second time, its value is set to the second item in the list, and so on. The loop terminates when NAME has taken on each of the values from LIST and no items are left in LIST.
Using command substitution for specifying LIST items
The first is a command line example, demonstrating the use of a for loop that makes a backup copy of each .xml file. After issuing the command, it is safe to start working on your sources:
[carol@octarine ~/articles] ls *.xml file1.xml file2.xml file3.xml [carol@octarine ~/articles] ls *.xml > list [carol@octarine ~/articles] for i in `cat list`; do cp "$i" "$i".bak ; done [carol@octarine ~/articles] ls *.xml* file1.xml file1.xml.bak file2.xml file2.xml.bak file3.xml file3.xml.bak
This one lists the files in /sbin that are just plain text files, and possibly scripts:
for i in `ls /sbin`; do file /sbin/$i | grep ASCII; done
Using the content of a variable to specify LIST items
The following is a specific application script for converting HTML files, compliant with a certain scheme, to PHP files. The conversion is done by taking out the first 25 and the last 21 lines, replacing these with two PHP tags that provide header and footer lines:
[carol@octarine ~/html] cat html2php.sh
#!/bin/bash
# specific conversion script for my html files to php
LIST="$(ls *.html)"
for i in "$LIST"; do
NEWNAME=$(ls "$i" | sed -e 's/html/php/')
cat beginfile > "$NEWNAME"
cat "$i" | sed -e '1,25d' | tac | sed -e '1,21d'| tac >> "$NEWNAME"
cat endfile >> "$NEWNAME"
done
Since we don't do a line count here, there is no way of knowing the line number from which to start deleting lines until reaching the end. The problem is solved using tac, which reverses the lines in a file.
The basename command
Instead of using sed to replace the html suffix with php, it would be cleaner to use the basename command. Read the man page for more info.
Odd characters
You will run into problems if the list expands to file names containing spaces and other irregular characters. A more ideal construct to obtain the list would be to use the shell's globbing feature, like this:
for i in $PATHNAME/*; do
commands
done
while loop
The while construct allows for repetitive execution of a list of commands, as long as the command controlling the while loop executes successfully (exit status of zero). The syntax is:
while CONTROL-COMMAND; do CONSEQUENT-COMMANDS; done
CONTROL-COMMAND can be any command(s) that can exit with a success or failure status. The CONSEQUENT-COMMANDS can be any program, script or shell construct.
As soon as the CONTROL-COMMAND fails, the loop exits. In a script, the command following the done statement is executed.
The return status is the exit status of the last CONSEQUENT-COMMANDS command, or zero if none was executed.
Simple example using while
Here is an example for the impatient:
#!/bin/bash # This script opens 4 terminal windows. i="0" while [ $i -lt 4 ] do xterm & i=$[$i+1] done
Nested while loops
The example below was written to copy pictures that are made with a webcam to a web directory. Every five minutes a picture is taken. Every hour, a new directory is created, holding the images for that hour. Every day, a new directory is created containing 24 subdirectories. The script runs in the background.
#!/bin/bash
# This script copies files from my homedirectory into the webserver directory.
# (use scp and SSH keys for a remote directory)
# A new directory is created every hour.
PICSDIR=/home/carol/pics
WEBDIR=/var/www/carol/webcam
while true; do
DATE=`date +%Y%m%d`
HOUR=`date +%H`
mkdir $WEBDIR/"$DATE"
while [ $HOUR -ne "00" ]; do
DESTDIR=$WEBDIR/"$DATE"/"$HOUR"
mkdir "$DESTDIR"
mv $PICDIR/*.jpg "$DESTDIR"/
sleep 3600
HOUR=`date +%H`
done
done
Note the use of the true statement. This means: continue execution until we are forcibly interrupted (with kill or Ctrl+C).
This small script can be used for simulation testing; it generates files:
#!/bin/bash # This generates a file every 5 minutes while true; do touch pic-`date +%s`.jpg sleep 300 done
Note the use of the date command to generate all kinds of file and directory names. See the man page for more.
Use the system
The previous example is for the sake of demonstration. Regular checks can easily be achieved using the system's cron facility. Do not forget to redirect output and errors when using scripts that are executed from your crontab!
Using keyboard input to control the while loop
This script can be interrupted by the user when a Ctrl+C sequence is entered:
#!/bin/bash # This script provides wisdom FORTUNE=/usr/games/fortune while true; do echo "On which topic do you want advice?" cat << topics politics startrek kernelnewbies sports bofh-excuses magic love literature drugs education topics echo echo -n "Make your choice: " read topic echo echo "Free advice on the topic of $topic: " echo $FORTUNE $topic echo done
A here document is used to present the user with possible choices. And again, the true test repeats the commands from the CONSEQUENT-COMMANDS list over and over again.
Calculating an average
This script calculates the average of user input, which is tested before it is processed: if input is not within range, a message is printed. If q is pressed, the loop exits:
#!/bin/bash
# Calculate the average of a series of numbers.
SCORE="0"
AVERAGE="0"
SUM="0"
NUM="0"
while true; do
echo -n "Enter your score [0-100%] ('q' for quit): "; read SCORE;
if (("$SCORE" < "0")) || (("$SCORE" > "100")); then
echo "Be serious. Common, try again: "
elif [ "$SCORE" == "q" ]; then
echo "Average rating: $AVERAGE%."
break
else
SUM=$[$SUM + $SCORE]
NUM=$[$NUM + 1]
AVERAGE=$[$SUM / $NUM]
fi
done
echo "Exiting."
Note how the variables in the last lines are left unquoted in order to do arithmetic.
Variables
Bash variables are in uppercase characters by convention.
Apart from dividing variables in local and global variables, we can also divide them in categories according to the sort of content the variable contains. In this respect, variables come in 4 types:
-
String variables
-
Integer variables
-
Constant variables
-
Array variables
Normally, a variable can hold any type of data, unless variables are declared explicitly. Constant variables are set using the readonly built-in command.
An array holds a set of variables. If a type of data is declared, then all elements in the array will be set to hold only this type of data.
Bash features allow for substitution and transformation of variables "on the fly". Standard operations include calculating the length of a variable, arithmetic on variables, substituting variable content and substituting part of the content.
Types of variables
Bash understands many different kinds of variables or parameters. Thus far, we haven't bothered much with what kind of variables we assigned, so our variables could hold any value that we assigned to them. A simple command line example demonstrates this:
[bob in ~] VARIABLE=12 [bob in ~] echo $VARIABLE 12 [bob in ~] VARIABLE=string [bob in ~] echo $VARIABLE string
There are cases when you want to avoid this kind of behavior, for instance when handling telephone and other numbers. Apart from integers and variables, you may also want to specify a variable that is a constant. This is often done at the beginning of a script, when the value of the constant is declared. After that, there are only references to the constant variable name, so that when the constant needs to be changed, it only has to be done once. A variable may also be a series of variables of any type, a so-called array of variables (VAR0VAR1, VAR2, ... VARN).
Global variables
Global variables or environment variables are available in all shells. The env or printenv commands can be used to display environment variables. These programs come with the sh-utils package.
Below is a typical output:
franky ~> printenv CC=gcc CDPATH=.:~:/usr/local:/usr:/ CFLAGS=-O2 -fomit-frame-pointer COLORTERM=gnome-terminal CXXFLAGS=-O2 -fomit-frame-pointer DISPLAY=:0 DOMAIN=hq.garrels.be e= TOR=vi FCEDIT=vi FIGNORE=.o:~ G_BROKEN_FILENAMES=1 GDK_USE_XFT=1 GDMSESSION=Default GNOME_DESKTOP_SESSION_ID=Default GTK_RC_FILES=/etc/gtk/gtkrc:/nethome/franky/.gtkrc-1.2-gnome2 GWMCOLOR=darkgreen GWMTERM=xterm HISTFILESIZE=5000 history_control=ignoredups HISTSIZE=2000 HOME=/nethome/franky HOSTNAME=octarine.hq.garrels.be INPUTRC=/etc/inputrc IRCNAME=franky JAVA_HOME=/usr/java/j2sdk1.4.0 LANG=en_US LDFLAGS=-s LD_LIBRARY_PATH=/usr/lib/mozilla:/usr/lib/mozilla/plugins LESSCHARSET=latin1 LESS=-edfMQ LESSOPEN=|/usr/bin/lesspipe.sh %s LEX=flex LOCAL_MACHINE=octarine LOGNAME=franky LS_COLORS=no=00:fi=00:di=01;34:ln=01;36:pi=40;33:so=01;35:bd=40;33;01:cd=40;33;01:or=01;05;37;41:mi=01;05;37;41:ex=01;32:*.cmd=01;32:*.exe=01;32:*.com=01;32:*.btm=01;32:*.bat=01;32:*.sh=01;32:*.csh=01;32:*.tar=01;31:*.tgz=01;31:*.arj=01;31:*.taz=01;31:*.lzh=01;31:*.zip=01;31:*.z=01;31:*.Z=01;31:*.gz=01;31:*.bz2=01;31:*.bz=01;31:*.tz=01;31:*.rpm=01;31:*.cpio=01;31:*.jpg=01;35:*.gif=01;35:*.bmp=01;35:*.xbm=01;35:*.xpm=01;35:*.png=01;35:*.tif=01;35: MACHINES=octarine MAILCHECK=60 MAIL=/var/mail/franky MANPATH=/usr/man:/usr/share/man/:/usr/local/man:/usr/X11R6/man MEAN_MACHINES=octarine MOZ_DIST_BIN=/usr/lib/mozilla MOZILLA_FIVE_HOME=/usr/lib/mozilla MOZ_PROGRAM=/usr/lib/mozilla/mozilla-bin MTOOLS_FAT_COMPATIBILITY=1 MYMALLOC=0 NNTPPORT=119 NNTPSERVER=news NPX_PLUGIN_PATH=/plugin/ns4plugin/:/usr/lib/netscape/plugins OLDPWD=/nethome/franky OS=Linux PAGER=less PATH=/nethome/franky/bin.Linux:/nethome/franky/bin:/usr/local/bin:/usr/local/sbin:/usr/X11R6/bin:/usr/bin:/usr/sbin:/bin:/sbin:. PS1=\[\033[1;44m\]franky is in \w\[\033[0m\] PS2=More input> PWD=/nethome/franky SESSION_MANAGER=local/octarine.hq.garrels.be:/tmp/.ICE-unix/22106 SHELL=/bin/bash SHELL_LOGIN=--login SHLVL=2 SSH_AGENT_PID=22161 SSH_ASKPASS=/usr/libexec/openssh/gnome-ssh-askpass SSH_AUTH_SOCK=/tmp/ssh-XXmhQ4fC/agent.22106 START_WM=twm TERM=xterm TYPE=type USERNAME=franky USER=franky _=/usr/bin/printenv VISUAL=vi WINDOWID=20971661 XAPPLRESDIR=/nethome/franky/app-defaults XAUTHORITY=/nethome/franky/.Xauthority XENVIRONMENT=/nethome/franky/.Xdefaults XFILESEARCHPATH=/usr/X11R6/lib/X11/%L/%T/%N%C%S:/usr/X11R6/lib/X11/%l/%T/%N%C%S:/usr/X11R6/lib/X11/%T/%N%C%S:/usr/X11R6/lib/X11/%L/%T/%N%S:/usr/X11R6/lib/X11/%l/%T/%N%S:/usr/X11R6/lib/X11/%T/%N%S XKEYSYMDB=/usr/X11R6/lib/X11/XKeysymDB XMODIFIERS=@im=none XTERMID= XWINHOME=/usr/X11R6 X=X11R6 YACC=bison -y
Local variables
Local variables are only available in the current shell. Using the set built-in command without any options will display a list of all variables (including environment variables) and functions. The output will be sorted according to the current locale and displayed in a reusable format.
Below is a diff file made by comparing printenv and set output, after leaving out the functions which are also displayed by the set command:
franky ~> diff set.sorted printenv.sorted | grep "<" | awk '{ print $2 }'
BASE=/nethome/franky/.Shell/hq.garrels.be/octarine.aliases
BASH=/bin/bash
BASH_VERSINFO=([0]="2"
BASH_VERSION='2.05b.0(1)-release'
COLUMNS=80
DIRSTACK=()
DO_FORTUNE=
EUID=504
GROUPS=()
HERE=/home/franky
HISTFILE=/nethome/franky/.bash_history
HOSTTYPE=i686
IFS=$'
LINES=24
MACHTYPE=i686-pc-linux-gnu
OPTERR=1
OPTIND=1
OSTYPE=linux-gnu
PIPESTATUS=([0]="0")
PPID=10099
PS4='+
PWD_REAL='pwd
SHELLOPTS=braceexpand:emacs:hashall:histexpand:history:interactive-comments:monitor
THERE=/home/franky
UID=504
Creating variables
Variables are case sensitive and capitalized by default. Giving local variables a lowercase name is a convention which is sometimes applied. However, you are free to use the names you want or to mix cases. Variables can also contain digits, but a name starting with a digit is not allowed:
prompt> export 1number=1 bash: export: `1number=1': not a valid identifier
To set a variable in the shell, use
VARNAME="value"
Putting spaces around the equal sign will cause errors. It is a good habit to quote content strings when assigning values to variables: this will reduce the chance that you make errors.
Some examples using upper and lower cases, numbers and spaces:
franky ~> MYVAR1="2" franky ~> echo $MYVAR1 2 franky ~> first_name="Franky" franky ~> echo $first_name Franky franky ~> full_name="Franky M. Singh" franky ~> echo $full_name Franky M. Singh franky ~> MYVAR-2="2" bash: MYVAR-2=2: command not found franky ~> MYVAR1 ="2" bash: MYVAR1: command not found franky ~> MYVAR1= "2" bash: 2: command not found franky ~> unset MYVAR1 first_name full_name franky ~> echo $MYVAR1 $first_name $full_name <--no output--> franky ~>
Exporting variables
A variable created like the ones in the example above is only available to the current shell. It is a local variable: child processes of the current shell will not be aware of this variable. In order to pass variables to a subshell, we need to export them using the export built-in command. Variables that are exported are referred to as environment variables. Setting and exporting is usually done in one step:
export VARNAME="value"
A subshell can change variables it inherited from the parent, but the changes made by the child don't affect the parent. This is demonstrated in the example:
franky ~> full_name="Franky M. Singh" franky ~> bash franky ~> echo $full_name franky ~> exit franky ~> export full_name franky ~> bash franky ~> echo $full_name Franky M. Singh franky ~> export full_name="Charles the Great" franky ~> echo $full_name Charles the Great franky ~> exit franky ~> echo $full_name Franky M. Singh franky ~>
When first trying to read the value of full_name in a subshell, it is not there (echo shows a null string). The subshell quits, and full_name is exported in the parent - a variable can be exported after it has been assigned a value. Then a new subshell is started, in which the variable exported from the parent is visible. The variable is changed to hold another name, but the value for this variable in the parent stays the same.
Bourne shell reserved variables
Bash uses certain shell variables in the same way as the Bourne shell. In some cases, Bash assigns a default value to the variable. The table below gives an overview of these plain shell variables:
Reserved Bourne shell variables
| Variable name | Definition |
|---|---|
| CDPATH | A colon-separated list of directories used as a search path for the cd built-in command. |
| HOME | The current user's home directory; the default for the cd built-in. The value of this variable is also used by tilde expansion. |
| IFS | A list of characters that separate fields; used when the shell splits words as part of expansion. |
| If this parameter is set to a file name and the MAILPATH variable is not set, Bash informs the user of the arrival of mail in the specified file. | |
| MAILPATH | A colon-separated list of file names which the shell periodically checks for new mail. |
| OPTARG | The value of the last option argument processed by the getopts built-in. |
| OPTIND | The index of the last option argument processed by the getopts built-in. |
| PATH | A colon-separated list of directories in which the shell looks for commands. |
| PS1 | The primary prompt string. The default value is "'\s-\v\$ '". |
| PS2 | The secondary prompt string. The default value is "'> '". |
Bash reserved variables
These variables are set or used by Bash, but other shells do not normally treat them specially.
Table 3-2. Reserved Bash variables
| Variable name | Definition |
|---|---|
| auto_resume | This variable controls how the shell interacts with the user and job control. |
| BASH | The full pathname used to execute the current instance of Bash. |
| BASH_ENV | If this variable is set when Bash is invoked to execute a shell script, its value is expanded and used as the name of a startup file to read before executing the script. |
| BASH_VERSION | The version number of the current instance of Bash. |
| BASH_VERSINFO | A read-only array variable whose members hold version information for this instance of Bash. |
| COLUMNS | Used by the select built-in to determine the terminal width when printing selection lists. Automatically set upon receipt of a SIGWINCH signal. |
| COMP_CWORD | An index into ${COMP_WORDS} of the word containing the current cursor position. |
| COMP_LINE | The current command line. |
| COMP_POINT | The index of the current cursor position relative to the beginning of the current command. |
| COMP_WORDS | An array variable consisting of the individual words in the current command line. |
| COMPREPLY | An array variable from which Bash reads the possible completions generated by a shell function invoked by the programmable completion facility. |
| DIRSTACK | An array variable containing the current contents of the directory stack. |
| EUID | The numeric effective user ID of the current user. |
| FCEDIT | The editor used as a default by the -e option to the fc built-in command. |
| FIGNORE | A colon-separated list of suffixes to ignore when performing file name completion. |
| FUNCNAME | The name of any currently-executing shell function. |
| GLOBIGNORE | A colon-separated list of patterns defining the set of file names to be ignored by file name expansion. |
| GROUPS | An array variable containing the list of groups of which the current user is a member. |
| histchars | Up to three characters which control history expansion, quick substitution, and tokenization. |
| HISTCMD | The history number, or index in the history list, of the current command. |
| HISTCONTROL | Defines whether a command is added to the history file. |
| HISTFILE | The name of the file to which the command history is saved. The default value is ~/.bash_history. |
| HISTFILESIZE | The maximum number of lines contained in the history file, defaults to 500. |
| HISTIGNORE | A colon-separated list of patterns used to decide which command lines should be saved in the history list. |
| HISTSIZE | The maximum number of commands to remember on the history list, default is 500. |
| HOSTFILE | Contains the name of a file in the same format as /etc/hosts that should be read when the shell needs to complete a hostname. |
| HOSTNAME | The name of the current host. |
| HOSTTYPE | A string describing the machine Bash is running on. |
| IGNOREEOF | Controls the action of the shell on receipt of an EOF character as the sole input. |
| INPUTRC | The name of the Readline initialization file, overriding the default /etc/inputrc. |
| LANG | Used to determine the locale category for any category not specifically selected with a variable starting with LC_. |
| LC_ALL | This variable overrides the value of LANG and any other LC_ variable specifying a locale category. |
| LC_COLLATE | This variable determines the collation order used when sorting the results of file name expansion, and determines the behavior of range expressions, equivalence classes, and collating sequences within file name expansion and pattern matching. |
| LC_CTYPE | This variable determines the interpretation of characters and the behavior of character classes within file name expansion and pattern matching. |
| LC_MESSAGES | This variable determines the locale used to translate double-quoted strings preceded by a "$" sign. |
| LC_NUMERIC | This variable determines the locale category used for number formatting. |
| LINENO | The line number in the script or shell function currently executing. |
| LINES | Used by the select built-in to determine the column length for printing selection lists. |
| MACHTYPE | A string that fully describes the system type on which Bash is executing, in the standard GNU CPU-COMPANY-SYSTEM format. |
| MAILCHECK | How often (in seconds) that the shell should check for mail in the files specified in the MAILPATH or MAIL variables. |
| OLDPWD | The previous working directory as set by the cd built-in. |
| OPTERR | If set to the value 1, Bash displays error messages generated by the getopts built-in. |
| OSTYPE | A string describing the operating system Bash is running on. |
| PIPESTATUS | An array variable containing a list of exit status values from the processes in the most recently executed foreground pipeline (which may contain only a single command). |
| POSIXLY_CORRECT | If this variable is in the environment when bash starts, the shell enters POSIX mode. |
| PPID | The process ID of the shell's parent process. |
| PROMPT_COMMAND | If set, the value is interpreted as a command to execute before the printing of each primary prompt (PS1). |
| PS3 | The value of this variable is used as the prompt for the select command. Defaults to "'#? '" |
| PS4 | The value is the prompt printed before the command line is echoed when the -x option is set; defaults to "'+ '". |
| PWD | The current working directory as set by the cd built-in command. |
| RANDOM | Each time this parameter is referenced, a random integer between 0 and 32767 is generated. Assigning a value to this variable seeds the random number generator. |
| REPLY | The default variable for the read built-in. |
| SECONDS | This variable expands to the number of seconds since the shell was started. |
| SHELLOPTS | A colon-separated list of enabled shell options. |
| SHLVL | Incremented by one each time a new instance of Bash is started. |
| TIMEFORMAT | The value of this parameter is used as a format string specifying how the timing information for pipelines prefixed with the time reserved word should be displayed. |
| TMOUT | If set to a value greater than zero, TMOUT is treated as the default timeout for the read built-in. In an interative shell, the value is interpreted as the number of seconds to wait for input after issuing the primary prompt when the shell is interactive. Bash terminates after that number of seconds if input does not arrive. |
| UID | The numeric, real user ID of the current user. |
Check the Bash man, info or doc pages for extended information. Some variables are read-only, some are set automatically and some lose their meaning when set to a different value than the default.
Special parameters
The shell treats several parameters specially. These parameters may only be referenced; assignment to them is not allowed.
Special bash variables
| Character | Definition |
|---|---|
| $* | Expands to the positional parameters, starting from one. When the expansion occurs within double quotes, it expands to a single word with the value of each parameter separated by the first character of the IFS special variable. |
| $@ | Expands to the positional parameters, starting from one. When the expansion occurs within double quotes, each parameter expands to a separate word. |
| $# | Expands to the number of positional parameters in decimal. |
| $? | Expands to the exit status of the most recently executed foreground pipeline. |
| $- | A hyphen expands to the current option flags as specified upon invocation, by the set built-in command, or those set by the shell itself (such as the -i). |
| $$ | Expands to the process ID of the shell. |
| $! | Expands to the process ID of the most recently executed background (asynchronous) command. |
| $0 | Expands to the name of the shell or shell script. |
| $_ | The underscore variable is set at shell startup and contains the absolute file name of the shell or script being executed as passed in the argument list. Subsequently, it expands to the last argument to the previous command, after expansion. It is also set to the full pathname of each command executed and placed in the environment exported to that command. When checking mail, this parameter holds the name of the mail file. |
The implementation of "$*" has always been a problem and realistically should have been replaced with the behavior of "$@". In almost every case where coders use "$*", they mean "$@". "$*" Can cause bugs and even security holes in your software.
The positional parameters are the words following the name of a shell script. They are put into the variables $1, $2, $3 and so on. As long as needed, variables are added to an internal array. $# holds the total number of parameters, as is demonstrated with this simple script:
#!/bin/bash # positional.sh # This script reads 3 positional parameters and prints them out. POSPAR1="$1" POSPAR2="$2" POSPAR3="$3" echo "$1 is the first positional parameter, \$1." echo "$2 is the second positional parameter, \$2." echo "$3 is the third positional parameter, \$3." echo echo "The total number of positional parameters is $#."
Upon execution one could give any numbers of arguments:
franky ~> positional.sh one two three four five one is the first positional parameter, $1. two is the second positional parameter, $2. three is the third positional parameter, $3. The total number of positional parameters is 5. franky ~> positional.sh one two one is the first positional parameter, $1. two is the second positional parameter, $2. is the third positional parameter, $3. The total number of positional parameters is 2.
Some examples on the other special parameters:
franky ~> grep dictionary /usr/share/dict/words dictionary franky ~> echo $_ /usr/share/dict/words franky ~> echo $$ 10662 franky ~> mozilla & [1] 11064 franky ~> echo $! 11064 franky ~> echo $0 bash franky ~> echo $? 0 franky ~> ls doesnotexist ls: doesnotexist: No such file or directory franky ~> echo $? 1 franky ~>
User franky starts entering the grep command, which results in the assignment of the _ variable. The process ID of his shell is 10662. After putting a job in the background, the ! holds the process ID of the backgrounded job. The shell running is bash. When a mistake is made, ? holds an exit code different from 0 (zero).
Script recycling with variables
Apart from making the script more readable, variables will also enable you to faster apply a script in another environment or for another purpose. Consider the following example, a very simple script that makes a backup of franky's home directory to a remote server:
#!/bin/bash # This script makes a backup of my home directory. cd /home # This creates the archive tar cf /var/tmp/home_franky.tar franky > /dev/null 2>&1 # First remove the old bzip2 file. Redirect errors because this generates some if the archive # does not exist. Then create a new compressed file. rm /var/tmp/home_franky.tar.bz2 2> /dev/null bzip2 /var/tmp/home_franky.tar # Copy the file to another host - we have ssh keys for making this work without intervention. scp /var/tmp/home_franky.tar.bz2 bordeaux:/opt/backup/franky > /dev/null 2>&1 # Create a timestamp in a logfile. date >> /home/franky/log/home_backup.log echo backup succeeded >> /home/franky/log/home_backup.log
First of all, you are more likely to make errors if you name files and directories manually each time you need them. Secondly, suppose franky wants to give this script to carol, then carol will have to do quite some editing before she can use the script to back up her home directory. The same is true if franky wants to use this script for backing up other directories. For easy recycling, make all files, directories, usernames, servernames etcetera variable. Thus, you only need to edit a value once, without having to go through the entire script to check where a parameter occurs. This is an example:
#!/bin/bash
# This script makes a backup of my home directory.
# Change the values of the variables to make the script work for you:
BACKUPDIR=/home
BACKUPFILES=franky
TARFILE=/var/tmp/home_franky.tar
BZIPFILE=/var/tmp/home_franky.tar.bz2
SERVER=bordeaux
REMOTEDIR=/opt/backup/franky
LOGFILE=/home/franky/log/home_backup.log
cd $BACKUPDIR
# This creates the archive
tar cf $TARFILE $BACKUPFILES > /dev/null 2>&1
# First remove the old bzip2 file. Redirect errors because this generates some if the archive
# does not exist. Then create a new compressed file.
rm $BZIPFILE 2> /dev/null
bzip2 $TARFILE
# Copy the file to another host - we have ssh keys for making this work without intervention.
scp $BZIPFILE $SERVER:$REMOTEDIR > /dev/null 2>&1
# Create a timestamp in a logfile.
date >> $LOGFILE
echo backup succeeded >> $LOGFILE
Large directories and low bandwidth
The above is purely an example that everybody can understand, using a small directory and a host on the same subnet. Depending on your bandwidth, the size of the directory and the location of the remote server, it can take an awful lot of time to make backups using this mechanism. For larger directories and lower bandwidth, use rsync to keep the directories at both ends synchronized.
Using the declare built-in
Using a declare statement, we can limit the value assignment to variables.
The syntax for declare is the following:
declare OPTION(s) VARIABLE=value
The following options are used to determine the type of data the variable can hold and to assign it attributes:
Options to the declare built-in
| Option | Meaning |
|---|---|
| -a | Variable is an array. |
| -f | Use function names only. |
| -i | The variable is to be treated as an integer; arithmetic evaluation is performed when the variable is assigned a value. |
| -p | Display the attributes and values of each variable. When -p is used, additional options are ignored. |
| -r | Make variables read-only. These variables cannot then be assigned values by subsequent assignment statements, nor can they be unset. |
| -t | Give each variable the trace attribute. |
| -x | Mark each variable for export to subsequent commands via the environment. |
Using + instead of - turns off the attribute instead. When used in a function, declare creates local variables.
The following example shows how assignment of a type to a variable influences the value.
[bob in ~] declare -i VARIABLE=12 [bob in ~] VARIABLE=string [bob in ~] echo $VARIABLE 0 [bob in ~] declare -p VARIABLE declare -i VARIABLE="0"
Note that Bash has an option to declare a numeric value, but none for declaring string values. This is because, by default, if no specifications are given, a variable can hold any type of data:
[bob in ~] OTHERVAR=blah [bob in ~] declare -p OTHERVAR declare -- OTHERVAR="blah"
As soon as you restrict assignment of values to a variable, it can only hold that type of data. Possible restrictions are either integer, constant or array.
See the Bash info pages for information on return status.
Constants
In Bash, constants are created by making a variable read-only. The readonly built-in marks each specified variable as unchangeable. The syntax is:
readonly OPTION VARIABLE(s)
The values of these variables can then no longer be changed by subsequent assignment. If the -f option is given, each variable refers to a shell function. If -a is specified, each variable refers to an array of variables. If no arguments are given, or if -p is supplied, a list of all read-only variables is displayed. Using the -p option, the output can be reused as input.
The return status is zero, unless an invalid option was specified, one of the variables or functions does not exist, or -f was supplied for a variable name instead of for a function name.
[bob in ~] readonly TUX=penguinpower [bob in ~] TUX=Mickeysoft bash: TUX: readonly variable
Array variables
An array is a variable containing multiple values. Any variable may be used as an array. There is no maximum limit to the size of an array, nor any requirement that member variables be indexed or assigned contiguously. Arrays are zero-based: the first element is indexed with the number 0.
Indirect declaration is done using the following syntax to declare a variable:
ARRAY[INDEXNR]=value
The INDEXNR is treated as an arithmetic expression that must evaluate to a positive number.
Explicit declaration of an array is done using the declare built-in:
declare -a ARRAYNAME
A declaration with an index number will also be accepted, but the index number will be ignored. Attributes to the array may be specified using the declare and readonly built-ins. Attributes apply to all variables in the array; you can't have mixed arrays.
Array variables may also be created using compound assignments in this format:
ARRAY=(value1 value2 ... valueN)
Each value is then in the form of [indexnumber=]string. The index number is optional. If it is supplied, that index is assigned to it; otherwise the index of the element assigned is the number of the last index that was assigned, plus one. This format is accepted by declare as well. If no index numbers are supplied, indexing starts at zero.
Adding missing or extra members in an array is done using the syntax:
ARRAYNAME[indexnumber]=value
Remember that the read built-in provides the -a option, which allows for reading and assigning values for member variables of an array.
Dereferencing the variables in an array
In order to refer to the content of an item in an array, use curly braces. This is necessary, as you can see from the following example, to bypass the shell interpretation of expansion operators. If the index number is @ or *, all members of an array are referenced.
[bob in ~] ARRAY=(one two three)
[bob in ~] echo ${ARRAY[*]}
one two three
[bob in ~] echo $ARRAY[*]
one[*]
[bob in ~] echo ${ARRAY[2]}
three
[bob in ~] ARRAY[3]=four
[bob in ~] echo ${ARRAY[*]}
one two three four
Referring to the content of a member variable of an array without providing an index number is the same as referring to the content of the first element, the one referenced with index number zero.
Deleting array variables
The unset built-in is used to destroy arrays or member variables of an array:
[bob in ~] unset ARRAY[1]
[bob in ~] echo ${ARRAY[*]}
one three four
[bob in ~] unset ARRAY
[bob in ~] echo ${ARRAY[*]}
<--no output-->
Examples of arrays
Practical examples of the usage of arrays are hard to find. You will find plenty of scripts that don't really do anything on your system but that do use arrays to calculate mathematical series, for instance. And that would be one of the more interesting examples...most scripts just show what you can do with an array in an oversimplified and theoretical way.
The reason for this dullness is that arrays are rather complex structures. You will find that most practical examples for which arrays could be used are already implemented on your system using arrays, however on a lower level, in the C programming language in which most UNIX commands are written. A good example is the Bash history built-in command. Those readers who are interested might check the built-ins directory in the Bash source tree and take a look at fc.def, which is processed when compiling the built-ins.
Another reason good examples are hard to find is that not all shells support arrays, so they break compatibility.
After long days of searching, I finally found this example operating at an Internet provider. It distributes Apache web server configuration files onto hosts in a web farm:
#!/bin/bash
if [ $(whoami) != 'root' ]; then
echo "Must be root to run $0"
exit 1;
fi
if [ -z $1 ]; then
echo "Usage: $0 </path/to/httpd.conf>"
exit 1
fi
httpd_conf_new=$1
httpd_conf_path="/usr/local/apache/conf"
login=htuser
farm_hosts=(web03 web04 web05 web06 web07)
for i in ${farm_hosts[@]}; do
su $login -c "scp $httpd_conf_new ${i}:${httpd_conf_path}"
su $login -c "ssh $i sudo /usr/local/apache/bin/apachectl graceful"
done
exit 0
First two tests are performed to check whether the correct user is running the script with the correct arguments. The names of the hosts that need to be configured are listed in the array farm_hosts. Then all these hosts are provided with the Apache configuration file, after which the daemon is restarted. Note the use of commands from the Secure Shell suite, encrypting the connections to remote hosts.
Thanks, Eugene and colleague, for this contribution.
Dan Richter contributed the following example. This is the problem he was confronted with:
"...In my company, we have demos on our web site, and every week someone has to test all of them. So I have a cron job that fills an array with the possible candidates, uses date +%W to find the week of the year, and does a modulo operation to find the correct index. The lucky person gets notified by e-mail."
And this was his way of solving it:
#!/bin/bash
# This is get-tester-address.sh
#
# First, we test whether bash supports arrays.
# (Support for arrays was only added recently.)
#
whotest[0]='test' || (echo 'Failure: arrays not supported in this version of
bash.' && exit 2)
#
# Our list of candidates. (Feel free to add or
# remove candidates.)
#
wholist=(
'Bob Smith <bob@example.com>'
'Jane L. Williams <jane@example.com>'
'Eric S. Raymond <esr@example.com>'
'Larry Wall <wall@example.com>'
'Linus Torvalds <linus@example.com>'
)
#
# Count the number of possible testers.
# (Loop until we find an empty string.)
#
count=0
while [ "x${wholist[count]}" != "x" ]
do
count=$(( $count + 1 ))
done
#
# Now we calculate whose turn it is.
#
week=`date '+%W'` # The week of the year (0..53).
week=${week#0} # Remove possible leading zero.
let "index = $week % $count" # week modulo count = the lucky person
email=${wholist[index]} # Get the lucky person's e-mail address.
echo $email # Output the person's e-mail address.
This script is then used in other scripts, such as this one, which uses a here document:
email=`get-tester-address.sh` # Find who to e-mail.
hostname=`hostname` # This machine's name.
#
# Send e-mail to the right person.
#
mail $email -s '[Demo Testing]' <<EOF
The lucky tester this week is: $email
Reminder: the list of demos is here:
http://web.example.com:8080/DemoSites
(This e-mail was generated by $0 on ${hostname}.)
EOF
Length of a variable
Using the ${#VAR} syntax will calculate the number of characters in a variable. If VAR is "*" or "@", this value is substituted with the number of positional parameters or number of elements in an array in general. This is demonstrated in the example below:
[bob in ~] echo $SHELL
/bin/bash
[bob in ~] echo ${#SHELL}
9
[bob in ~] ARRAY=(one two three)
[bob in ~] echo ${#ARRAY}
3
Variable substitution
${VAR:-WORD}
If VAR is not defined or null, the expansion of WORD is substituted; otherwise the value of VAR is substituted:
[bob in ~] echo ${TEST:-test}
test
[bob in ~] echo $TEST
[bob in ~] export TEST=a_string
[bob in ~] echo ${TEST:-test}
a_string
[bob in ~] echo ${TEST2:-$TEST}
a_string
This form is often used in conditional tests, for instance in this one:
[ -z "${COLUMNS:-}" ] && COLUMNS=80
It is a shorter notation for
if [ -z "${COLUMNS:-}" ]; then
COLUMNS=80
fi
If the hyphen (-) is replaced with the equal sign (=), the value is assigned to the parameter if it does not exist:
[bob in ~] echo $TEST2
[bob in ~] echo ${TEST2:=$TEST}
a_string
[bob in ~] echo $TEST2
a_string
The following syntax tests the existence of a variable. If it is not set, the expansion of WORD is printed to standard out and non-interactive shells quit. A demonstration:
[bob in ~] cat vartest.sh
#!/bin/bash
# This script tests whether a variable is set. If not,
# it exits printing a message.
echo ${TESTVAR:?"There's so much I still wanted to do..."}
echo "TESTVAR is set, we can proceed."
[bob in testdir] ./vartest.sh
./vartest.sh: line 6: TESTVAR: There's so much I still wanted to do...
[bob in testdir] export TESTVAR=present
[bob in testdir] ./vartest.sh
present
TESTVAR is set, we can proceed.
Using "+" instead of the exclamation mark sets the variable to the expansion of WORD; if it does not exist, nothing happens.
Removing substrings
To strip a number of characters, equal to OFFSET, from a variable, use this syntax:
${VAR:OFFSET:LENGTH}
The LENGTH parameter defines how many characters to keep, starting from the first character after the offset point. If LENGTH is omitted, the remainder of the variable content is taken:
[bob in ~] export STRING="thisisaverylongname"
[bob in ~] echo ${STRING:4}
isaverylongname
[bob in ~] echo ${STRING:6:5}
avery
${VAR#WORD}
and
${VAR##WORD}
These constructs are used for deleting the pattern matching the expansion of WORD in VAR. WORD is expanded to produce a pattern just as in file name expansion. If the pattern matches the beginning of the expanded value of VAR, then the result of the expansion is the expanded value of VAR with the shortest matching pattern ("#") or the longest matching pattern (indicated with "##").
If VAR is * or @, the pattern removal operation is applied to each positional parameter in turn, and the expansion is the resultant list.
If VAR is an array variable subscribed with "*" or "@", the pattern removal operation is applied to each member of the array in turn, and the expansion is the resultant list. This is shown in the examples below:
[bob in ~] echo ${ARRAY[*]}
one two one three one four
[bob in ~] echo ${ARRAY[*]#one}
two three four
[bob in ~] echo ${ARRAY[*]#t}
one wo one hree one four
[bob in ~] echo ${ARRAY[*]#t*}
one wo one hree one four
[bob in ~] echo ${ARRAY[*]##t*}
one one one four
The opposite effect is obtained using "%" and "%%", as in this example below. WORD should match a trailing portion of string:
[bob in ~] echo $STRING
thisisaverylongname
[bob in ~] echo ${STRING%name}
thisisaverylong
Replacing parts of variable names
This is done using the
${VAR/PATTERN/STRING}
or
${VAR//PATTERN/STRING}
syntax. The first form replaces only the first match, the second replaces all matches of PATTERN with STRING:
[bob in ~] echo ${STRING/name/string}
thisisaverylongstring
More information can be found in the Bash info pages.
Functions
Shell functions are a way to group commands for later execution, using a single name for this group, or routine. The name of the routine must be unique within the shell or script. All the commands that make up a function are executed like regular commands. When calling on a function as a simple command name, the list of commands associated with that function name is executed. A function is executed within the shell in which it has been declared: no new process is created to interpret the commands.
Special built-in commands are found before shell functions during command lookup. The special built-ins are: break, :, ., continue, eval, exec, exit, export, readonly, return, set, shift, trap and unset.
Function syntax
Functions either use the syntax
function FUNCTION { COMMANDS; }
or
FUNCTION () { COMMANDS; }
Both define a shell function FUNCTION. The use of the built-in command function is optional; however, if it is not used, parentheses are needed.
The commands listed between curly braces make up the body of the function. These commands are executed whenever FUNCTION is specified as the name of a command. The exit status is the exit status of the last command executed in the body.
Common mistakes
The curly braces must be separated from the body by spaces, otherwise they are interpreted in the wrong way.
The body of a function should end in a semicolon or a newline.
Positional parameters in functions
Functions are like mini-scripts: they can accept parameters, they can use variables only known within the function (using the local shell built-in) and they can return values to the calling shell.
A function also has a system for interpreting positional parameters. However, the positional parameters passed to a function are not the same as the ones passed to a command or script.
When a function is executed, the arguments to the function become the positional parameters during its execution. The special parameter # that expands to the number of positional parameters is updated to reflect the change. Positional parameter 0 is unchanged. The Bash variable FUNCNAME is set to the name of the function, while it is executing.
If the return built-in is executed in a function, the function completes and execution resumes with the next command after the function call. When a function completes, the values of the positional parameters and the special parameter # are restored to the values they had prior to the function's execution. If a numeric argument is given to return, that status is returned. A simple example:
[lydia@cointreau ~/test] cat showparams.sh
#!/bin/bash
echo "This script demonstrates function arguments."
echo
echo "Positional parameter 1 for the script is $1."
echo
test ()
{
echo "Positional parameter 1 in the function is $1."
RETURN_VALUE=$?
echo "The exit code of this function is $RETURN_VALUE."
}
test other_param
[lydia@cointreau ~/test] ./showparams.sh parameter1
This script demonstrates function arguments.
Positional parameter 1 for the script is parameter1.
Positional parameter 1 in the function is other_param.
The exit code of this function is 0.
[lydia@cointreau ~/test]
Note that the return value or exit code of the function is often storen in a variable, so that it can be probed at a later point. The init scripts on your system often use the technique of probing the RETVAL variable in a conditional test, like this one:
if [ $RETVAL -eq 0 ]; then
<start the daemon>
Or like this example from the /etc/init.d/amd script, where Bash's optimization features are used:
[ $RETVAL = 0 ] && touch /var/lock/subsys/amd
The commands after && are only executed when the test proves to be true; this is a shorter way to represent an if/then/fi structure.
The return code of the function is often used as exit code of the entire script. You'll see a lot of initscripts ending in something like exit $RETVAL.
Displaying functions
All functions known by the current shell can be displayed using the set built-in without options. Functions are retained after they are used, unless they are unset after use. The which command also displays functions:
[lydia@cointreau ~] which zless
zless is a function
zless ()
{
zcat "$@" | "$PAGER"
}
[lydia@cointreau ~] echo $PAGER
less
This is the sort of function that is typically configured in the user's shell resource configuration files. Functions are more flexible than aliases and provide a simple and easy way of adapting the user environment.
Here's one for DOS users:
dir ()
{
ls -F --color=auto -lF --color=always "$@" | less -r
}
Recycling functions
There are plenty of scripts on your system that use functions as a structured way of handling series of commands. On some Linux systems, for instance, you will find the /etc/rc.d/init.d/functions definition file, which is sourced in all init scripts. Using this method, common tasks such as checking if a process runs, starting or stopping a daemon and so on, only have to be written once, in a general way. If the same task is needed again, the code is recycled.
You could make your own /etc/functions file that contains all functions that you use regularly on your system, in different scripts. Just put the line
. /etc/functions
somewhere at the start of the script and you can recycle functions.
Function - Setting the path
This section might be found in your /etc/profile file. The function pathmunge is defined and then used to set the path for the root and other users:
pathmunge () {
if ! echo $PATH | /bin/egrep -q "(^|:)$1($|:)" ; then
if [ "$2" = "after" ] ; then
PATH=$PATH:$1
else
PATH=$1:$PATH
fi
fi
}
# Path manipulation
if [ `id -u` = 0 ]; then
pathmunge /sbin
pathmunge /usr/sbin
pathmunge /usr/local/sbin
fi
pathmunge /usr/X11R6/bin after
unset pathmunge
The function takes its first argument to be a path name. If this path name is not yet in the current path, it is added. The second argument to the function defines if the path will be added in front or after the current PATH definition.
Normal users only get /usr/X11R6/bin added to their paths, while root gets a couple of extra directories containing system commands. After being used, the function is unset so that it is not retained.
Common shell features
The following features are standard in almost every shell. Note that the stop, suspend, jobs, bg and fg commands are only available on systems that support job control.
| Command | Meaning |
|---|---|
| > | Redirect output |
| >> | Append to file |
| < | Redirect input |
| << | "Here" document (redirect input) |
| | | Pipe output |
| & | Run process in background. |
| ; | Separate commands on same line |
| * | Match any character(s) in filename |
| ? | Match single character in filename |
| [ ] | Match any characters enclosed |
| ( ) | Execute in subshell |
| ` ` | Substitute output of enclosed command |
| " " | Partial quote (allows variable and command expansion) |
| ' ' | Full quote (no expansion) |
| \ | Quote following character |
| $var | Use value for variable |
| $$ | Process id |
| $0 | Command name |
| $n | nth argument (n from 0 to 9) |
| # | Begin comment |
| bg | Background execution |
| break | Break from loop statements |
| cd | Change directories |
| continue | Resume a program loop |
| echo | Display output |
| eval | Evaluate arguments |
| exec | Execute a new shell |
| fg | Foreground execution |
| jobs | Show active jobs |
| kill | Terminate running jobs |
| newgrp | Change to a new group |
| shift | Shift positional parameters |
| stop | Suspend a background job |
| suspend | Suspend a foreground job |
| time | Time a command |
| umask | Set or list file permissions |
| unset | Erase variable or function definitions |
| wait | Wait for a background job to finish |
Differing shell features
The table below shows major differences between the standard shell (sh), Bourne Again SHell (bash), Korn shell (ksh) and the C shell (csh).
Shell compatibility
Since the Bourne Again SHell is a superset of sh, all sh commands will also work in bash - but not vice versa. bash has many more features of its own, and, as the table below demonstrates, many features incorporated from other shells.
Since the Turbo C shell is a superset of csh, all csh commands will work in tcsh, but not the other way round.
| sh | bash | ksh | csh | Meaning/Action |
|---|---|---|---|---|
| $ | $ | $ | % | Default user prompt |
| >| | >| | >! | Force redirection | |
| > file 2>&1 | &> file or > file 2>&1 | > file 2>&1 | >& file | Redirect stdout and stderr to file |
| { } | { } | Expand elements in list | ||
| `command` | `command` or $(command) | $(command) | `command` | Substitute output of enclosed command |
| $HOME | $HOME | $HOME | $home | Home directory |
| ~ | ~ | ~ | Home directory symbol | |
| ~+, ~-, dirs | ~+, ~- | =-, =N | Access directory stack | |
| var=value | VAR=value | var=value | set var=value | Variable assignment |
| export var | export VAR=value | export var=val | setenv var val | Set environment variable |
| ${nnnn} | ${nn} | More than 9 arguments can be referenced | ||
| "$@" | "$@" | "$@" | All arguments as separate words | |
| $# | $# | $# | $#argv | Number of arguments |
| $? | $? | $? | $status | Exit status of the most recently executed command |
| $! | $! | $! | PID of most recently backgrounded process | |
| $- | $- | $- | Current options | |
| . file | source file or . file | . file | source file | Read commands in file |
| alias x='y' | alias x=y | alias x y | Name x stands for command y | |
| case | case | case | switch or case | Choose alternatives |
| done | done | done | end | End a loop statement |
| esac | esac | esac | endsw | End case or switch |
| exit n | exit n | exit n | exit (expr) | Exit with a status |
| for/do | for/do | for/do | foreach | Loop through variables |
| set -f, set -o
nullglob|dotglob |nocaseglob|noglob |
noglob | Ignore substitution characters for filename generation | ||
| hash | hash | alias -t | hashstat | Display hashed commands (tracked aliases) |
| hash cmds | hash cmds | alias -t cmds | rehash | Remember command locations |
| hash -r | hash -r | unhash | Forget command locations | |
| history | history | history | List previous commands | |
| ArrowUp+Enter or !! | r | !! | Redo previous command | |
| !str | r str | !str | Redo last command that starts with "str" | |
| !cmd:s/x/y/ | r x=y cmd | !cmd:s/x/y/ | Replace "x" with "y" in most recent command starting with "cmd", then execute. | |
| if [ $i -eq 5 ] | if [ $i -eq 5 ] | if ((i==5)) | if ($i==5) | Sample condition test |
| fi | fi | fi | endif | End if statement |
| ulimit | ulimit | ulimit | limit | Set resource limits |
| pwd | pwd | pwd | dirs | Print working directory |
| read | read | read | $< | Read from terminal |
| trap 2 | trap 2 | trap 2 | onintr | Ignore interrupts |
| unalias | unalias | unalias | Remove aliases | |
| until | until | until | Begin until loop | |
| while/do | while/do | while/do | while | Begin while loop |
The Bourne Again SHell has many more features not listed here. This table is just to give you an idea of how this shell incorporates all useful ideas from other shells: there are no blanks in the column for bash. More information on features found only in Bash can be retrieved from the Bash info pages, in the "Bash Features" section.
Financial Opportunity
Personal Opportunity - Free software gives you access to billions of dollars of software at no cost. Use this software for your business, personal use or to develop a profitable skill. Access to source code provides access to a level of capabilities/information that companies protect though copyrights. Open source is a core component of the Internet and it is available to you. Leverage the billions of dollars in resources and capabilities to build a career, establish a business or change the world. The potential is endless for those who understand the opportunity.
Business Opportunity - Goldman Sachs, IBM and countless large corporations are leveraging open source to reduce costs, develop products and increase their bottom lines. Learn what these companies know about open source and how open source can give you the advantage.
U.S. Government - On January 20 2009, President Obama's first day in office, the Open Government initiative was issued to provide transparency and access to Government data. Learn how our Government is using open source and the opportunities this provides for you. Leverage Use open Government data or
Free Books
The Free Books Library is a collection of thousands of the most popular public domain books in an online readable format. The collection includes great classical literature and more recent works where the U.S. copyright has expired. These books are yours to read and use without restrictions.
The Library of History by Diodorus the Sicilian is one of the most highly regarded universal histories in antiquities. His work includes the history of Egypt, Asia, Africa, Greece and Europe. His book is a must read for research of ancient history.
The Histories of Herodotus written in 440 BC is considered to be the founding work of history in Western literature. His history included stories and fables but he claimed to have traveled extensively and learned about many countries through direct observation.
The thesis of Stolen Legacy is that the Egyptians created what is wrongly called Greek philosophy. Dr. James argues that the African origin of Greek Philosophy is well known but rarely discussed. Ancient Greek historians such as Herodotus and Diodorus the Sicilian wrote in significant detail about the contributions of Egypt. Egyptian technology and libraries were unmatched and Greek philosophers such as Pythagoras and Plato studied there. The contribution of Africa to the intellectual foundation of modern knowledge is tremendous but unacknowledged.
Bible Study The King James Bible (kjv), World English Bible (web) and Bible in Basic English (bbe) are all examples of public domain books. The King James Bible (kjv) online uses the content from these books and open source software to enhance Bible study capabilities. The site includes the verse of the day, search tools, christian literature and links to related content. It demonstrates the use of open source to create a valuable service.
Free Software
Free Software provides computer programs and capabilities at no cost but more importantly, it provides the freedom to run, edit, contribute to, and share the software. The importance of free software is a matter of access, not price. Software at no cost is a benefit but ownership rights to the software and source code is far more significant.
Free Office Software - The Libre Office suite provides top desktop productivity tools for free. This includes, a word processor, spreadsheet, presentation engine, drawing and flowcharting, database and math applications. Libre Office is available for Linux or Windows.
Linux is an open source computer operating system (OS) used on laptops, games, watches and super computers. The software and the source code used for Linux are both available to you at no cost. Use this powerful resource to your advantage.
Source Code - Want to change a program or know how it works? Open Source provides the source code for its programs so that anyone can use, modify or learn how to write those programs themselves. Visit the GNU source code repositories to download the source.
Educational Materials
Study at Harvard, Stanford or MIT - Open edX provides free online courses from Harvard, MIT, Columbia, UC Berkeley and other top Universities. Hundreds of courses for almost all major subjects and course levels. Open edx also offers some paid courses and selected certifications.
Linux Manual Pages - A man or manual page is a form of software documentation found on Linux/Unix operating systems. Topics covered include computer programs (including library and system calls), formal standards and conventions, and even abstract concepts.
