Bash

From Christoph's Personal Wiki
Revision as of 01:19, 25 May 2007 by Christoph (Talk | contribs) (→‎External links)

Jump to: navigation, search
The correct title of this article is bash. The initial letter is capitalized due to technical restrictions.

Bash is a Linux command shell written for the GNU project. Its name is an acronym for Bourne-again shell—a pun on the Bourne shell (sh), which was an early, important Unix shell. Bash is the default shell on most Linux systems and my favourite shell.

Bash builtins

A shell builtin is a command or a function, called from a shell, that is executed directly in the shell itself, instead of an external executable program which the shell would load and execute.

Shell builtins work significantly faster than external programs, because there is no program loading overhead. However, their code is inherently present in the shell, and thus modifying or updating them requires modifications to the shell. Therefore shell builtins are usually used for simple, almost trivial, functions, such as text output. Because of the nature of Linux, some functions of the operating system have to be implemented as shell builtins. The most notable example is cd, which changes the working directory of the shell. Because each executable program runs in a separate process, and working directories are specific to each process, loading cd as an external program would not affect the working directory of the shell that loaded it. 

bash, :, ., [, alias, bg, bind, break, builtin, cd, command, compgen,
complete, continue, declare, dirs, disown, echo, enable, eval, exec,
exit, export, fc, fg, getopts, hash, help, history, jobs, kill, let,
local, logout, popd, printf, pushd, pwd, read, readonly, return, set,
shift, shopt, source, suspend, test, times, trap, type, typeset,
ulimit, umask, unalias, unset, wait

Bash shell shortcuts

CTRL Key Bound

Basic commands
Command Description
Ctrl + a Jump to the start of the line
Ctrl + b Move back a char
Ctrl + c Terminate the command
Ctrl + d Delete from under the cursor
Ctrl + e Jump to the end of the line
Ctrl + f Move forward a char
Ctrl + h Backspace
Ctrl + k Delete to EOL
Ctrl + l Clear the screen
Ctrl + n Next command line (useful for "scrolling" with Ctrl + p)
Ctrl + p Previous command line
Ctrl + r Search the history backwards
Ctrl + R Search the history backwards with multi occurrence
Ctrl + u Delete backward from cursor
Ctrl + xx Move between EOL and current cursor position
Ctrl + x @ Show possible hostname completions
Ctrl + w deletes the token left of the cursor
Ctrl + z Suspend / Stop the command
Ctrl + / Undo last command-line edit

ALT Key Bound

Basic commands
Command Description
Alt + < Move to the first line in the history
Alt + > Move to the last line in the history
Alt + ? Show current completion list
Alt + * Insert all possible completions
Alt + / Attempt to complete filename
Alt + . Yank last argument to previous command
Alt + b Move backward
Alt + c Capitalize the word
Alt + d Delete word
Alt + f Move forward
Alt + l Make word lowercase
Alt + n Search the history forwards non-incremental
Alt + p Search the history backwards non-incremental
Alt + r Recall command
Alt + t Move words around
Alt + u Make word uppercase
Alt + back-space Delete backward from cursor

More Special Keybindings

Basic commands
Command Description
$ 2T All available commands(common)
$ (string)2T All available commands starting with (string)
$ /2T Entire directory structure including Hidden one
$ 2T Only Sub Dirs inside including Hidden one
$ *2T Only Sub Dirs inside without Hidden one
$ ~2T All Present Users on system from "/etc/passwd"
$ $2T All Sys variables
$ @2T Entries from "/etc/hosts"
$ =2T Output like ls or dir
Note: Here "2T" means Press TAB twice

Bash syntax highlights

Bash's command syntax is a superset of the Bourne shell's command syntax. The definitive specification of Bash's command syntax is the Bash Reference Manual distributed by the GNU project. This section highlights some of Bash's unique syntax features.

The vast majority of Bourne shell scripts can be executed without alteration by Bash, with the exception of those Bourne shell scripts that happen to reference a Bourne special variable or to use a Bourne builtin command. The Bash command syntax includes ideas drawn from the Korn shell (ksh) and the C shell (csh), such as command-line editing, command history, the directory stack, the $RANDOM and $PPID variables, and POSIX command substitution syntax: $(...). When being used as an interactive command shell, Bash supports completion of partly typed-in program names, filenames, variable names, etc. when the user presses the TAB key.

Bash syntax has many extensions that the Bourne shell lacks. Several of those extensions are enumerated here.

Integer mathematics

A major limitation of the Bourne shell is that it cannot perform integer calculations without spawning an external process. Bash can perform in-process integer calculations using the ((...)) command and the $[...] variable syntax, as follows: 

VAR=55             # Assign integer 55 to variable VAR.
((VAR = VAR + 1))  # Add one to variable VAR.  Note the absence of the '$' character.
((++VAR))          # Another way to add one to VAR.  Performs C-style pre-increment.
((VAR++))          # Another way to add one to VAR.  Performs C-style post-increment.
echo $[VAR * 22]   # Multiply VAR by 22 and substitute the result into the command.
echo $((VAR * 22)) # Another way to do the above.

The ((...)) command can also be used in conditional statements, because its exit status is 0 or 1 depending on whether the condition is true or false: 

if ((VAR == Y * 3 + X * 2))
then
        echo Yes
fi

((Z > 23)) && echo Yes

The ((...)) command supports the following relational operators: '==', '!=', '>', '<', '>=', and '<='.

Bash cannot perform in-process floating point calculations. The only Unix command shells capable of this are Korn Shell (1993 version) and zsh (starting at version 4.0).

I/O redirection

Bash has several I/O redirection syntaxes that the traditional Bourne shell lacks. Bash can redirect standard output and standard error at the same time using this syntax: 

command &> file

which is simpler to type than the equivalent Bourne shell syntax, "command > file 2>&1". Bash, since version 2.05b, can redirect standard input from a string using the following syntax (sometimes called "here strings"): 

command <<< "string to be read as standard input"

If the string contains whitespace, it must be quoted.

Example: Redirect standard output to a file, write data, close file, reset stdout 

# make Filedescriptor(FD) 6 a copy of stdout (FD 1)
exec 6>&1
# open file "test.data" for writing
exec 1>test.data
# produce some content
echo "data:data:data"
# close file "test.data"
exec 1>&-
# make stdout a copy of FD 6 (reset stdout)
exec 1>&6
# close FD6
exec 6>&-

Open and close files 

# open file test.data for reading
exec 6<test.data
# read until end of file
while read -u 6 dta
do
  echo "$dta" 
done
# close file test.data
exec 6<&-

Catch output of external commands 

 # execute 'find' and store results in VAR
 # search for filenames which end with the letter "h"
 VAR=$(find . -name "*h")

In-process regular expressions

Bash 3.0 supports in-process regular expression matching using the following syntax, reminiscent of Perl: 

[[ string =~ regex ]]

The regular expression syntax is the same as that documented by the regex(3) man page. The exit status of the above command is 0 if the regex matches the string, 1 if it does not match. Parenthesized subexpressions in the regular expression can be accessed using the shell variable BASH_REMATCH, as follows: 

if [[ abcfoobarbletch =~ 'foo(bar)bl(.*)' ]]
then
        echo The regex matches!
        echo $BASH_REMATCH      -- outputs: foobarbletch
        echo ${BASH_REMATCH[1]} -- outputs: bar
        echo ${BASH_REMATCH[2]} -- outputs: etch
fi

This syntax gives performance superior to spawning a separate process to run a grep command, because the regular expression matching takes place within the Bash process. If the regular expression or the string contain whitespace or shell metacharacters (such as '*' or '?'), they should be quoted.

Backslash escapes

Words of the form $'string' are treated specially. The word expands to string, with backslash-escaped characters replaced as specified by the C programming language. Backslash escape sequences, if present, are decoded as follows:

Backslash Escapes
Backslash
Escape 		Expands To ...
\a An alert (bell) character
\b A backspace character
\e An escape character
\f A form feed character
\n A new line character
\r A carriage return character
\t A horizontal tab character
\v A vertical tab character
\\ A backslash character
\' A single quote character
\nnn The eight-bit character whose value is the octal value nnn (one to three digits)
\xHH The eight-bit character whose value is the hexadecimal value HH (one or two hex digits)
\cx A control-X character

The expanded result is single-quoted, as if the dollar sign had not been present.

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.

Bash startup scripts

When Bash starts, it executes the commands in a variety of different scripts.

When Bash is invoked as an interactive login shell, or as a non-interactive shell with the --login option, it first reads and executes commands from the file /etc/profile, if that file exists. After reading that file, it looks for ~/.bash_profile, ~/.bash_login, and ~/.profile, in that order, and reads and executes commands from the first one that exists and is readable. The --noprofile option may be used when the shell is started to inhibit this behavior.

When a login shell exits, Bash reads and executes commands from the file ~/.bash_logout, if it exists.

When an interactive shell that is not a login shell is started, Bash reads and executes commands from ~/.bashrc, if that file exists. This may be inhibited by using the --norc option. The --rcfile file option will force Bash to read and execute commands from file instead of ~/.bashrc.

When Bash is started non-interactively, to run a shell script, for example, it looks for the variable BASH_ENV in the environment, expands its value if it appears there, and uses the expanded value as the name of a file to read and execute. Bash behaves as if the following command were executed: 

if [ -n "$BASH_ENV" ]; then . "$BASH_ENV"; fi

but the value of the PATH variable is not used to search for the file name.

If Bash is invoked with the name sh, it tries to mimic the startup behavior of historical versions of sh as closely as possible, while conforming to the POSIX standard as well. When invoked as an interactive login shell, or a non-interactive shell with the --login option, it first attempts to read and execute commands from /etc/profile and ~/.profile, in that order. The --noprofile option may be used to inhibit this behavior. When invoked as an interactive shell with the name sh, Bash looks for the variable ENV, expands its value if it is defined, and uses the expanded value as the name of a file to read and execute. Since a shell invoked as sh does not attempt to read and execute commands from any other startup files, the --rcfile option has no effect. A non-interactive shell invoked with the name sh does not attempt to read any other startup files. When invoked as sh, Bash enters posix mode after the startup files are read.

When Bash is started in posix mode, as with the --posix command line option, it follows the POSIX standard for startup files. In this mode, interactive shells expand the ENV variable and commands are read and executed from the file whose name is the expanded value. No other startup files are read.

Bash attempts to determine when it is being run by the remote shell daemon, usually rshd. If Bash determines it is being run by rshd, it reads and executes commands from ~/.bashrc, if that file exists and is readable. It will not do this if invoked as sh. The --norc option may be used to inhibit this behavior, and the --rcfile option may be used to force another file to be read, but rshd does not generally invoke the shell with those options or allow them to be specified.

Christoph's Additions

PS1='\[\033[0;31m\][\u@christophchamp]\[\033[00m\]:\[\033[0;33m\]`pwd`\[\033[00m\]> '

[christoph@christophchamp]:/home/christoph>

References

External links

Bash guides from the Linux Documentation Project:

Other guides and tutorials:

Retrieved from "http://wiki.christophchamp.com/index.php?title=Bash&oldid=3981"