Go to the next chapter.

Bash contains features that appear in other popular shells, and some features that only appear in Bash. Some of the shells that Bash has borrowed concepts from are the Bourne Shell (sh), the Korn Shell (ksh), and the C-shell (csh and its successor, tcsh). The following menu breaks the features up into categories based upon which one of these other shells inspired the feature.

This manual is meant as a brief introduction to features found in Bash. The Bash manual page should be used as the definitive reference on shell behavior.

• Bourne Shell Features: Features originally found in the Bourne shell.
• Csh Features: Features originally found in the Berkeley C-Shell.
• Korn Shell Features: Features originally found in the Korn Shell.
• Bash Specific Features: Features found only in Bash.
• Job Control: A chapter describing what job control is and how bash allows you to use it.

  rules.

  editing features.

• Variable Index: Quick reference helps you find the variable you want.
• Concept Index: General index for this manual.

Bourne Shell Style Features

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, and the rules for evaluation and quoting are taken from the Posix 1003.2 specification for the `standard' Unix shell.

This section briefly summarizes things which Bash inherits from the Bourne shell: shell control structures, builtins, variables, and other features. It also lists the significant differences between Bash and the Bourne Shell.

• Looping Constructs: Shell commands for iterative action.
• Conditional Constructs: Shell commands for conditional execution.
• Shell Functions: Grouping commands by name.
• Bourne Shell Builtins: Builtin commands inherited from the Bourne Shell.
• Bourne Shell Variables: Variables which Bash uses in the same way as the Bourne Shell.
• Other Bourne Shell Features: Addtional aspects of Bash which behave in the same way as the Bourne Shell.

Looping Constructs

Note that wherever you see a ; in the description of a command's syntax, it may be replaced indiscriminately with one or more newlines.

Bash supports the following looping constructs.

until The syntax of the until command is:

until test-commands; do consequent-commands; done

Execute consequent-commands as long as the final command in test-commands has an exit status which is not zero.

while The syntax of the while command is:

while test-commands; do consequent-commands; done

Execute consequent-commands as long as the final command in test-commands has an exit status of zero.

for The syntax of the for command is:

for name [in words ...]; do commands; done

Execute commands for each member in words, with name bound to the current member. If ``in words'' is not present, ``in "$@"'' is assumed.

Conditional Constructs

if The syntax of the if command is:

	if test-commands; then
  	   consequent-commands;
	[elif more-test-commands; then
  	   more-consequents;]
	[else alternate-consequents;]
	fi

Execute consequent-commands only if the final command in test-commands has an exit status of zero. Otherwise, each elif list is executed in turn, and if its exit status is zero, the corresponding more-consequents is executed and the command completes. If ``else alternate-consequents'' is present, and the final command in the final if or elif clause has a non-zero exit status, then execute alternate-consequents.

case The syntax of the case command is:

case word in [pattern [| pattern]...) commands ;;]... esac

Selectively execute commands based upon word matching pattern. The `|' is used to separate multiple patterns.

Here is an example using case in a script that could be used to describe an interesting feature of an animal:

	echo -n "Enter the name of an animal: "
	read ANIMAL
	echo -n "The $ANIMAL has "
	case $ANIMAL in
	  horse | dog | cat) echo -n "four";;
	  man | kangaroo ) echo -n "two";;
	  *) echo -n "an unknown number of";;
	esac
	echo "legs."

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. Shell functions are executed in the current shell context; no new process is created to interpret them.

Functions are declared using this syntax:

[ function ] name () { command-list; }

This defines a function named name. The body of the function is the command-list between { and }. This list is executed whenever name is specified as the name of a command. The exit status of a function is the exit status of the last command executed in the body.

When a function is executed, the arguments to the function become the positional parameters during its execution. The special parameter # that gives the number of positional parameters is updated to reflect the change. Positional parameter 0 is unchanged.

If the builtin command return 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 function execution.

Bourne Shell Builtins

The following shell builtin commands are inherited from the Bourne shell. These commands are implemented as specified by the Posix 1003.2 standard.

• : Do nothing beyond expanding any arguments and performing redirections.
• . Read and execute commands from the filename argument in the current shell context.
• break Exit from a for, while, or until loop.
• cd Change the current working directory.
• continue Resume the next iteration of an enclosing for, while, or until loop.
• echo Print the arguments, separated by spaces, to the standard output.
• eval The arguments are concatenated together into a single command, which is then read and executed.
• exec If a command argument is supplied, it replaces the shell. If no command is specified, redirections may be used to affect the current shell environment.
• exit Exit the shell.
• export Mark the arguments as variables to be passed to child processes in the environment.
• getopts Parse options to shell scripts or functions.
• hash Remember the full pathnames of commands specified as arguments, so they need not be searched for on subsequent invocations.
• kill Send a signal to a process.
• pwd Print the current working directory.
• read Read a line from the shell input and use it to set the values of specified variables.
• readonly Mark variables as unchangable.
• return Cause a shell function to exit with a specified value.
• shift Shift positional parameters to the left.
• test
• [ Evaluate a conditional expression.
• times Print out the user and system times used by the shell and its children.
• trap Specify commands to be executed when the shell receives signals.
• umask Set the shell process's file creation mask.
• unset Cause shell variables to disappear.
• wait Wait until child processes exit and report their exit status.

Bourne Shell 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.

• IFS A list of characters that separate fields; used when the shell splits words as part of expansion.
• PATH A colon-separated list of directories in which the shell looks for commands.
• HOME The current user's home directory.
• CDPATH A colon-separated list of directories used as a search path for the cd command.
• MAILPATH A colon-separated list of files which the shell periodically checks for new mail. You can also specify what message is printed by separating the file name from the message with a ?. When used in the text of the message, $_ stands for the name of the current mailfile.
• PS1 The primary prompt string.
• PS2 The secondary prompt string.
• OPTIND The index of the last option processed by the getopts builtin.
• OPTARG The value of the last option argument processed by the getopts builtin.

Other Bourne Shell Features

• Major Differences from the Bourne Shell: Major differences between Bash and the Bourne shell.

Bash implements essentially the same grammar, parameter and variable expansion, redirection, and quoting as the Bourne Shell. Bash uses the Posix 1003.2 standard as the specification of how these features are to be implemented. There are some differences between the traditional Bourne shell and the Posix standard; this section quickly details the differences of significance. A number of these differences are explained in greater depth in subsequent sections.

Major Differences from the Bourne Shell

Bash implements the ! keyword to negate the return value of a pipeline. Very useful when an if statement needs to act only if a test fails.

Bash includes brace expansion (see section Brace Expansion).

Bash includes the Posix and ksh-style pattern removal %% and ## constructs to remove leading or trailing substrings from variables.

The Posix and ksh-style $() form of command substitution is implemented, and preferred to the Bourne shell's `` (which is also implemented for backwards compatibility).

Variables present in the shell's initial environment are automatically exported to child processes. The Bourne shell does not normally do this unless the variables are explicitly marked using the export command.

The expansion ${#xx}, which returns the length of $xx, is supported.

The IFS variable is used to split only the results of expansion, not all words. This closes a longstanding shell security hole.

It is possible to have a variable and a function with the same name; sh does not separate the two name spaces.

Bash functions are permitted to have local variables, and thus useful recursive functions may be written.

The noclobber option is available to avoid overwriting existing files with output redirection.

Bash allows you to write a function to override a builtin, and provides access to that builtin's functionality within the function via the builtin and command builtins.

The command builtin allows selective disabling of functions when command lookup is performed.

Individual builtins may be enabled or disabled using the enable builtin.

Functions may be exported to children via the environment.

The Bash read builtin will read a line ending in \ with the -r option, and will use the $REPLY variable as a default if no arguments are supplied.

The return builtin may be used to abort execution of scripts executed with the . or source builtins.

The umask builtin allows symbolic mode arguments similar to those accepted by chmod.

The test builtin is slightly different, as it implements the Posix 1003.2 algorithm, which specifies the behavior based on the number of arguments.

Ready-to-Run Software, Inc Privacy Statement

Portions (c)Copyright, 1996-2005 by Ready-to-Run Software, Inc
(All rights reserved.)
212 Cedar Cove
Lansing, NY 14882
Phone: 607 533 UNIX (8649)
Fax: 607 533 4002