Syntax
[word] [space] [word]
Spaces separate words. In bash, a word is a group of characters that belongs together. Examples are command names and arguments to commands. To put spaces inside an argument (or word), quote the argument (see next point) with single or double quotes.
[command] ; [command] [newline]
[command] & [command]
A single ampersand terminates an asynchronous command. An ampersand does the same thing as a semicolon or newline in that it indicates the end of a command, but it causes Bash to execute the command asynchronously. That means Bash will run it in the background and run the next command immediately after, without waiting for the former to end. Only the command before the & is executed asynchronously and you must not put a ; after the &, the & replaces the ;.
[command] | [command]
[command] && [command]
[command] || [command]
' [Single quoted string] '
" [Double quoted string] "
Disables syntactical meaning of all characters except expansions inside the string. Use this form instead of single quotes if you need to expand a parameter or command substitution into your string.
Remember: It's important to always wrap your expansions ("$var" or "$(command)") in double quotes. This will, in turn, safely disable meaning of syntactical characters that may occur inside the expanded result.
Basic Structures
Compound Commands
Compound commands are statements that can execute several commands but are considered as a sort of command group by Bash.
Command Lists
{ [command list]; }
Execute the list of commands in the current shell as though they were one command.
- Command grouping on its own isn't very useful. However, it comes into play wherever Bash syntax accepts only one command while you need to execute multiple. For example, you may want to pass output of multiple commands via a pipe to another command's input:
{ cmd1; cmd2; } | cmd3
Or you may want to execute multiple commands after a || operator:
rm file || { echo "Removal failed, aborting."; exit 1; }
It is also used for function bodies. Technically, this can also be used for loop bodies though this is undocumented, not portable and we normally preferdo ...; done for this):
for digit in 1 9 7; { echo "$digit"; } # non-portable, undocumented, unsupported
for digit in 1 9 7; do echo "$digit"; done # preferred
Note: You need a ; before the closing } (or it must be on a new line).
( [command list] )
Execute the list of commands in a subshell.
This is exactly the same thing as the command grouping above, only, the commands are executed in a subshell. Any code that affects the environment such as variable assignments, cd, export, etc. do not affect the main script's environment but are scoped within the brackets.
Note: You do not need a ; before the closing ).
Expressions
Loops
Builtins
Builtins are commands that perform a certain function that has been compiled into Bash. Understandably, they are also the only types of commands (other than those above) that can modify the Bash shell's environment.
Dummies
true (or :): These commands do nothing at all.
false: The same as above, except that the command always "fails".
Declarative
alias: Sets up a Bash alias, or print the bash alias with the given name.
- Aliasses replace a word in the beginning of a command by something else. They only work in interactive shells (not scripts).
declare (or typeset): Assign a value to a variable.
export: Export the given variable to the environment so that child processes inherit it.
This is the same as declare -x. Remember that for the child process, the variable is not the same as the one you exported. It just holds the same data. Which means, you can't change the variable data and expect it to change in the parent process, too.
local: Declare a variable to have a scope limited to the current function.
As soon as the function exits, the variable disappears. Assigning to it in a function also doesn't change a global variable with the same name, should one exist. The same options as taken by declare can be passed to local.
type: Show the type of the command name specified as argument.
The type can be either: alias, keyword, function, builtin, or file.
Output
echo: Output each argument given to echo on one line, separated by a single space.
printf: Use the first argument as a format specifier of how to output the other arguments.
pwd: Output the absolute pathname of the current working directory.
Execution
cd: Changes the current directory to the given path.
- If the path doesn't start with a slash, it is relative to the current directory.
command: Run the first argument as a command.
coproc: Run a command or compound command as a co-process.
. or source: Makes Bash read the filename given as first argument and execute its contents in the current shell.
This is kind of like include in other languages. If more arguments are given than just a filename to source, those arguments are set as the positional parameters during the execution of the sourced code. If the filename to source has no slash in it, PATH is searched for it.
exec: Run the command given as first argument and replace the current shell with it.
exit: End the execution of the current script.
- If an argument is given, it is the exit status of the current script (an integer between 0 and 255).
logout: End the execution of a login shell.
return: End the execution of the current function.
ulimit: Modify resource limitations of the current shell's process.
- These limits are inherited by child processes.
Jobs/Processes
jobs: List the current shell's active jobs.
bg: Send the previous job (or job denoted by the given argument) to run in the background.
- The shell continues to run while the job is running. The shell's input is handled by itself, not the job.
fg: Send the previous job (or job denoted by the given argument) to run in the foreground.
- The shell waits for the job to end and the job can receive the input from the shell.
kill: Send a signal(3) to a process or job.
trap: Handle a signal(3) sent to the current shell.
suspend: Stops the execution of the current shell until it receives a SIGCONT signal.
wait: Stops the execution of the current shell until active jobs have finished.
Conditionals And Loops
Script Arguments
set: The set command normally sets various Shell options, but can also set Positional parameters.
Shell options are options that can be passed to the shell, such as bash -x or bash -e. set toggles shell options like this: set -x, set +x, set -e, ... Positional parameters are parameters that hold arguments that were passed to the script or shell, such as bash myscript -foo /bar. set assigns positional parameters like this: set -- -foo /bar.
shift: Moves all positional parameters' values one parameter back.
This way, values that were in $1 are discarted, values from $2 go into $1, values from $3 go into $2, and so on. You can specify an argument to shift which is an integer that specifies how many times to repeat this shift.
getopts: Puts an option specified in the arguments in a variable.
getopts Uses the first argument as a specification for which options to look for in the arguments. It then takes the first option in the arguments that is mentioned in this option specification (or next option, if getopts has been ran before), and puts this option in the variable denoted by the name in the second argument togetopts. This command is pretty much always used in a loop:
while getopts abc opt
do
case $opt in
a) ...;;
b) ...;;
c) ...;;
esac
done
This way all options in the arguments are parsed and when they are either -a, -b or -c, the respective code in the case statement is executed. Following short style is also valid for specifying multiple options in the arguments that getopts parses: -ac.
Streams
If you're new to handling input and output in bash or are looking for more examples, details and/or explanations, go read
BashGuide/InputAndOutput.
Bash is an excellent tool for managing streams of data between processes. Thanks to its excellent operators for connecting file descriptors, we take data from almost anywhere and send it to almost anywhere. Understanding streams and how you manipulate them in Bash is key to the vastness of Bash's power.
File Descriptors
A file descriptor is like a road between a file and a process. It's used by the process to send data to the file or read data from the file. A process can have a great many file descriptors, but by default, there are three that are used for standard tasks.
0: Standard Input
- This is where processes normally read information from. Eg. the process may ask you for your name, after you type it in, the information is read over FD 0.
1: Standard Output
- This is where processes normally write all their output to. Eg. the process may explain what it's doing or output the result of an operation.
2: Standard Error
- This is where processes normally write their error messages to. Eg. the process may complain about invalid input or invalid arguments.
Redirection
[command] > [file], [command] [n]> [file], [command] 2> [file]
File Redirection: The > operator redirects the command's Standard Output (or FD n) to a given file.
- This means all standard output generated by the command will be written to the file.
You can optionally specify a number in front of the > operator. If not specified, the number defaults to 1. The number indicates which file descriptor of the process to redirect output from.
- Note: The file will be truncated (emptied) before the command is started!
[command] >&[fd], [command] [fd]>&[fd], [command] 2>&1
Duplicating File Descriptors: The x>&y operator copies FD y's target to FD x.
For the last example, FD 1 (the command's stdout)'s current target is copied to FD 2 (the command's stderr).
- As a result, when the command writes to its stderr, the bytes will end up in the same place as they would have if they had been written to the command's stdout.
[command] >> [file], [command] [n]>> [file]
[command] < [file], [command] [n]< [file]
File Redirection: The < operator redirects the given file to the command's Standard Input.
You can optionally specify a number in front of the < operator. If not specified, the number defaults to 0. The number indicates which file descriptor of the process to redirect input into.
[command] &> [file]
[command] &>> [file] (Bash 4+)
[command] <<< "[line of data]"
[command] <<[WORD]
[lines of data]
[WORD]
Here-Document: Redirects the lines of data to the command's Standard Input.
- This is a good way of sending multiple lines of text to a command's input.
Note: The word after << must be exactly the same as the word after the last line of data, and when you repeat that word after the last line of data, it must be in the beginning of the line, and there must be nothing else on that line.
Note: You can 'quote' the word after the <<. If you do so, anything in the lines of data that looks like expansions will not be expanded by bash.
Piping
Expansions
[command] "$( [command list] )", [command] "` [command list] `"
Command Substitution: captures the output of a command and expands it inline.
We only use command substitution inside other commands when we want the output of one command to become part of another statement. An ancient and ill-advised alternative syntax for command substitution is the back-quote: `command`. This syntax has the same result, but it does not nest well and it's too easily confused with quotes (back-quotes have nothing to do with quoting!). Avoid this syntax and replace it with $(command) when you find it.
It's like running the second command, taking its output, and pasting it in the first command where you would put $(...).
[command] <([command list])
Process substitution: The <(...) operator expands into a new file created by bash that contains the other command's output.
- The file provides whomever reads from it with the output from the second command.
It's like redirecting the output of the second command to a file called foo, and then running the first command and giving it foo as argument. Only, in a single statement, and foo gets created and cleaned up automatically afterwards.
NOTE: DO NOT CONFUSE THIS WITH FILE REDIRECTION. The < here does not mean File Redirection. It is just a symbol that's part of the <(...) operator! This operator does not do any redirection. It merely expands into a path to a file.
[command] >([command list])
Process substitution: The >(...) operator expands into a new file created by bash that sends data you write to it to a second command's Standard Input.
- When the first command writes something to the file, that data is given to the second command as input.
It's like redirecting a file called foo to the input of the second command, and then running the first command, giving it foo as argument. Only, in a single statement, and foo gets created and cleaned up automatically afterwards
Common Combinations
Tests
Exit Codes
An Exit Code or Exit Status is an unsigned 8-bit integer returned by a command that indicates how its execution went. It is agreed that an Exit Code of 0 indicates the command was successful at what it was supposed to do. Any other Exit Code indicates that something went wrong. Applications can choose for themselves what number indicates what went wrong; so refer to the manual of the application to find out what the application's Exit Code means.
Testing The Exit Code
if [command list]; then [command list]; elif [command list]; then [command list]; else [command list]; fi
The if command tests whether the last command in the first command list had an exit code of 0.
If so, it executes the command list that follows the then. If not, the next elif is tried in the same manner. If no elifs are present, the command list following else is executed, unless there is no else statement. To summarize, if executes a list of *command*s. It tests the exit code. On success, the then commands are executed. elif and else parts are optional. The fi part ends the entire if block (don't forget it!).
while [command list], and until [command list]
Execute the next iteration depending on the exit code of the last command in the command list.
We've discussed these before, but it's worth repeating them in this section, as they actually do the same thing as the if statement; except that they execute a loop for as long as the tested exit code is respectively 0 or non-0.
Patterns
Bash knows two types of patterns. Glob Patterns is the most important, most used and best readable one. Later versions of Bash also support the "trendy" Regular Expressions. However, it is ill-advised to use regular expressions in scripts unless you have absolutely no other choice or the advantages of using them are far greater than when using globs. Generally speaking, if you need a regular expression, you'll be using awk(1), sed(1), or grep(1) instead of Bash.
Glob Syntax
?: A question mark matches any character.
- That is one single character.
*: A star matches any amount of any characters.
- That is zero or more of whatever characters.
[...]: This matches *one of* any of the characters inside the braces.
- That is one character that is mentioned inside the braces.
[abc]: Matches either a, b, or c but not the string abc.
[a-c]: The dash tells Bash to use a range.
[!a-c] or [^a-c]: The ! or ^ in the beginning tells Bash to invert the match.
Matches any character that is *not* a, b or c. That means any other letter, but *also* a number, a period, a comma, or any other character you can think of.
[[:digit:]]: The [:class:] syntax tells Bash to use a character class.
- Character classes are groups of characters that are predefined and named for convenience. You can use the following classes:
alnum, alpha, ascii, blank, cntrl, digit, graph, lower, print, punct, space, upper, word, xdigit
Testing
case [string] in [glob pattern]) [command list];; [glob pattern]) [command list];; esac:
[[ [string] = "[string]" ]], [[ [string] = [glob pattern] ]], or [[ [string] =~ [regular expression] ]]:
Test whether the left-hand STRING matches the right-hand STRING (if quoted), GLOB (if unquoted and using =) or REGEX (if unquoted and using =~).
[ and test are commands you often see in sh scripts to perform these tests. [[ can do all these things (but better and safer) and it also provides you with patternmatching.
Do NOT use [ or test in bash code. Always use [[ instead. It has many benefits and no downsides.
Do NOT use [[ for performing tests on commands or on numeric operations. For the first, use if and for the second use ((.
[[ can do a bunch of other tests, such as on files. See help test for all the types of tests it can do for you.
(( [arithmetic expression] )):
Parameters
Parameters are what Bash uses to store your script data in. There are Special Parameters and Variables.
Any parameters you create will be variables, since special parameters are read-only parameters managed by Bash. It is recommended you use lower-case names for your own parameters so as not to confuse them with the all-uppercase variable names used by Bash internal variables and environment variables. It is also recommended you use clear and transparent names for your variables. Avoid x, i, t, tmp, foo, etc. Instead, use the variable name to describe the kind of data the variable is supposed to hold.
It is also important that you understand the need for quoting. Generally speaking, whenever you use a parameter, you should quote it: echo "The file is in: $filePath". If you don't, bash will tear the contents of your parameter to bits, delete all the whitespace from it, and feed the bits as arguments to the command. Yes, Bash mutilates your parameter expansions by default - it's called Word Splitting - so use quotes to prevent this.
The exception is keywords and assignment. After myvar= and inside [[, case, etc, you don't need the quotes, but they won't do any harm either - so if you're unsure: quote!
Last but not least: Remember that parameters are the data structures of bash. They hold your application data. They should NOT be used to hold your application logic. So while many ill-written scripts out there may use things like GREP=/usr/bin/grep, or command='mplayer -vo x11 -ao alsa', you should NOT do this. The main reason is because you cannot possibly do it completely right and safe and readable/maintainable.
If you want to avoid retyping the same command multiple times, or make a single place to manage the command's command line, use a function instead. Not parameters.
Special Parameters
1, 2, ...: Positional Parameters are the arguments that were passed to your script or your function.
*:
When expanded, it equals the single string that concatenates all positional parameters using the first character of IFS to separate them (- by default, that's a space).
@: This will expand into multiple arguments: Each positional parameter that is set will be expanded as a single argument.
So basically, "$@" is the same as "$1" "$2" "$3" ..., all quoted separately.
NOTE: You should always use "$@" before "$*", because "$@" preserves the fact that each argument is its separate entity. With "$*", you lose this data!"$*" is really only useful if you want to separate your arguments by something that's not a space; for instance, a comma:(IFS=,; echo "You ran the script with the arguments: $*") -- output all your arguments, separating them by commas.
#: This parameter expands into a number that represents how many positional parameters are set.
?: Expands into the exit code of the previously completed foreground command.
-: The dash parameter expands into the option flags that are currently set on the Bash process.
$: The dollar parameter expands into the Process ID of the Bash process.
!: Expands into the Process ID of the most recently backgrounded command.
_: Expanding the underscore argument gives you the last argument of the last command you executed.
Parameter Operations
"$var", "${var}"
"${var:-Default Expanded Value}"
"${var:=Default Expanded And Assigned Value}"
"${var:?Error Message If Unset}", "${name:?Error: name is required.}"
${name:+Replacement Value}, ${name:+--name "$name"}
Expand the given string if the parameter name is not empty. This expansion is used mainly for expanding the parameter along with some context. The example expands two arguments: notice how, unlike all other examples, the main expansion is unquoted, allowing word splitting of the inside string. Remember to quote the parameter in the inside string, though!
"${line:5}", "${line:5:10}", "${line:offset:length}"
Expand a substring of the value contained within the parameter line. The substring begins at character number 5 (or the number contained within parameteroffset, in the second example) and has a length of 10 characters (or the number contained within parameter length). The offset is 0-based. If the length is omitted, the substring reaches til the end of the parameter's value.
"${@:5}", "${@:2:4}", "${array:start:count}"
Expand elements from an array starting from a start index and expanding all or a given count of elements. All elements are expanded as separate arguments because of the quotes. If you use @ as the parameter name, the elements are taken from positional parameters (the arguments to your script - the second example becomes: "$2" "$3" "$4" "$5").
"${!var}"
"${#var}", "${#myarray[@]}"
"${var#A Prefix}", "${PWD#*/}", "${PWD##*/}"
Expand the value contained within the parameter var after removing the string A Prefix from the beginning of it. If the value doesn't have the given prefix, it is expanded as is. The prefix can also be a glob pattern, in which case the string that matches the pattern is removed from the front. You can double the # mark to make the pattern match greedy.
"${var%A Suffix}", "${PWD%/*}", "${PWD%%/*}"
"${var/pattern/replacement}", "${HOME/$USER/bob}", "${PATH//:/ }"
"${var^}", "${var^^}", "${var^^[ac]}"
Expand the value contained within the parameter var after upper-casing all characters matching the pattern. The pattern must be match a single character and the pattern ? (any character) is used if it is omitted. The first example upper-cases the first character from var's value, the second upper-cases all characters. The third upper-cases all characters that are either a or c.
"${var,}", "${var,,}", "${var,,[AC]}"
Arrays
Arrays are variables that contain multiple strings. Whenever you need to store multiple items in a variable, use an array and NOT a string variable. Arrays allow you to keep the elements nicely separated and allow you to cleanly expand the elements into separate arguments. This is impossible to do if you mash your items together in a string!
If you're new to bash or don't fully grasp what arrays are and why one would use them in favor of normal variables, or you're looking for more explanation and/or examples on arrays, go read
the BashGuide's section on Arrays and
BashFAQ/005
Creating Arrays
myarray=( foo bar quux )
myarray=( "foo bar" quux )
myfiles=( *.txt )
Create an array myfiles that contains all the filenames of the files in the current directory that end with .txt. We can use any type of expansion inside the array assignment syntax. The example use pathname expansion to replace a glob pattern by all the filenames it matches. Once replaced, array assignment happens like in the first two examples.
myfiles+=( *.html )
names[5]="Big John", names[n + 1]="Long John"
Assign a string to a specific index in the array. Using this syntax, you explicitly tell Bash at what index in your array you want to store the string value. The index is actually interpreted as an arithmetic expression, so you can easily do math there.
read -ra myarray
Chop a line into fields and store the fields in an array myarray. The
read commands reads a line from
stdin and uses each character in the
IFS variable as a delimiter to split that line into fields.
IFS=, read -ra names <<< "John,Lucas,Smith,Yolanda"
Chop a line into fields using , as the delimiter and store the fields in the array named names. We use the <<< syntax to feed a string to the read command'sstdin. IFS is set to , for the duration of the read command, causing it to split the input line into fields separated by a comma. Each field is stored as an element in the names array.
IFS=$'\n' read -d '' -ra lines
Read all lines from stdin into elements of the array named lines. We use read's -d '' switch to tell it not to stop reading after the first line, causing it to read in all of stdin. We then set IFS to a newline character, causing read to chop the input up into fields whenever a new line begins.
files=(); while IFS= read -d '' -r file; do files+=("$file"); done < <(find . -name '*.txt' -print0)
Safely read all TXT files contained recursively in the current directory into the array named files.
We begin by creating an empty array named files. We then start a while loop which runs a read statement to read in a filename from stdin, and then appends that filename (contained in the variable file) to the files array. For the read statement we set IFS to empty, avoiding read's behavior of trimming leading whitespace from the input and we set -d '' to tell read to continue reading until it sees a NUL byte (filenames CAN span multiple lines, so we don't want read to stop reading the filename after one line!). For the input, we attach the find command to while's stdin. The find command uses -print0 to output its filenames by separating them with NUL bytes (see the -d '' on read). NOTE: This is the only truly safe way of building an array of filenames from a command's output! You must delimit your filenames with NUL bytes, because it is the only byte that can't actually appear inside a filename! NEVER use ls to enumerate filenames! First try using the glob examples above, they are just as safe (no need to parse an external command), much simpler and faster.
declare -A homedirs=( ["Peter"]=~pete ["Johan"]=~jo ["Robert"]=~rob )
Create an associative array, mapping names to user home directories. Unlike normal arrays, associative arrays indices are strings (just like the values). Note: you must use declare -A when creating an associative array to indicate to bash that this array's indices are strings and not integers.
homedirs["John"]=~john
Using Arrays
echo "${names[5]}", echo "${names[n + 1]}"
Expand a single element from an array, referenced by its index. This syntax allows you to retrieve an element's value given the index of the element. The index is actually interpreted as an arithmetic expression, so you can easily do math there.
echo "${names[@]}"
cp "${myfiles[@]}" /destinationdir/
rm "./${myfiles[@]}"
Remove all files referenced by the filenames within the myfiles array. It's generally a bad idea to attach strings to an array expansion syntax. What happens is: the string is only prefixed to the first element expanded from the array (or suffixed to the last if you attached the string to the end of the array expansion syntax). If myfiles contained the elements -foo.txt and bar-.html, this command would expand into: rm "./-foo.txt" "bar-.html". Notice only the first element is prefixed with ./. In this particular instance, this is handy because rm fails if the first filename begins with a dash. Now it begins with a dot.
(IFS=,; echo "${names[*]}")
Expand the array names into a single string containing all elements in the array, merging them by separating them with a comma (,). The
"${array[*]}"syntax is only very rarely useful. Generally, when you see it in scripts, it is a bug. The one use it has is to merge all elements of an array into a single string for displaying to the user. Notice we surrounded the statement with
(brackets
), causing a subshell: This will scope the
IFS assignment, resetting it after the subshell ends.
for file in "${myfiles[@]}"; do read -p "Delete $file? " && [[ $REPLY = y ]] && rm "$file"; done
for index in "${!myfiles[@]}"; do echo "File number $index is ${myfiles[index]}"; done
Iterate over all keys of the myfiles array after expanding them into the for statement. The syntax "${!array[@]}" (notice the !) gets expanded into a list of array keys, not values. Keys of normal arrays are numbers starting at 0. The syntax for getting to a particular element within an array is "${array[index]}", whereindex is the key of the element you want to get at.
names=(John Pete Robert); echo "${names[@]/#/Long }"
names=(John Pete Robert); echo "${names[@]:start:length}"; echo "${names[@]:1:2}"
printf '%s\n' "${names[@]}"
Output each array element on a new line. This printf statement is a very handy technique for outputting array elements in a common way (in this case, appending a newline to each). The format string given to printf is applied to each element (unless multiple %s's appear in it, of course).
for name in "${!homedirs[@]}"; do echo "$name lives in ${homedirs[$name]}"; done
Iterate over all keys of the homedirs array after expanding them into the for statement. The syntax for getting to the keys of associative arrays is the same as that for normal arrays. Instead of numbers beginning at 0, we now get the keys for which we mapped our associative array's values. We can later use these keys to look up values within the array, just like normal arrays.
printf '%s\n' "${#names[@]}"
Output the number of elements in the array. In this printf statement, the expansion expands to only one argument, regardless of the amount of elements in the array. The expanded argument is a number that indicates the amount of elements in the names array.
Examples: Basic Structures
Compound Commands
Command Lists
[[ $1 ]] || { echo "You need to specify an argument!" >&2; exit 1; }
(IFS=','; echo "The array contains these elements: ${array[*]}")
We use parenthesis to trigger a subshell here.
When we set the
IFS variable, it will only change in the subshell and not in our main script. That avoids us having to reset it to it's default after the expansion in the echo statement (which otherwise we would have to do in order to avoid unexpected behaviour later on).
(cd "$1" && tar -cvjpf archive.tbz2 .)
Expressions
Loops
for file in *.mp3; do openssl md5 "$file"; done > mysongs.md5
for file; do cp "$file" /backup/; done
for (( i = 0; i < 50; i++ )); do printf "%02d," "$i"; done
Generates a comma-separated list of numbers zero-padded to two digits.
(The last character will be a comma, yes, if you really want to get rid of it; you can - but it defeats the simplicity of this example)
while read _ line; do echo "$line"; done < file
until myserver; do echo "My Server crashed with exit code: $?; restarting it in 2 seconds .."; sleep 2; done
select fruit in Apple Pear Grape Banana Strawberry; do (( credit -= 2, health += 5 )); echo "You purchased some $fruit. Enjoy!"; done
Builtins
Dummies
Declarative
alias l='ls -al'
declare -i myNumber=5
export AUTOSSH_PORT=0
foo() { local bar=fooBar; echo "Inside foo(), bar is $bar"; }; echo "Setting bar to 'normalBar'"; bar=normalBar; foo; echo "Outside foo(), bar is $bar"
if ! type -P ssh >/dev/null; then echo "Please install OpenSSH." >&2; exit 1; fi
Output
Execution
cd ~lhunath
cd() { command cd "$@" && echo "$PWD"; }
Inside the function, execute the builtin cd command, not the function (which would cause infinite recursion) and if it succeeds, echo out the new current working directory.
source bashlib; source ./.foorc
exec 2>/var/log/foo.log
echo "Fatal error occurred! Terminating!"; exit 1
