Other Bourne Shell Features

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 Bash; 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 SVR4.2 Bourne Shell

• POSIX-conformant, even where the POSIX specification differs from traditional sh behavior.
• multi-character invocation options (see section Invoking Bash).
• command-line editing (see section Command Line Editing) and the bind builtin.
• command history (see section Bash History Facilities) and the history and fc builtins to manipulate it.
• csh-like history expansion (see section History Expansion).
• one-dimensional array variables (see section Arrays), and the appropriate variable expansions and assignment syntax to use them. Several of the Bash builtins take options to act on arrays. Bash provides a number of built-in array variables.
• The $'...' quoting syntax, which expands ANSI-C backslash-escaped characters in the text between the single quotes, is supported (see section ANSI-C Quoting).
• $"..." quoting syntax to do locale-specific translation of the characters between the double quotes. The -D, --dump-strings, and --dump-po-strings invocation options list the translatable strings found in a script (see section Locale-Specific Translation).
• ! keyword to negate the return value of a pipeline (see section Pipelines). Very useful when an if statement needs to act only if a test fails.
• time reserved word and command timing (see section Pipelines). The display of the timing statistics may be controlled with the TIMEFORMAT variable.
• select compound command, which allows the generation of simple menus (see section Conditional Constructs).
• [[ compound command, which makes conditional testing part of the shell grammar (see section Conditional Constructs).
• brace expansion (see section Brace Expansion) and tilde expansion (see section Tilde Expansion).
• command aliases and the alias and unalias builtins (see section Aliases).
• shell arithmetic, the (( compound command (see section Conditional Constructs), and arithmetic expansion (see section Shell Arithmetic).
• 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.
• POSIX pattern removal %, #, %% and ## expansions to remove leading or trailing substrings from variable values (see section Shell Parameter Expansion).
• The expansion ${#xx}, which returns the length of ${xx}, is supported (see section Shell Parameter Expansion).
• The expansion CODE>${var:offset[:length]}, which expands to the substring of var's value of length length, beginning at offset, is present (see section Shell Parameter Expansion).
• The expansion ${var/[/]pattern[/replacement]}, which matches pattern and replaces it with replacement in the value of var, is available (see section Shell Parameter Expansion).
• indirect variable expansion using ${!word} (see section Shell Parameter Expansion).
• expands positional parameters beyond $9 using ${num}.
• The POSIX $() form of command substitution is implemented (see section Command Substitution), and preferred to the Bourne shell's " (which is also implemented for backwards compatibility).
• process substitution (see section Process Substitution).
• automatically assigns variables that provide information about the current user (UID, EUID, and GROUPS), the current host (HOSTTYPE, OSTYPE, MACHTYPE, and HOSTNAME), and the instance of Bash that is running (BASH, BASH_VERSION, and BASH_VERSINFO). See section Bash Variables, for details.
• The IFS variable is used to split only the results of expansion, not all words (see section Word Splitting). This closes a longstanding shell security hole.
• full set of POSIX.2 filename expansion operators, including character classes, equivalence classes, and collating symbols (see section Filename Expansion).
• extended pattern matching features when the extglob shell option is enabled (see section Pattern Matching).
• It is possible to have a variable and a function with the same name; sh does not separate the two name spaces.
• functions are permitted to have local variables using the local builtin, and thus useful recursive functions may be written.
• Variable assignments preceding commands affect only that command, even builtins and functions (see section Environment). In sh, all variable assignments preceding commands are global unless the command is executed from the file system.
• filename expansion on filenames specified as operands to input and output redirection operators.
• <> redirection operator, allowing a file to be opened for both reading and writing, and the &> redirection operator, for directing standard output and standard error to the same file (see section Redirections).
• The noclobber option is available to avoid overwriting existing files with output redirection (see section The Set Builtin). The >| redirection operator may be used to override noclobber.
• cd and pwd builtins (see section Bourne Shell Builtins) each take -L and -P builtins to switch between logical and physical modes.
• function to override a builtin with the same name, and provides access to that builtin's functionality within the function via the builtin and command builtins (see section Bash Builtin Commands).
• The command builtin allows selective disabling of functions when command lookup is performed (see section Bash Builtin Commands).
• Individual builtins may be enabled or disabled using the enable builtin (see section Bash Builtin Commands).
• exec builtin takes additional options that allow users to control the contents of the environment passed to the executed command, and what the zeroth argument to the command is to be (see section Bourne Shell Builtins).
• Shell functions may be exported to children via the environment using export -f (see section Shell Functions).
• export, readonly, and declare builtins can take a -f option to act on shell functions, a -p option to display variables with various attributes set in a format that can be used as shell input, a -n option to remove various variable attributes, and name=value arguments to set variable attributes and values simultaneously.
• hash builtin allows a name to be associated with an arbitrary filename, even when that filename cannot be found by searching the $PATH, using hash -p (see section Bourne Shell Builtins).
• help builtin for quick reference to shell facilities (see section Bash Builtin Commands).
• The printf builtin is available to display formatted output (see section Bash Builtin Commands).
• The Bash read builtin (see section Bash Builtin Commands) 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 Bash read builtin also accepts a prompt string with the -p option and will use Readline to obtain the line when given the -e option.
• The return builtin may be used to abort execution of scripts executed with the . or source builtins (see section Bourne Shell Builtins).
• shopt builtin, for finer control of shell optional capabilities (see section Bash Builtin Commands).
• more optional behavior controllable with the set builtin (see section The Set Builtin).
• test builtin (see section Bourne Shell Builtins) is slightly different, as it implements the POSIX algorithm, which specifies the behavior based on the number of arguments.
• trap builtin (see section Bourne Shell Builtins) allows a DEBUG pseudo-signal specification, similar to EXIT. Commands specified with a DEBUG trap are executed after every simple command. The DEBUG trap is not inherited by shell functions.
• type builtin is more extensive and gives more information about the names it finds (see section Bash Builtin Commands).
• umask builtin permits a -p option to cause the output to be displayed in the form of a umask command that may be reused as input (see section Bourne Shell Builtins).
• csh-like directory stack, and provides the pushd, popd, and dirs builtins to manipulate it (see section The Directory Stack). Bash also makes the directory stack visible as the value of the DIRSTACK shell variable.
• special backslash-escaped characters in the prompt strings when interactive (see section Controlling the Prompt).
• restricted mode is more useful (see section The Restricted Shell); the SVR4.2 shell restricted mode is too limited.
• disown builtin can remove a job from the internal shell job table (see section Job Control Builtins) or suppress the sending of SIGHUP to a job when the shell exits as the result of a SIGHUP.
• The SVR4.2 shell has two privilege-related builtins (mldmode and priv) not present in Bash.
• Bash does not have the stop or newgrp builtins.
• Bash does not use the SHACCT variable or perform shell accounting.
• The SVR4.2 sh uses a TIMEOUT variable like Bash uses TMOUT.

More features unique to Bash may be found in section Bash Features.

Implementation Differences From The SVR4.2 Shell

Since Bash is a completely new implementation, it does not suffer from many of the limitations of the SVR4.2 shell. For instance:

• Bash does not fork a subshell when redirecting into or out of a shell control structure such as an if or while statement.
• Bash does not allow unbalanced quotes. The SVR4.2 shell will silently insert a needed closing quote at EOF under certain circumstances. This can be the cause of some hard-to-find errors.
• The SVR4.2 shell uses a baroque memory management scheme based on trapping SIGSEGV. If the shell is started from a process with SIGSEGV blocked (e.g., by using the system() C library function call), it misbehaves badly.
• In a questionable attempt at security, the SVR4.2 shell, when invoked without the -p option, will alter its real and effective UID and GID if they are less than some magic threshold value, commonly 100. This can lead to unexpected results.
• The SVR4.2 shell does not allow users to trap SIGSEGV, SIGALRM, or SIGCHLD.
• The SVR4.2 shell does not allow the IFS, MAILCHECK, PATH, PS1, or PS2 variables to be unset.
• The SVR4.2 shell treats ^ as the undocumented equivalent of |.
• Bash allows multiple option arguments when it is invoked (-x -v); the SVR4.2 shell allows only one option argument (-xv). In fact, some versions of the shell dump core if the second argument begins with a -.
• The SVR4.2 shell exits a script if any builtin fails; Bash exits a script only if one of the POSIX.2 special builtins fails, and only for certain failures, as enumerated in the POSIX.2 standard.
• The SVR4.2 shell behaves differently when invoked as jsh (it turns on job control).

This section briefly summarizes things which Bash inherits from the Bourne Shell: builtins, variables, and other features. It also lists the significant differences between Bash and the Bourne Shell. Many of the builtins have been extended by POSIX or Bash.

Go to the first, previous,