Differences between revisions 33 and 143 (spanning 110 versions)

1. Contents: Bash Guide

Contents

Contents: Bash Guide
Practices

Contents

Choose Your Shell
Quoting
Readability
Bash Tests
Don't Ever Do These
Debugging

Practices

1. Choose Your Shell

The first thing you should do before starting a shell script, or any kind of script or program for that matter, is enumerate the requirements and the goal of that script. Then evaluate what the best tool is to accomplish those goals.

BASH may be easy to learn and write in, but it isn't always fit for the job.

There are a lot of tools in the basic toolset that can help you. If you just need AWK, then don't make a shell script that invokes AWK. Just make an AWK script. If you need to retrieve data from an HTML or XML file in a reliable manner, Bash is also the wrong tool for the job. You should consider XPath/XSLT instead, or a language that has a library available for parsing XML or HTML.

If you decide that a shell script is what you want, then first ask yourself these questions:

In the foreseeable future, might your script be needed in an environment where Bash is not available by default?
- If so, then consider sh instead. sh is a POSIX shell and its features are available in any shell that complies with the POSIX standard. You can rely on the fact that any POSIX system will be able to run your script. You will have to balance the needs of portability against the Bash features you'd be unable to use.
- Keep in mind that this guide does not apply to sh! The Bashism page gives some alternatives, but it is not complete.
Are you certain that in all environments you will run and might want to run this script in the future Bash 3.x (or 4.x) will be available to you?
- If not, you should limit yourself to features of Bash 2.x ONLY.

If the above questions do not limit your choices, use all the Bash features you require, and then make note of which version of Bash is required to run your script.

Using Bash 3 or higher means you can avoid ancient scripting techniques. They have been replaced with far better alternatives for very good reasons.

Stay away from scripting examples you see on the Web unless you understand them completely. Mostly any scripts you will find on the Web are broken in some way. Do not copy/paste from them.
Always use the correct shebang. If you're writing a Bash script, you need to put #!/usr/bin/env bash at the top of your script. Omitting this header or using the #!/bin/sh header is wrong. In the latter case you will no longer be able to use any Bash features. You will be limited to the POSIX shell scripting standard (even if your /bin/sh links to Bash).
When writing Bash scripts, do not use the [ command. Bash has a far better alternative: [[. Bash's [[ is more reliable in many ways and there are no advantages whatsoever to sticking with the old relic. You'll also miss out on a lot of features provided by [[ that [ does not have (like pattern matching).
It's also time you forgot about `...`. It isn't consistent with the syntax of Expansion and is terribly hard to nest without a dose of painkillers. Use $(...) instead.
And for heaven's sake, "Use more quotes!" Protect your strings and parameter expansions from WordSplitting. Word splitting will eat your babies if you don't quote things properly.
Learn to use parameter expansions instead of sed or cut to manipulate simple strings in Bash. If you want to remove the extension from a filename, use ${filename%.*} instead of `echo "$filename" | sed 's/\.[^.]*$//'` or some other dinosaur.
Use built-in math instead of expr to do simple calculations, especially when just incrementing a variable. If the script you're reading uses x=`expr $x + 1` then it's not something you want to mimic.

2. Quoting

Word Splitting is the demon inside Bash that is out to get unsuspecting newcomers or even veterans who let down their guard.

If you do not understand how Word Splitting works or when it is applied you should be very careful with your strings and your Parameter Expansions. I suggest you read up on WordSplitting if you doubt your knowledge.

The best way to protect yourself from this beast is to quote all your strings. Quotes keep your strings in one piece and prevent Word Splitting from tearing them open. Allow me to illustrate:

$ echo Push that word             away from me.
Push that word away from me.
$ echo "Push that word             away from me."
Push that word             away from me.

Now, don't think Word Splitting is about collapsing spaces. What really happened in this example is that the first command passed each word in our sentence as a separate argument to echo. Bash split our sentence up in words using the whitespace between them to determine where each argument begins and ends. In the second example Bash is forced to keep the whole quoted string together. This means it's not split up into arguments and the whole string is passed to echo as one argument. echo prints out each argument it gets with a space in between them. You should understand the basics of Word Splitting now.

This is where it gets dangerous: Word Splitting does not just happen on literal strings. It also happens after Parameter Expansion! As a result, if you missed a cup of coffee this morning you may find yourself making this mistake:

$ sentence="Push that word             away from me."
$ echo $sentence
Push that word away from me.
$ echo "$sentence"
Push that word             away from me.

As you can see, in the first echo command, we neglected to add quotes. Bash expanded our sentence and then used Word Splitting to split the resulting expansion up into arguments to use for echo, which had the result of destroying our carefully thought-out formatting. In our second example, the quotes around the Parameter Expansion of sentence make sure Bash does not split it up into multiple arguments around the whitespace.

It's not just spaces you need to protect. Word Splitting occurs on all whitespace, including tabs, newlines, and any other characters in the IFS variable. Here's another example to show you just how badly you can break things if you neglect to quote when necessary:

$ echo "$(ls -al)"
total 8
drwxr-xr-x   4 lhunath users 1 2007-06-28 13:13 "."/
drwxr-xr-x 102 lhunath users 9 2007-06-28 13:13 ".."/
-rw-r--r--   1 lhunath users 0 2007-06-28 13:13 "a"
-rw-r--r--   1 lhunath users 0 2007-06-28 13:13 "b"
-rw-r--r--   1 lhunath users 0 2007-06-28 13:13 "c"
drwxr-xr-x   2 lhunath users 1 2007-06-28 13:13 "d"/
drwxr-xr-x   2 lhunath users 1 2007-06-28 13:13 "e"/
$ echo $(ls -al)
total 8 drwxr-xr-x 4 lhunath users 1 2007-06-28 13:13 "."/ drwxr-xr-x 102 lhunath users 9 2007-06-28 13:13 ".."/ -rw-r--r-- 1 lhunath users 0 2007-06-28 13:13 "a" -rw-r--r-- 1 lhunath users 0 2007-06-28 13:13 "b" -rw-r--r-- 1 lhunath users 0 2007-06-28 13:13 "c" drwxr-xr-x 2 lhunath users 1 2007-06-28 13:13 "d"/ drwxr-xr-x 2 lhunath users 1 2007-06-28 13:13 "e"/

In some very rare occasions it may be desired to leave out the quotes. That's if you need Word Splitting to take place:

$ friends="Marcus JJ Thomas Michelangelo"
$ for friend in $friends
> do echo "$friend is my friend!"; done
Marcus is my friend!
JJ is my friend!
Thomas is my friend!
Michelangelo is my friend!

But, honestly? You should use arrays for nearly all of these cases. Arrays have the benefit that they separate strings without the need for an explicit delimiter. That means your strings in the array can contain any valid (non-NUL) character, without the worry that it might be your string delimiter (like the space is in our example above). Using arrays in our example above gives us the ability to add middle or last names of our friends:

$ friends=( "Marcus The Rich" "JJ The Short" "Timid Thomas" "Michelangelo The Mobster" )
$ for friend in "${friends[@]}"
> do echo "$friend is my friend"; done

Note that in our previous for we used an unquoted $friends. This allowed Bash to split our friends string up into words. In this last example, we quoted the ${friends[@]} Parameter Expansion. Quoting an expansion of an array through the @ index makes Bash expand that array into a sequence of its elements, where each element is wrapped in quotes.

3. Readability

Almost as important as the result of your code is the readability of your code.

Chances are that you aren't just going to write a script once and then forget about it. If so, you might as well delete it after using it. If you plan to continue using it, you should also plan to continue maintaining it. Unlike your house your code won't get dirty over time, but you will learn new techniques and new approaches constantly. You will also gain insight about how your script is used. All that new information you gather since the completion of your initial code should be used to maintain your code in such a way that it constantly improves. Your code should keep growing more user-friendly and more stable.

Trust me when I say, no piece of code is ever 100% finished, with the exception of some very short and useless chunks of nothingness.

To make it easier for yourself to keep your code healthy and improve it regularly you should keep an eye on the readability of what you write. When you return to a long loop after a year has passed since your last visit to it and you wish to improve it, add a feature, or debug something about it, consider whether you'd rather see this:

   1 friends=( "Marcus The Rich" "JJ The Short" "Timid Thomas" "Michelangelo The Mobster" )
   2 
   3 # Say something significant about my friends.
   4 for name in "${friends[@]}"; do
   5 
   6     # My first friend (in the list).
   7     if [[ $name = "${friends[0]}" ]]; then
   8         echo "$name was my first friend."
   9 
  10     # My friends whose names start with M.
  11     elif [[ $name = M* ]]; then
  12         echo "$name starts with an M"
  13 
  14     # My short friends.
  15     elif [[ " $name " = *" Short "* ]]; then
  16         echo "$name is a shorty."
  17 
  18     # Friends I kind of didn't bother to remember.
  19     else
  20         echo "I kind of forgot what $name is like."
  21 
  22     fi
  23 done

Than something like this:

   1 x=(       Marcus\ The\ Rich JJ\ The\ Short
   2   Timid\ Thomas Michelangelo\ The\ Mobster)
   3 for name in "${x[@]}"
   4   do if [ "$name" = "$x" ]; then echo $name was my first friend.
   5  elif
   6    echo $name    |   \
   7   grep -qw Short
   8     then echo $name is a shorty.
   9  elif [ "x${name:0:1}" = "xM" ]
  10      then echo $name starts   with an M; else
  11 echo I kind of forgot what $name \
  12  is like.; fi; done

And yes, I know this is an exaggerated example, but I've seen some authentic code that actually has a lot in common with that last example.

For your own health, keep these few points in mind:

Healthy whitespace gives you breathing space. Indent your code properly and consistently. Use blank lines to separate paragraphs or logic blocks.
Avoid backslash-escaping. It's counter-intuitive and boggles the mind when overused. Even in small examples it takes your mind more effort to understand a\ b\ c than it takes to understand 'a b c'.
Comment your way of thinking before you forget. You might find that even code that looks totally common sense right now could become the subject of "What the hell was I thinking when I wrote this?" or "What is this supposed to do?".
Consistency prevents mind boggles. Be consistent in your naming style. Be consistent in your use of capitals. Be consistent in your use of shell features. In coding, unlike in the bedroom, it's good to be simple and predictable.

4. Bash Tests

The test command, also known as [, is an application that usually resides somewhere in /usr/bin or /bin and is used a lot by shell programmers to perform certain tests on files and variables. In a number of shells, including Bash, test is also implemented as a shell builtin.

It can produce surprising results, especially for people starting shell scripting that think [ ] is part of the shell syntax.

If you use sh, you have little choice but to use test as it is the only way to do most of your testing.

If however you are using Bash to do your scripting (and I presume you are since you're reading this guide), then you can also use the [[ keyword. While it still behaves in many ways like a command, it presents several advantages over the traditional test command.

Let me illustrate how [[ can be used to replace test, and how it can help you to avoid some of the common mistakes made by using test:

$ var=''
$ [ $var = '' ] && echo True
-bash: [: =: unary operator expected
$ [ "$var" = '' ] && echo True
True
$ [[ $var = '' ]] && echo True
True

[ $var = '' ] expands into [ = '' ]. The first thing test does is count its arguments. Since we're using the [ form, we'll just strip off the mandatory ] argument at the end. In the first example, test sees two arguments: = and ''. It knows that if it has two arguments, the first one has to be a unary operator (an operator that takes one operand). But = is not a unary operator (it's binary -- it requires two operands), so test blows up.

Yes, test did not see our empty $var because Bash expanded it into nothingness before test could even see it. Moral of the story? Use more quotes! Using quotes, [ "$var" = '' ] expands into [ "" = '' ] and test has no problem.

Now, [[ can see the whole command before it's being expanded. It sees $var, and not the expansion of $var. As a result, there is no need for the quotes at all! [[ is safer.

$ var=
$ [ "$var" < a ] && echo True
-bash: a: No such file or directory
$ [ "$var" \< a ] && echo True
True
$ [[ $var < a ]] && echo True
True

In this example we attempted a string comparison between an empty variable and 'a'. We're surprised to see the first attempt does not yield True even though we think it should. Instead, we get some weird error that implies Bash is trying to open a file called 'a'.

We've been bitten by File Redirection. Since test is just an application, the < character in our command is interpreted (as it should) as a File Redirection operator instead of the string comparison operator of test. Bash is instructed to open a file 'a' and connect it to stdin for reading. To prevent this, we need to escape < so that test receives the operator rather than Bash. This makes our second attempt work.

Using [[ we can avoid the mess altogether. [[ sees the < operator before Bash gets to use it for Redirection -- problem fixed. Once again, [[ is safer.

Even more dangerous is using the > operator instead of our previous example with the < operator. Since > triggers output Redirection it will create a file called 'a'. As a result, there will be no error message warning us that we've committed a sin! Instead, our script will just break. Even worse, we might overwrite some important file! It's up to us to guess where the problem is:

$ var=a
$ [ "$var" > b ] && echo True || echo False
True
$ [[ "$var" > b ]] && echo True || echo False
False

Two different results, not good. The lesson is to trust [[ more than [. [ "$var" > b ] is expanded into [ "a" ] and the output of that is being redirected into a new file called 'b'. Since [ "a" ] is the same as [ -n "a" ] and that basically tests whether the "a" string is non-empty, the result is a success and the echo True is executed.

Using [[ we get our expected scenario where "a" is tested against "b" and since we all know "a" sorts before "b" this triggers the echo False statement. And this is how you can break your script without realizing it. You will however have a suspiciously empty file called 'b' in your current directory.

Yes it adds a few characters, but [[ is far safer than [. Everybody inevitably makes programming errors. Even if you try to use [ safely and carefully avoid these mistakes, I can assure you that you will make them. And if other people are reading your code, you can be sure that they'll absolutely mess things up.

Besides [[ provides the following features over [:

[[ can do glob pattern matching:
```
[[ abc = a* ]]
```
[[ can do regex pattern matching (Bash 3.1+):
```
[[ abb =~ ab+ ]]
```

The only advantage of test is its portability.

5. Don't Ever Do These

The Bash shell allows you to do quite a lot of things, offering you considerable flexibility. Unfortunately, it does very little to discourage misuse and other ill-advised behavior. It hopes people will find out for themselves that certain things should be avoided at all costs.

Unfortunately many people don't care enough to want to find out for themselves. They write without thinking things through and many awful and dangerous scripts end up in production environments or in Linux distributions. The result of these, and even your very own scripts written in a time of neglect, can often be DISASTROUS.

That said, for the good of your scripts and for the rest of mankind, Never Ever Do Anything Along These Lines:

ls -l | awk '{ print $8 }'
- DON'T EVER parse the output of ls! The ls command's output cannot be trusted for a number of reasons.
  1. For one, ls will mangle the filenames of files if they contain characters unsupported by your locale. As a result, parsing filenames out of ls is NEVER guaranteed to actually give you a file that you will be able to find. ls might have replaced certain characters in the filename by question marks.
  2. Secondly, ls separates lines of data by newlines. This way, every bit of information on a file is on a new line. UNFORTUNATELY filenames themselves can ALSO contain newlines. This means that if you have a filename that contains a newline in the current directory, it will completely break your parsing and as a result, break your script!
  3. Last but not least, the output format of ls -l is NOT guaranteed consistent across platforms. Some systems omit the group ID by default, for instance, and reverse the effect of the -g switch. Some systems use two fields for the modification time, and some use three. On the systems that use three, the third field can be either a year, or an HH:MM concatenation, depending on how old the file is.
  There are alternatives to using ls in many cases. If you need to work with file modification times, you can typically use Bash Tests. If none of those things is possible, I recommend you switch to a different language, like python or perl.
if echo "$file" | fgrep .txt; then
ls *.txt | grep story
- DON'T EVER test or filter filenames with grep! Unless your grep pattern is really smart it will probably not be trustworthy.
- In the first example above, the test would match both story.txt AND story.txt.exe. If you make grep patterns that are smart enough, they'll probably be so ugly, massive and unreadable that you shouldn't use them anyway.
- The alternative is called globbing. Bash has a feature called Pathname Expansion. This will help you enumerate all files that match a certain pattern. Also, you can use globs to test whether a filename matches a certain glob pattern (in a case or [[ command).
cat file | grep pattern
- Don't use cat to feed a single file's content to a filter. cat is a utility used to concatenate the contents of several files together.
- To feed the contents of a file to a process you will probably be able to pass the filename as an argument to the program (grep 'pattern' /my/file, sed 'expression' /my/file, ...).
- If the manual of the program does not specify any way to do this, you should use redirection (read column1 column2 < /my/file, tr ' ' '\n' < /my/file, ...).
for line in $(<file); do
- Don't use a for loop to read the lines of a file. Use a while read loop instead.
for number in $(seq 1 10); do
- For the love of god and all that is holy, do not use seq to count.
- Bash is able enough to do the counting for you. You do not need to spawn an external application (especially a single-platform one) to do some counting and then pass that application's output to Bash for word splitting. Learn the syntax of for already!
- In general, C-style for loops are the best method for implementing a counter for ((i=1; i<=10; i++)).
- If you actually wanted a stream of numbers separated by newlines as test input, consider printf '%d\n' {1..10}. You can also loop over the result of a sequence expansion if the range is constant, but the shell needs to expand the full list into memory before processing the loop body. This method can be wasteful and is less versatile than other arithmetic loops.
i=`expr $i + 1`
- expr is a relic of ancient Rome. Do not wield it.
- It was used in scripts written for shells with very limited capabilities. You're basically spawning a new process, calling another C program to do some math for you and return the result as a string to bash. Bash can do all this itself and so much faster, more reliably (no numbers->string->number conversions) and in all, better.
- You should use this in Bash: let i++ or ((i++))
- Even POSIX sh can do arithmetic: i=$(($i+1)). It only lacks the ++ operator and the ((...)) command (it has only the $((...)) substitution).

6. Debugging

Very often you will find yourself clueless as to why your script isn't acting the way you want it to. Resolving this problem is always just a matter of common sense and debugging techniques.

6.1. Diagnose the Problem

Unless you know what exactly the problem is, you most likely won't come up with a solution anytime soon. So make sure you understand what exactly goes wrong. Evaluate the symptoms and/or error messages.

Try to formulate the problem as a sentence. This will also be vital if you're going to ask other people for help with your problem. You don't want them to have to go through your whole script or run it so that they understand what's going on. No; you need to make the problem perfectly clear to yourself and to anybody trying to help you. This requirement stands until the day the human race invents means of telepathy.

6.2. Minimize the Codebase

If staring at your code doesn't give you a divine inspiration, the next thing you should do is try to minimize your codebase to isolate the problem.

Don't worry about preserving the functionality of your script. The only thing you want to preserve is the logic of the code block that seems buggy.

Often, the best way to do this is to copy your script to a new file and start deleting everything that seems irrelevant from it. Alternatively, you can make a new script that does something similar in the same code fashion, and keep adding structure until you duplicate the problem.

As soon as you delete something that makes the problem go away (or add something that makes it appear), you'll have found where the problem lies. Even if you haven't precisely pinpointed the issue, at least you're not staring at a massive script anymore, but hopefully at a stub of no more than 3-7 lines.

For example, if you have a script that lets you browse images in your image folder by date, and for some reason you can't manage to iterate over your images in the folder properly, it suffices to reduce the script to this part:

for image in $(ls -R "$imgFolder"); do
    echo "$image"
done

Your actual script will be far more complex, and the inside of the for loop will also be far longer. But the essence of the problem is this code. Once you've reduced your problem to this it may be easier to see the problem you're facing. Your echo spits out parts of image names; it looks like all whitespace is replaced by newlines. That must be because echo is run once for each chunk terminated by whitespace, not for every image name (as a result, it seems the output has split open image names with whitespace in them). With this reduced code, it's easier to see that the cause is actually your for statement that splits up the output of ls into words. That's because ls is UNPARSABLE in a bugless manner (do not ever use ls in scripts, unless if you want to show its output to a user).

We can't use a recursive glob (unless we're in bash 4), so we have to use find to retrieve the filenames. One fix would be:

find "$imgFolder" -print0 | while IFS= read -r -d '' image; do
    echo "$image"
done

Now that you've fixed the problem in this tiny example, it's easy to merge it back into the original script.

6.3. Activate Bash's Debug Mode

If you still don't see the error of your ways, Bash's debugging mode might help you see the problem through the code.

When Bash runs with the x option turned on, it prints out every command it executes before executing it (to standard error). That is, after any expansions have been applied. As a result, you can see exactly what's happening as each line in your code is executed. Pay very close attention to the quoting used. Bash uses quotes to show you exactly which strings are passed as a single argument.

There are three ways of turning on this mode.

Run the script with bash -x:
```
$ bash -x ./mybrokenscript
```
Modify your script's header:
```
#!/bin/bash -x
[.. script ..]
```
Or:
```
#!/usr/bin/env bash
set -x
```

Or add set -x somewhere in your code to turn on this mode for only a specific block of your code:

#!/usr/bin/env bash
[..irrelevant code..]
set -x
[..relevant code..]
set +x
[..irrelevant code..]

Because the debugging output goes to stderr, you will generally see it on the screen, if you are running the script in a terminal. If you would like to log it to a file, you can tell Bash to send all stderr to a file:

exec 2>> /path/to/my.logfile
set -x

A nice feature of bash version >= 4.1 is the variable BASH_XTRACEFD. This allows you to specify the file descriptor to write the set -x debugging output to. In older versions of bash, this output always goes to stderr, and it is difficult if not impossible to keep it separate from normal output (especially if you are logging stderr to a file, but you need to see it on the screen to operate the program). Here's a nice way to use it:

   1 # dump set -x data to a file
   2 # turns on with a filename as $1
   3 # turns off with no params
   4 setx_output()
   5 {
   6     if [[ $1 ]]; then
   7         exec {BASH_XTRACEFD}>>"$1"
   8         set -x
   9     else
  10         set +x
  11         unset -v BASH_XTRACEFD
  12     fi
  13 }

If you have a complicated mess of scripts, you might find it helpful to change PS4 before setting -x. If the value assigned to PS4 is surrounded by double quotes it will be expanded during variable assignment, which is probably not what you want; with single quotes, the value will be expanded when the PS4 prompt is displayed.

PS4='+$BASH_SOURCE:$LINENO:$FUNCNAME: '

6.4. Step Your Code

If the script goes too fast for you, you can enable code-stepping. The following code uses the DEBUG trap to inform the user about what command is about to be executed and wait for his confirmation do to so. Put this code in your script, at the location you wish to begin stepping:

debug_prompt () { read -p "[$BASH_SOURCE:$LINENO] $BASH_COMMAND?" _ ;}
trap 'debug_prompt "$_"' DEBUG

6.5. The Bash Debugger

The Bash Debugger Project is a gdb-style debugger for bash, available from http://bashdb.sourceforge.net/

The Bash Debugger will allow you to walk through your code and help you track down bugs.

6.6. Reread the Manual

If your script still doesn't seem to agree with you, maybe your perception of the way things work is wrong. Try going back to the manual (or this guide) to re-evaluate whether commands do exactly what you think they do, or the syntax is what you think it is. Very often people misunderstand what for does, how Word Splitting works, or how often they should use quotes.

Keep the tips and good practice guidelines in this guide in mind as well. They often help you avoid bugs and problems with scripts.

I mentioned this in the Scripts section of this guide too, but it's worth repeating it here. First of all, make sure your script's header is actually #! /bin/bash. If it is missing or if it's something like #! /bin/sh then you deserve the problems you're having. That means you're probably not even using Bash to run your code. Obviously that'll cause issues. Also, make sure you have no Carriage Return characters at the ends of your lines. This is the cause of scripts written in Microsoft Windows(tm). You can get rid of these fairly easily like this:

$ tr -d '\r' < myscript > tmp && mv tmp myscript

6.7. Read the FAQ / Pitfalls

The BashFAQ and BashPitfalls pages explain common misconceptions and issues encountered by other Bash scripters. It's very likely that your problem will be described there in some shape or form.

To be able to find your problem in there, you'll obviously need to have Diagnosed it properly. You'll need to know what you're looking for.

6.8. Ask Us on IRC

There are people in the #bash channel almost 24/7. This channel resides on the Libera Chat IRC network. To reach us, you need an IRC client. Connect it to irc.libera.chat, and /join #bash.

Make sure that you know what your real problem is and have stepped through it on paper, so you can explain it well. We don't like having to guess at things. Start by explaining what you're trying to do with your script.

Either way, please have a look at this page before entering #bash: XyProblem.

<- Job Control

[BashGuide/Practices][edit]

-  ⇤ ← Revision 33 as of 2007-05-25 22:50:47 → 
  Size: 76657
  Editor: Lhunath
  Comment:
+   ← Revision 143 as of 2008-11-22 14:09:37 → ⇥
  Size: 577
  Editor: localhost
  Comment: converted to 1.6 markup
-Deletions are marked like this.
+Additions are marked like this.
 Line 1:
-= Introduction =
+## The Bash Guide
##   ~ lhunath
#acl GreyCat:read,write,revert,admin,delete Lhunath:read,write,revert pgas:read,write,revert All:read
#pragma section-numbers on
-Line 3:
+Line 6:
-All the information here is presented without any warranty or guarantee of accuracy.  Use it at your own risk.  When in doubt, please consult the man pages or the GNU info pages as the authoritative references.
+= Contents: Bash Guide =
-Line 5:
+Line 8:
-["BASH"] is a BourneShell compatible shell, which adds many new features to its ancestor. Most of them are available in the 'KornShell', too.
+<<TableOfContents>>
## Until TableOfContents.py gets fixed, every page will have to be manually included.
## Currently, using the regex makes the ToC have links pointing to the wrong anchors.
## [[Include(^BashGuide/.*, , editlink)]]
-Line 7:
+Line 13:
-[[TableOfContents]]

-----


[[Anchor(about)]]
== About This Guide ==

This guide aims to become a point of reference for people interested in learning to work with ["BASH"].  It aspires to teach its readers good practice techniques in developing scripts for the ["BASH"] interpreter and educate them about the internal operation of ["BASH"].

This guide is targetted at beginning users.  It assumes no basic knowledge, but rather expects you to have enough common sense to put two and two together.  If something is unclear to you, you should report this so that it may be clarified in this document for future readers.

You are invited to contribute to the development of this document by extending it or correcting invalid or incomplete information.



[[Anchor(definition)]]
== A Definition ==

["BASH"] is an acronym for '''''B'''ourne '''A'''gain '''Sh'''ell''.  It is based on the ''Bourne'' shell and is mostly compatible with its features.

Shells are applications that provide users with the ability to give commands to their operating system interactively, or to allow them to execute batch processes quickly.  In no way are they required for execution of processes; they are merely a layer between system function calls and the user.

--------
    '''In The Manual:
    [http://www.gnu.org/software/bash/manual/bashref.html#SEC1 Introduction]'''
--------



[[Anchor(using)]]
== Using Bash ==

Most users that think of ["BASH"] think of it as a prompt and a command line.  That is ["BASH"] in ''interactive mode''.  ["BASH"] can also run in ''non-interactive mode'' through scripts.  We can use scripts to automate certain logic.  Scripts are basically lists of commands that you can type on the command line.  When such a script is executed, all these commands are executed sequentially, one after another.

We'll start with the basics in an ''interactive shell''. Once you're familiar with those, you can put them together in scripts.

--------
    '''In the FAQ:
    [[BR]]
    [http://wooledge.org/mywiki/BashFAQ/061 Is there a list of which features were added to specific releases (versions) of Bash?]'''
--------




[[Anchor(basics)]]
= The Basics =



[[Anchor(commands)]]
== Commands And Arguments ==

["BASH"] reads commands from its input (which is either a terminal or a file).  In ''interactive mode'', its input is your terminal.  These commands can be aliases, functions, builtin commands, or executable applications.

  * '''Aliases''': ["BASH"] can use aliases to make it easier to quickly execute complex commands.  An alias is a ''name'' that is mapped to a certain ''string''.  Whenever that ''name'' is used as a command in bash, it is replaced by the ''string''.
  * '''Functions''': Functions in ["BASH"] are much like aliases, but more powerful and general.  A function contains shell commands, very much like a script.  When a function is called, the commands in it are executed.
  * '''Builtin Commands''': ["BASH"] has some basic commands built into it, such as `cd` (change directory), `if` (conditional command execution), and so on.
  * '''Executable Applications''': ["BASH"] uses a variable that tells it where to find other applications.  This variable is called `PATH`, and it is a set of directory names separated by colons -- for example, `/bin:/usr/bin`.  Each directory can contain executables.  When a command is specified in ["BASH"] without a pathname (e.g. `ls`), and it isn't an alias, function or builtin, ["BASH"] searches the paths in `PATH`, in order from left to right, for this command.  Since these commands are not part of ["BASH"] and run as separate processes, they are also called ''external commands''.

Each command can be followed by arguments.  It is very important that you understand how this works exactly.  If you don't grasp these concepts well, the quality of your code will degrade significantly and you will introduce very dangerous bugs.  So, pay close attention in the next few chapters.

{{{
    $ ls
    a  b  c
}}}

`ls` is a command that lists files in the current directory.

{{{
    $ mkdir d
    $ cd d
    $ ls
}}}

`mkdir` is a command that creates a new directory.  We specified the argument `d` to that command.  This way, the application `mkdir` is instructed to create a directory called `d`.  After that, we use the application `cd` to change the current directory to `d`.  `ls` shows us that the current directory (which is now `d`) is empty, since it doesn't display any filenames.

--------
    '''Tip:
    [[BR]]
    You can use the `type` command to figure out the type of a command.
    [[BR]]
    For example:'''
{{{
    $ type rm
    rm is hashed (/bin/rm)
    $ type cd
    cd is a shell builtin
}}}
----
    '''In The Manual:
    [http://www.gnu.org/software/bash/manual/bashref.html#SEC16 Simple Commands]'''
--------



[[Anchor(splitting)]]
== Commandline Argument Splitting ==

Commands in ["BASH"] can take multiple arguments.  These arguments are used to tell the command exactly what it's supposed to do.  In ["BASH"], you separate these arguments by whitespace (spaces, tabs and newlines).

{{{
    $ ls
    $ touch a b c
    $ ls
    a  b  c
}}}

`touch` is an application that changes the 'Last Modified'-time of a certain file to the current time.  If the filename that it's given does not exist yet, it simply creates that file, as a new and empty file.  In this example, we passed three arguments.  `touch` creates a file for each argument.  `ls` shows us that three files have been created.

{{{
    $ rm *
    $ ls
    $ touch a   b c
    $ ls
    a  b  c
}}}

`rm` is an application that removes all the files that it was given.  ''*'' is a ''glob''.  It basically means ''all files in the current directory''.  You will read more about this later on.

Now, did you notice that there are several spaces between `a` and `b`, and only one between `b` and `c`?  Also, notice that the files that were created by `touch` are no different than the first time.  You now know that the amount of whitespace between arguments does not matter.  This is important to know.  For example:

{{{
    $ echo This is a test.
    This is a test.
    $ echo This    is    a    test.
    This is a test.
}}}

In this case, we provide the `echo` command with four arguments. 'This', 'is', 'a' and 'test.'.  `echo` takes these arguments, and prints them out one by one with a space in between.  In the second case, the exact same thing happens.  The extra spaces make no difference.  To protect the whitespace properly, we need to pass the sentence as one single argument.  We can do this by using quotes:

{{{
    $ echo "This    is    a    test."
    This    is    a    test.
}}}

Quotes group everything together and pass it as a single argument.  This argument is 'This    is    a    test.', properly spaced.  `echo` prints this single argument out just like it always does.

Be very careful to avoid the following:

{{{
    $ ls
    The secret voice in your head.mp3  secret
    $ rm The secret voice in your head.mp3
    rm: cannot remove `The': No such file or directory
    rm: cannot remove `voice': No such file or directory
    rm: cannot remove `in': No such file or directory
    rm: cannot remove `your': No such file or directory
    rm: cannot remove `head.mp3': No such file or directory
    $ ls
    The secret voice in your head.mp3
}}}

You need to make sure you quote filenames properly.  If you don't you'll end up deleting the wrong things!  `rm` takes filenames as arguments.  If you do not quote filenames with spaces, `rm` thinks that each argument is another file.  Since ["BASH"] splits your arguments at the spaces, `rm` will try to remove each word.

Please have a good look at http://bash-hackers.org/wiki/doku.php?id=syntax:words if all this isn't very clear to you yet.

--------
    '''Good Practice:
    [[BR]]
    You should ''always'' quote sentences or strings that belong together; even if it's not
    absolutely necessary.  This will keep you alert and reduce the risk of human error in
    your scripts.
    [[BR]]
    For example, you should always quote arguments to the `echo` command.'''
----
    '''In the FAQ:
    [[BR]]
    [http://wooledge.org/mywiki/BashFAQ/050 I'm trying to construct a command dynamically, but I can't figure out how to deal with quoted multi-word arguments.]'''
--------



[[Anchor(globs)]]
== Globs ==

Globs are a very important concept in ["BASH"], if only for their incredible convenience.  Properly understanding globs will benefit you in many ways.  Globs are basically patterns that can be used to match filenames or other strings.

Globs are composed of normal characters and meta characters.  Meta characters are characters that have a special meaning.  These are the basic meta characters:

  * '''*''': Matches any string, including the null string.
  * '''?''': Matches any single character.
  * '''[...]''': Matches any one of the enclosed characters.

Here's an example of how we can use glob patterns to expand to filenames:

{{{
    $ ls
    a  abc  b  c
    $ echo *
    a abc b c
    $ echo a*
    a abc
}}}

["BASH"] sees the glob, for example `a*`.  It ''expands'' this glob, by looking in the current directory and matching it against all files there.  Any filenames that match the glob, are enumerated and replaced by the glob.  As a result, the statement `echo a*` is replaced by the statement `echo a abc`, and is then executed.

["BASH"] will always make sure that whitespace and special characters are escaped properly when expanding the glob.  For example:

{{{
    $ touch "a b.txt"
    $ ls
    a b.txt
    $ rm *
    $ ls
}}}

Here, `rm *` is expanded into `rm a\ b.txt`.  This makes sure that the string `a b.txt` is passed as a single argument to `rm`, since it represents a single file.  It is important to understand that using globs to enumerate files is nearly '''always''' a better idea than using `ls` for that purpose.  Here's an example with some more complex syntax which we will cover later on, but it will illustrate the problem very well:

{{{
    $ ls
    a b.txt
    $ for file in `ls`; do rm "$file"; done
    rm: cannot remove `a': No such file or directory
    rm: cannot remove `b.txt': No such file or directory
    $ for file in *; do rm "$file"; done
    $ ls
}}}

Here we use the `for` command to go through the output of the `ls` command.  The `ls` command results in a string `a b.txt`.  The `for` command splits that string into arguments over which it iterates.  As a result, for iterates over `a` and `b.txt`.  Naturally, this is '''not''' what we want.  The glob however expands in the proper form.  It results in the string `a\ b.txt`, which `for` takes as a single argument.

["BASH"] also supports a feature called `Extended Globs`.  These globs are more powerful in nature.  This feature is turned off by default, but can be turned on with the `shopt` command, which is used to toggle '''sh'''ell '''opt'''ions:

{{{
    $ shopt -s extglob
}}}

  * '''?(list)''': Matches zero or one occurrence of the given patterns.
  * '''*(list)''': Matches zero or more occurrences of the given patterns.
  * '''+(list)''': Matches one or more occurrences of the given patterns.
  * '''@(list)''': Matches one of the given patterns.
  * '''!(list)''': Matches anything except one of the given patterns.

The list inside the parentheses is a list of globs separated by the `|` character. Here's an example:

{{{
    $ ls
    names.txt  tokyo.jpg  california.bmp
    $ echo !(*jpg|*bmp)
    names.txt
}}}

Our glob now expands to anything that does not match the `*jpg` or the `*bmp` pattern.  Only the text file passes for that, so it is expanded.

Then, there is Brace Expansion.  Brace Expansion technically does not fit in the category of Globs, but it is similar.  Globs only expand to actual filenames, where brace expansion will expand to any permutation of the pattern.  Here's how they work:

{{{
    $ echo th{e,a}n
    then than
    $ echo {/home/*,/root}/.*profile
    /home/axxo/.bash_profile /home/lhunath/.profile /root/.bash_profile /root/.profile
    $ echo {1..9}
    1 2 3 4 5 6 7 8 9
    $ echo {0,1}{0..9}
    00 01 02 03 04 05 06 07 08 09 10 11 12 13 14 15 16 17 18 19
}}}

--------
    '''Good Practice:
    [[BR]]
    You should always use globs in favor of `ls` (or similar) to enumerate files.
    Globs will always expand safely and minimize the risk for bugs.
    [[BR]]
    You can sometimes end up with some very weird filenames.  Generally speaking, scripts
    aren't always tested against all the odd cases that it may end up being used with.'''
----
    '''In The Manual:
    [http://www.gnu.org/software/bash/manual/bashref.html#SEC35 Pattern Matching]'''
----
    '''In the FAQ:
    [[BR]]
    [http://wooledge.org/mywiki/BashFAQ/016 How can I use a logical AND in a shell pattern (glob)?]'''
--------



[[Anchor(characters)]]
== Special Characters ==

There are several special characters in ["BASH"] that have a non-literal meaning.  When we use these characters, ["BASH"] evaluates these characters and their meaning, but usually does not pass them on to the underlying commands.

Here are a few of those special characters, and what they do:
  * '''"text"''': Double quotes.  Double quotes protect the text inside from being split into multiple words or arguments.  They also prevent the special meaning of single quotes inside.
  * ''''text'''': Single quotes.  Single quotes protect the text inside from any kind of expansion by the shell and keeps it from being split into multiple words or arguments.  They also prevent the special meaning of all special characters inside.
  * '''# text''': Comment character.  Any text that follows until the first newline is not processed as shell commands or arguments.
  * ''';''': Command separator.  The colon is used to separate multiple commands from each other if the user chooses to keep them on the same line.  It's ''basically'' the same thing as a newline.
  * '''\''': Escape character.  The escape character protects the next character from being used in any special sort of way.
  * '''>''' or '''<''': Redirection character.  These characters are used to modify (redirect) the input and/or output of a command.
  * '''[[ expression ]]''': Test expression.  This evaluates the conditional expression.
  * '''{ commands; }''': Command Group.  This executes the commands inside the braces as though they were only one command.  It is convenient for places where ["BASH"] syntax requires only one command to be present.
  * '''`command`''', '''$(command)''': Command substitution (The latter form is '''highly''' preferred).  Command substitution executes the command inside the substitution form first, and replaces itself by that command's output.
  * '''(command)''': Subshell Execution.  This executes the command in a new bash shell, instead of in the current.
  * '''((expression))''': Arithmetic Evaluation.  Inside the parentheses, operators such as +, -, * and / are seen as mathematical operators.
  * '''$((expression))''': Arithmetic Expansion.  Comparable to the above, however this expression is replaced the result of its arithmetic evaluation.
  * '''$''': Expansion character.  This character is used for any form of parameter expansion.  More about this later.

Some examples:

{{{
    $ echo "I am $USER"
    I am lhunath
    $ echo 'I am $USER'
    I am $USER
    $ # boo
    $ echo An open\ \ \ space
    An open   space
    $ echo "My computer is $(hostname)"
    My computer is Lyndir
    $ echo boo > file
    $ echo $(( 5 + 5 ))
    10
    $ (( 5 > 0 )) && echo "Five is bigger than zero."
    Five is bigger than zero.
}}}

--------
    '''In The Manual:
    [http://www.gnu.org/software/bash/manual/bashref.html#SEC6 Shell Syntax]'''
--------



[[Anchor(parameters)]]
== Parameters and Variables ==

Parameters should be seen as a sort of named space in memory where you can store your data.  Generally speaking, they will store string data, but can also be used to store integers or arrays.

Let's get your vocabulary straight before we get into the real deal.  There are parameters and variables. Variables are actually just a kind of parameters.  Parameters that are denoted by a name.  I'm sure you'll understand things better with a few examples:

{{{
    $ # Some parameters that aren't variables:
    $ echo My shell is $0, and was started with these options: $-
    My shell is -bash, and was started with these options: himB
    $ # Some parameters that ARE variables:
    $ echo I am $USER, and I live at $HOME.
    I am lhunath, and I live at /home/lhunath.
}}}

'''Please note: Unlike PHP/Perl/... parameters do NOT start with a $-sign.  The $-sign you see in the examples merely causes the parameter that follows it to be ''expanded''.  Expansion basically means that the shell replaces it by its content.
As such, `USER` is the parameter (variable), that contains your username.  `$USER` will be replaced with its content; which in my case, is `lhunath`.'''

I think you've got the drift now. Here's a summary of most non-variable parameters:

  * '''Positional Parameters''': 0, 1, 2, ...; They contain the n'th argument that was passed to the current script.
  * '''Special Parameters''':
    * '''*''': Expands to a string enumerating all positional parameters.
    * '''@''': Depending on the context in which it is used, expands to either a string enumerating all positional parameters, or several strings; one for each parameter.
    * '''#''': Expands to the amount of positional parameters that are currently set.
    * '''?''': Expands to the exit code of the most recently completed foreground application.
    * '''$''': Expands to the ["PID"] of the current shell.
    * '''!''': Expands to the ["PID"] of the application most recently executed in the background.
    * '''_''': Expands to the last argument of the last command that was executed.

And here are some examples of variables that the shell initializes for you:
  * '''BASH_VERSION''': Contains a string describing the version of ["BASH"].
  * '''HOSTNAME''': Contains the hostname of your computer, I swear.
  * '''PPID''': Contains the ["PID"] of the process that started this shell.
  * '''PWD''': Contains the current directory.
  * '''RANDOM''': Each time you expand this variable, a random number between 0 and 32767 is generated.
  * '''UID''': The integer ID of the current user.
  * '''COLUMNS''': The amount of characters fit on one line in your terminal. (The width of your terminal in characters.)
  * '''LINES''': The amount of lines that fit in your terminal. (The height of your terminal in lines.)
  * '''HOME''': The current user's home directory.
  * '''PATH''': A colon-separated list of paths that will be searched to find the executable for a command that is executed, if it is not an alias or a function (or absolutely referenced).
  * '''PS1''': Contains a string that describes the format of your shell prompt.
  * '''TMPDIR''': Contains the directory that is used to store temporary files (by the shell).

Of course, you aren't restricted to only these variables.  Feel free to define your own:

{{{
    $ country=Canada
    $ echo "I am $USER and I currently live in $country."
    I am lhunath and I currently live in Canada.
}}}

Notice what we did to assign the value `Canada` to the variable `country`.  Remember that you are '''NOT allowed to have any spaces before or after that equals sign'''!

{{{
    $ language = PHP
    -bash: language: command not found
    $ language=PHP
    $ echo "I'm far too used to $language."
    I'm far too used to PHP.
}}}

Remember that ["BASH"] is not Perl or PHP.  You need to be very well aware of how ''expansion'' works to avoid '''big''' trouble.  If you don't, you'll end up creating very dangerous situations in your scripts, especially when making this mistake with `rm`:

{{{
    $ ls
    no secret  secret
    $ file='no secret'
    $ rm $file
    rm: cannot remove `no': No such file or directory
}}}

Imagine we have two files, `no secret` and `secret`.  The first contains nothing useful, but the second contains the secret that will save the world from impending doom.  Unthoughtful as you are, you forgot to '''quote''' your parameter expansion of `file`.  ["BASH"] expands the parameter and the result is `rm no secret`.  ["BASH"] splits the arguments up by their whitespace as it normally does, and `rm` is passed two arguments; 'no' and 'secret'.  As a result, it fails to find the file `no` and it deletes the file `secret`.  You doomed the world, you should be proud.

--------
    '''Good Practice:
    [[BR]]
    You should always keep parameter expansions well quoted.  This prevents the whitespace
    or the possible globs inside of them to give you gray hair or unexpectedly wipe stuff
    off your computer.  The only good PE, is a quoted PE.'''
----
    '''In The Manual:
    [http://www.gnu.org/software/bash/manual/bashref.html#SEC23 Shell Parameters],
    [http://www.gnu.org/software/bash/manual/bashref.html#SEC60 Shell Variables]'''
----
    '''In the FAQ:
    [[BR]]
    [http://wooledge.org/mywiki/BashFAQ/013 How can I concatenate two variables? How do I append a string to a variable?]
    [[BR]]
    [http://wooledge.org/mywiki/BashFAQ/025 How can I access positional parameters after $9?]'''
--------



[[Anchor(parameterexpansion)]]
== Parameter Expansion ==

''Parameter Expansion'' is the term that refers to any operation that causes a parameter to be expanded (replaced by content).  In its most basic appearance, the parameter expansion of a parameter is achieved by prefixing that parameter with a `$` sign.  In certain situations, additional curly brackets around the parameter's name are required:

{{{
    $ echo "'$USER', '$USERs', '${USER}s'"
    'lhunath', '', 'lhunaths'
}}}

This example illustrates what basic parameter expansions look like.  The second PE results in an empty string.  That's because the parameter `USERs` is empty.  We did not intend to have the `s` be part of the parameter name.  Since there's no way for ["BASH"] to determine whether you want the `s` appended to the name of the parameter or its value you need to use curly brackets to mark the beginning and end of the parameter name.  That's what we do in the third PE in our example above.

''Parameter Expansion'' can also be used to modify the string that will be expanded.  These operations are terribly convenient:

{{{
    $ for file in *.JPG *.jpeg
    > do mv "$file" "${file%.*}.jpg"
    > done
}}}

The code above can be used to rename all `JPEG` files with a `JPG` or a `jpeg` extension to have a normal `jpg` extension.  The PE (`${file%.*}`) cuts off everything from the end until it finds a period (`.`).  Then, in the same quotes, a new extension is appended to the expansion result.

Here's a summary of most PEs that are available:

  * '''${parameter:-word}''': Use Default Values.  If '`parameter`' is unset or null, the expansion of '`word`' is substituted.  Otherwise, the value of '`parameter`' is substituted.
  * '''${parameter:=word}''': Assign Default Values.  If '`parameter`' is unset or null, the expansion of '`word`' is assigned to '`parameter`'.  The value  of '`parameter`' is then substituted.
  * '''${parameter:?word}''': Display Error if Null or Unset.  If '`parameter`' is null or unset, the expansion of '`word`' (or a message to that effect if '`word`' is not present) is written to the standard error and the shell, if it is not interactive, exits.  Otherwise,  the value of '`parameter`' is substituted.
  * '''${parameter:+word}''': Use Alternate Value.  If '`parameter'` is null or unset, nothing is substituted, otherwise the expansion of '`word`' is substituted.
  * '''${parameter:offset:length} Substring Expansion.  Expands to up to '`length`' characters of '`parameter`' starting at the character specified by '`offset`'. If '`length`' is omitted, expands to the substring of '`parameter`' starting at the character specified by '`offset`'.
  * '''${#parameter}''': The  length in characters of the value of '`parameter`' is substituted.
  * '''${parameter#pattern}''': The '`pattern`' is anchored to the beginning of '`parameter`'. The result of the expansion is the expanded value of '`parameter`' with  the  shortest match deleted.
  * '''${parameter##pattern}''': The '`pattern`' is anchored to the beginning of '`parameter`'. The result of the expansion is the expanded value of '`parameter`' with the longest match deleted.
  * '''${parameter%pattern}''': The '`pattern`' is anchored to the end of '`parameter`'. The result of the expansion is the expanded value of '`parameter`'  with  the  shortest match deleted.
  * '''${parameter%%pattern}''': The '`pattern`' is anchored to the end of '`parameter`'. The result of the expansion is the expanded value of '`parameter`'  with  the  longest match deleted.
  * '''${parameter/pattern/string}''': The '`pattern`' is not anchored but evaluated from left to right in the value of '`parameter`'. The result of the expansion is the expanded value of '`parameter`'  with  the  shortest match of '`pattern`' replaced by '`string`'.
  * '''${parameter//pattern/string}''': The '`pattern`' is not anchored but evaluated from left to right in the value of '`parameter`'. The result of the expansion is the expanded value of '`parameter`'  with  the  longest match of '`pattern`' replaced by '`string`'.

You will learn them all through experience.  They will come in handy far more often than you think they might.  Here's a few examples to kickstart you:

{{{
    $ file="$HOME/.secrets/007"; \
    > echo "File location: $file"; \
    > echo "Filename: ${file##*/}"; \
    > echo "Directory of file: ${file%/*}"; \
    > echo "Non-secret file: ${file/secrets/not_secret}"; \
    > echo; \
    > echo "Other file location: ${other:-There is no other file}"; \
    > echo "Using file if there is no other file: ${other:=$file}"; \
    > echo "Other filename: ${other##*/}"; \
    > echo "Other file location length: ${#other}"
    File location: /home/lhunath/.secrets/007
    Filename: 007
    Directory of file: /home/lhunath/.secrets
    Non-secret file: /home/lhunath/.not_secret/007
    
    Other file location: There is no other file
    Using file if there is no other file: /home/lhunath/.secrets/007
    Other filename: 007
    Other file location length: 26
}}}

Remember the difference between `${v#p}` and `${v##p}`.  The doubling of the `#` character means metacharacters will become greedy.  The same counts for `%` and `/`:

{{{
    $ version=1.5.9; echo "MAJOR: ${version%%.*}, MINOR: ${version#*.}."
    MAJOR: 1, MINOR: 5.9.
    $ echo "Dash: ${version/./-}, Dashes: ${version//./-}."
    Dash: 1-5.9, Dashes: 1-5-9.
}}}


'''Note: You cannot nest PEs together.  If you need to execute multiple PEs on a parameter, you will need to use multiple statements:'''

{{{
    $ file=$HOME/image.jpg; file=${file##*/}; echo "${file%.*}"
    image
}}}



--------
    '''Good Practice:
    [[BR]]
    You may be tempted to use external applications such as `sed`, `awk`, `cut`, `perl`
    or others to modify your strings.  Be aware that all of these require an extra process
    to be started, which in some cases can cause slowdowns.  Parameter Expansions are the
    perfect alternative.'''
----
    '''In The Manual:
    [http://www.gnu.org/software/bash/manual/bashref.html#SEC29 Shell Parameter Expansion]'''
----
    '''In the FAQ:
    [[BR]]
    [http://wooledge.org/mywiki/BashFAQ/007 Is there a function to return the length of a string?]
    [[BR]]
    [http://wooledge.org/mywiki/BashFAQ/073 How can I use parameter expansion? How can I get substrings? How can I get a file without its extension, or get just a file's extension?]
    [[BR]]
    [http://wooledge.org/mywiki/BashFAQ/074 How do I get the effects of those nifty Bash Parameter Expansions in older shells?]'''
--------



[[Anchor(conditionals)]]
== Tests and Conditionals ==

Sequential execution of applications is one thing, but to achieve a sort of logic in your scripts or your command line one-liners, you'll need variables and conditionals.  Conditionals are used to determine the execution flow of a script.


[[Anchor(exitcode)]]
=== Exit Status ===

Every application results in an exit code whenever it terminates.  This exit code is used by whatever application started it to evaluate whether everything went OK.  This exit code is like a return value from functions.  It's an integer between 0 and 255 (inclusive).  Convention dictates that we use 0 to denote success, and any other number to denote failure of some sort.  The specific number is entirely application-specific, and is used to hint as to what exactly went wrong.

For example, the `ping` command sends ICMP packets over the network to a certain host.  That host normally responds to this packet by sending the exact same one right back.  This way, we can check whether the remote host can receive our packets.  `ping` has a range of exit codes which can tell us what went wrong, if anything did:

'''From the `ping` manual:
    If  ping does not receive any reply packets at all it will exit with code 1.
    If a packet count and deadline are both specified, and fewer than count packets
    are received by the time the deadline has arrived, it will also exit with code 1.
    On other error it exits with code 2. Otherwise it exits with code 0.
    This makes it possible to use the exit code to see if a host is alive or not.'''

The parameter `?` shows us the exit code of the last foreground process that terminated.
Let's play around a little with ping to see it's exit codes:

{{{
    $ ping God
    ping: unknown host God
    $ echo $?
    2

    $ ping -c 1 -W 1 1.1.1.1
    PING 1.1.1.1 (1.1.1.1) 56(84) bytes of data.
    
    --- 1.1.1.1 ping statistics ---
    1 packets transmitted, 0 received, 100% packet loss, time 0ms
    $ echo $?
    1
}}}

--------
    '''Good Practice:
    [[BR]]
    You should make sure that your scripts always return a non-zero exit code if
    something unexpected happened in its execution.  You can do this with the `exit`
    builtin:'''
{{{
    rm file || { echo "Could not delete file!"; exit 1; }
}}}
----
    '''In The Manual:
    [http://www.gnu.org/software/bash/manual/bashref.html#SEC52 Exit Status]'''
--------


[[Anchor(operators)]]
=== Control Operators ===

Now that we know what exit codes are, and that an exit code of '0' means the command's execution was successful, we'll learn to use this information.  The easiest way of performing a certain action depending on the success of a previous command is through the use of 'control operators'.  These operators are `&&` and `||`, which respectively represent a logical AND and a logical OR.  These operators are used inbetween two commands, and they are used to control whether the second command should be executed depending on the success of the first.

Let's put that theory in practice:


{{{
    $ mkdir d && cd d
}}}

This simple example has two commands, `mkdir d` and `cd d`.  You could easily just use a semi-colon there to separate both commands and execute them sequentially; but we want something more.  In the above example, ["BASH"] will execute `mkdir d`, then `&&` will check the result of the `mkdir` application as it finishes.  If the `mkdir` application resulted in a success (exit code 0), then `&&` will execute the next command, `cd d`.  If `mkdir d` failed, and returned a non-0 exit code, `&&` will skip the next command, and we will stay in the current directory.

Another example:

{{{
    $ rm /etc/some_file.conf || echo "I couldn't remove the file!"

    rm: cannot remove `/etc/some_file.conf': No such file or directory
    I couldn't remove the file!
}}}

`||` is much like `&&`, but it does the exact opposite.  It only executes the next command if the first '''failed'''.  As such, the message is only echoed if the `rm` command was unsuccessful.

You can make a sequence with these operators, but you have to be very careful when you do.  Remember what exit code the operator is '''really''' going to be checking against!  Here's an example that might cause confusion:

{{{
    $ false && true || echo "Riddle, riddle?"
    Riddle, riddle?

    $ true && false || echo "Riddle, riddle?"
    Riddle, riddle?
}}}

`true` is obviously always going to be successful.  `false` is obviously always going to be unsuccessful.  Can you guess why the `echo` statement is executed in both occasions?

The key to understanding how to sequence these operators properly is by evaluating exit codes from left to right.

In the first example, `false` is unsuccessful, so `&&` does not execute the next command (which is `true`), but the next `||` gets a shot too.  `||` still sees that the last exit code was that from `false`, and `||` executes the next command when the previous was unsuccessful.  As a result, the `echo` statement is executed.

The same for the second statement again.  `true` is successful, so the `&&` executes the next statement.  That is `false`; the last exit code now becomes unsuccessful.  After that, `||` is evaluated, which sees the unsuccessful exit code from `false` and executes the `echo` statement.

It's all easy with `true`s and `false`s; but how about real commands?

{{{
    $ rm file && touch file || echo "File not found!"
}}}

All seems well with this piece of code, and when you test it, I'm sure you'll see that it actually does what it's supposed to.  It tries to delete a file, and if it succeeds, it creates it again as a new and empty file; if something goes wrong we get the error message.  What's the catch?

Perhaps you guessed, perhaps not, but here's a hint:  Imagine we're in a directory where we don't have permission to create a file?  It won't stop us from deleting the file if the file happens to be ours.  `rm` will succeed in deleting our file, but `touch` will fail to create it anew because of permission issues.  As a result, we get a strange error message saying that the file wasn't found while we were actually trying to '''create''' it.  What's up with that?

--------
    '''Good Practice:
    [[BR]]
    It's best not to get overcourageous when dealing with conditional operators.
    They can make your script hard to understand, especially for a person that's
    assigned to maintain it and didn't write it himself.'''
----
    '''In The Manual:
    [http://www.gnu.org/software/bash/manual/bashref.html#SEC18 List of Commands]'''
--------


[[Anchor(if)]]
=== If-statements ===

`if` is an application that executes the command that it receives as argument, and checks that command's exit code to see whether its execution was successful.  Depending on that exit code, `if` executes a specific block of code.

{{{
    $ if true
    > then echo "It was true."
    > else echo "It was false!"
    > fi

    It was true.
}}}

Here you see the basic outline of an ''if-statement''.  We start by calling `if` with the argument `true`.  `true` is a sort of built-in application, running it is like running an application that always ends successfully.  `if` runs that application, and once the application's done, it checks the exit code.  Since `true` always exits successfully, `if` continues to the `then`-block, and executes its code.  Should the `true` application have failed somehow, and returned an unsuccessful exit code, the `if` statement would have skipped the `then` code, and executed the `else` code block instead.

There are commands that can help us a lot in doing conditional checks.  They are `[` (also named `test`) and `[[`.  `[` is a normal application that reads its arguments and does some checks with them.  `[[` is much like `[`, however, it is not an application.  It's a built-in and it offers far more versatillity.  Let's get practical:

{{{
    $ if [ a = b ]
    > then echo "a is the same as b."
    > else echo "a is not the same as b."
    > fi

    a is not the same as b.
}}}

`if` executes the command `[` with the arguments 'a', '=', 'b' and ']'.  `[` uses these arguments to determine what must be checked.  It then checks whether the string 'a' is identical to the string 'b', and if this is the case, it will exit successfully.  However, since we know this is not the case, `[` will not exit successfully (it's exit code will be 1).  `if` sees that `[` terminated unsuccessfully and executes the code in the `else` block.

Now, to see why `[[` is so much more interesting and trustworthy than `[`, let us highlight some possible problems with `[`:

{{{
    $ if [ my dad = my dog ]
    > then echo "I have a problem."
    > fi

    -bash: [: too many arguments
}}}

Can you guess what caused the problem?
[[BR]]
`[` was executed with the arguments 'my', 'dad', '=', 'my', 'dog' and ']'.  `[` doesn't understand what test it's supposed to execute, because it expects the second argument to be the operator.  In our case, the operator is the third argument.  Yet another reason why '''quotes''' are so terribly important.  Whenever we type whitespace in bash that belongs together with the words before or after it, '''we need to quote the whole string''':

{{{
    $ if [ 'my dad' = 'my dog' ]
    > then echo "I have a problem."
    > fi
}}}

This time, `[` sees an operator (`=`) in the second argument and it can continue with its work.  Now, this may be easy to see and avoid, but it gets just a little trickier when we put the strings in variables, rather than literally in the statement:

{{{
    $ dad='my dad'; dog='my dog'
    $ if [ $dad = $dog ]
    > then echo "I have a problem."
    > fi

    -bash: [: too many arguments
}}}

How did we mess up this time?
[[BR]]
Here's a hint: ["BASH"] takes our ''if-statement'' and expands all the parameters in it.  The result is `if [ my dad = my dog ]`.  Boom, game over.

Here's how it's supposed to look like:

{{{
    $ if [ "$dad" = "$dog" ]
    > then echo "I have a problem."
    > fi
}}}

To help us out a little, ["BASH"] introduced a new style of conditional test.  Original as the ["BASH"] authors are, they called it `[[`.  `[[` was loaded with several very interesting features which are missing from `[`.  One of them helps us in dealing with parameter expansions:

{{{
    $ if [[ $dad = $dog ]]
    > then echo "I have a problem."
    > fi
    $ if [[ I want $dad = I want $dog ]]
    > then echo "I want too much."
    > fi

    -bash: conditional binary operator expected
    -bash: syntax error near `want'
}}}

This time, $dad and $dog didn't need to be quoted.  Since `[[` isn't an application (while `[` is), but a built-in, it has special magical powers.  It parses its arguments before they are expanded by bash and does the expansion itself; taking the result as a single argument, even if that result contains whitespace.  ''However'', be aware that simple strings still have to be quoted properly.  `[[` can't know whether your literal whitespace in the statement is intentional or not; so it splits it up just like ["BASH"] normally would.  Let's fix our last example:

{{{
    $ if [[ "I want $dad" = "I want $dog" ]]
    > then echo "I want too much."
    > fi
}}}

Now that you've got a decent understanding of quoting issues that may arise, let's have a look at some of the other features that `[` and `[[` were blessed with:

  * Tests supported by `[` (also known as `test`):
    * '''-e FILE''': True if file exists.
    * '''-f FILE''': True if file is a regular file.
    * '''-d FILE''': True if file is a directory.
    * '''-h FILE''': True if file is a symbolic link.
    * '''-r FILE''': True if file is readable by you.
    * '''-s FILE''': True if file exists and is not empty.
    * '''-t FD  ''': True if FD is opened on a terminal.
    * '''-w FILE''': True if the file is writable by you.
    * '''-x FILE''': True if the file is executable by you.
    * '''-O FILE''': True if the file is effectively owned by you.
    * '''-G FILE''': True if the file is effectively owned by your group.
    * '''FILE -nt FILE''': True if the first file is newer than the second.
    * '''FILE -ot FILE''': True if the first file is older than the second.

    * '''-z STRING''': True if the string is empty (it's length is zero).
    * '''-n STRING''': True if the string is not empty (it's length is not zero).
    * '''STRING = STRING''': True if the first string is identical to the second.
    * '''STRING != STRING''': True if the first string is not identical to the second.
    * '''STRING < STRING''': True if the first string sorts before the second.
    * '''STRING > STRING''': True if the first string sorts after the second.

    * '''EXPR -a EXPR''': True if both expressions are true (logical AND).
    * '''EXPR -o EXPR''': True if either expression is true (logical OR).

    * '''INT -eq INT''': True if both integers are identical.
    * '''INT -ne INT''': True if the integers are not identical.
    * '''INT -lt INT''': True if the first integer is less than the second.
    * '''INT -gt INT''': True if the first integer is greater than the second.
    * '''INT -le INT''': True if the first integer is less than or equal to the second.
    * '''INT -ge INT''': True if the first integer is greater than or equal to the second.

  * Additional tests supported only by `[[`:
    * '''STRING = (or ==) PATTERN''': Not string comparison like with `[` (or `test`), but ''pattern matching'' is performed.  True if the string matches the glob pattern.
    * '''STRING =~ REGEX''': True if the string matches the regex pattern.
    * '''( EXPR )''': Parantheses can be used to change the evaluation precedence.
    * '''EXPR && EXPR''': Much like the '-a' operator of `test`, but does not evaluate the second expression if the first already turns out to be false.
    * '''EXPR || EXPR''': Much like the '-o' operator of `test`, but does not evaluate the second expression if the first already turns out to be true.
    * '''! EXPR''': Inverses the result of the expression.

You want some examples?  Sure:

{{{
    $ test -e /etc/X11/xorg.conf && echo "Your Xorg is configured!"
    Your Xorg is configured!
    $ test -n "$HOME" && echo "Your homedir is set!"
    Your homedir is set!
    $ [[ boar != bear ]] && echo "Boars aren't bears!"
    Boars aren't bears!
    $ [[ boar != b?ar ]] && echo "Boars don't look like bears!"
    $ [[ $DISPLAY ]] && echo "Your DISPLAY variable is not empty, you probably have Xorg running."
    Your DISPLAY variable is not empty, you probably have Xorg running.
    $ [[ ! $DISPLAY ]] && echo "Your DISPLAY variable is not not empty, you probably don't have Xorg running."
}}}

--------
    '''Good Practice:
    [[BR]]
    Whenever you're making a ["BASH"] script, you should always use `[[` (unless if
    for some reason you need very specific and rare functionality from `[`).
    [[BR]]
    Whenever you're making a Shell script, which may end up being used in an environment
    where ["BASH"] is not available, you should use `[`, because it is far more compatible
    (it's an application, not built into ["BASH"], like `[[`).'''
----
    '''In The Manual:
    [http://www.gnu.org/software/bash/manual/bashref.html#SEC20 Conditional Constructs]'''
----
    '''In the FAQ:
    [[BR]]
    [http://wooledge.org/mywiki/BashFAQ/017 How can I group expressions, e.g. (A AND B) OR C?]
    [[BR]]
    [http://wooledge.org/mywiki/BashFAQ/031 What is the difference between the old and new test commands ([ and [[)?]
    [[BR]]
    [http://wooledge.org/mywiki/BashFAQ/041 How do I determine whether a variable contains a substring?]
    [[BR]]
    [http://wooledge.org/mywiki/BashFAQ/054 How can I tell whether a variable contains a valid number?]
    [[BR]]
    [http://wooledge.org/mywiki/BashFAQ/066 I want to check if [[ $var == foo || $var == bar || $var = more ... without repeating $var n times.]'''
--------


[[Anchor(loops)]]
=== Conditional Loops ===

You've learned how to code some basic logic flow for your scripts.  It's important that you understand a thing or two about keeping scripts healthy first.

["BASH"] scripts, much like any other kind of scripts, should never be overrated.  Although they have great potential once you fully understand its features; they aren't always the right tool for the job.  At the same time, when you make scripts, you should remember to keep them light, both in length and in complexity.  Very long and/or very complex scripts are most often also very bad scripts.  Those that aren't yet soon will be; because they are always very difficult to maintain and adapt/extend.

A technique that we can use to try and keep code length and complexity down is loops.  There are two kinds of loops.  Using the correct kind of loop correctly will help you keep your scripts readable and healthy.

["BASH"] supports `while` loops and `for` loops.  The `for` loops can appear in three different forms.  Here's a summary:

  * '''`while [command]`''': Repeat so long as command is executed successfully (exit code: 0).
  * '''`for [variable] in [words]`''': Repeat the loop for each word after putting it into the variable.
  * '''`for (( [expression]; [expression]; [expression] ))`''': Starts by evaluating the first expression, repeats the loop so long as the second expression is valid and at the end of each loop evaluates the third expression.

Let's put that in practice; here are some examples to illustrate the differences but also the similarities between the loops:

{{{
    $ while true
    > do echo "Infinite loop!
    > done

    $ (( i=10 )); while (( i > 0 ))
    > do echo "$i empty cans of beer."
    > (( i-- ))
    > done

    $ for (( i=10; i > 0; i-- ))
    > do echo "$i empty cans of beer."
    > done

    $ for i in {10..0}
    > do echo "$i empty cans of beer."
    > done
}}}

The last three loops achieve exactly the same result; just in a different syntax.  You'll encounter this many times in your shell scripting experience.  There will nearly always be multiple approaches to solving a problem.  The test of your skill soon won't be about solving a problem as much as about how best to solve it.  You need to learn to pick the best angle of approach for the job.  Usually, the main factors to keep into account will be the simplicity and flexibility of the resulting code.  My personal favorite is the latter of the examples.  In the example I used ''Brace Expansion'' to generate the words; but there are other ways, too.

Let's take a closer look at that last example, because although it looks the easier of both `for`s, it can often be the trickiest too; if you don't know exactly how it works.

As I mentioned before; it takes one word from a list of words and puts each in the variable, one at a time, then loops through the code with it.  The tricky part is how ["BASH"] decides what the words are.  Let me explain myself by expanding the braces from that previous example:

{{{
    $ for i in 10 9 8 7 6 5 4 3 2 1 0
    > do echo "$i empty cans of beer."
    > done
}}}

["BASH"] takes the characters between `in` and the end of the statement, at splits them up into words.  You shouldn't confuse the splitting that happens here with the splitting that happens with ''Commandline Arguments''; even though they look exactly the same at first sight.  Commandline arguments are split at ''spaces'', ''tabs'' and ''newlines''; while the splitting in this `for` statement happens at ''spaces'' by default.  This default behaviour can be changed.  The way `for` determines what delimiter to use for the splitting is by looking into the `IFS` variable; and taking the first character there.  `IFS` is an acronym for ''Internal Field Separator''; and by default it contains a ''space'', a ''tab'' and a ''newline''.  Since the ''space'' is the first character there, `for` uses it to split up the words in our sequence; and feeds each word to the variable `i`; one at a time.

'''As a result; be VERY careful not to make the following mistake:'''

{{{
    $ ls
    The best song in the world.mp3
    $ for file in $(ls *.mp3)
    > do rm "$file"
    > done

    rm: cannot remove `The': No such file or directory
    rm: cannot remove `best': No such file or directory
    rm: cannot remove `song': No such file or directory
    rm: cannot remove `in': No such file or directory
    rm: cannot remove `the': No such file or directory
    rm: cannot remove `world.mp3': No such file or directory
}}}

You should already know to quote the `$file` in the `rm` statement; but what's going wrong here?  Right.  ["BASH"] expands the command substitution (`$(ls *.mp3)`), replaces it by its output, and as a result executes `for file in The best song in the world.mp3`.  ["BASH"] splits that up in words by using ''spaces'' and tries to `rm` each word.  ''Boom, you are dead''.

You want to quote it, you say?  Let's add another song:

{{{
    $ ls
    The best song in the world.mp3  The worst song in the world.mp3
    $ for file in "$(ls *.mp3)"
    > do rm "$file"
    > done
    rm: cannot remove `The best song in the world.mp3  The worst song in the world.mp3': No such file or directory
}}}

Quotes will indeed protect the whitespace in your filenames; but it will do more than that.  The quotes will protect '''all the whitespace''' from the output of `ls`.  There is no way ["BASH"] can know which parts of the output of `ls` represent filenames; it's not psychic.  The output of `ls` is a simple string, and ["BASH"] treats it as that for lack of better.  The `for` puts the whole quoted output in `i` and runs the `rm` command with it.  ''Damn, dead again''.

So what do we do?  As suggested earlier; globs are your best friend:

{{{
    $ for file in *.mp3
    > do rm "$file"
    > done
}}}

This time, ["BASH"] '''does''' know which are filenames, and it '''does''' know what the filenames are and as such it can split them up nicely.  The result of expanding the glob is this: `for file in "The best song in the world.mp3" "The worst song in the world.mp3"`. Problem resolved.

Let's talk about changing that delimiter.  Say, you've got yourself a nice cooking recipe, and you want to write a script that tells you how to use it.  Sure, let's get right at it:

{{{
    $ recipe='2 c. all purpose flour
    > 6 tsp. baking powder
    > 2 eggs
    > 2 c. milk
    > 1/3 c. oil'

    $ for ingredient in $recipe
    > do echo "Take $ingredient; mix well."
    > done
}}}

Can you guess what the result will look like?  I recommend you run the code if you can't and ponder the reason first.  It will help you understand things.

Yes, as explained earlier, `for` splits its stuff up in words by using the delimiter from `IFS`.

To read the recipe correctly, we need to split it up by newlines instead of by spaces.  Here's how we do that:

{{{
    $ recipe='2 c. all purpose flour
    > 6 tsp. baking powder
    > 2 eggs
    > 2 c. milk
    > 1/3 c. oil'
    $ IFS=$'\n'

    $ for ingredient in $recipe
    > do echo "Take $ingredient; mix well."
    > done

    Take 2 c. all purpose flour; mix well.
    Take 6 tsp. baking powder; mix well.
    Take 2 eggs; mix well.
    Take 2 c. milk; mix well.
    Take 1/3 c. oil; mix well.
}}}

Beautiful.

'''Note: This delimiter is only used when the words consist of an expansion. Not when they're literal.  Literal words are always split at spaces:'''

{{{
    $ PATH=/bin:/usr/bin
    $ IFS=:

    $ for i in $PATH
    > do echo "$i"
    > done
    /bin
    /usr/bin

    $ for i in $PATH:/usr/local/bin
    > do echo "$i"
    > done
    /bin
    /usr/bin
    /usr/local/bin

    $ for i in /bin:/usr/bin:/usr/local/bin
    > do echo "$i"
    > done
    /bin:/usr/bin:/usr/local/bin
}}}

Lets focus a little more on the `while` loop.  It promises even more simplicity than this `for` loop; so long as you don't need any `for` specific features.  The `while` loop is very interesting for its capacity of executing commands and basing the loop's progress on the result of them.  Here are a few examples of how `while` loops are very often used:

{{{
    $ # The sweet machine; hand out sweets for a cute price.
    $ while read -p $'The sweet machine.\nInsert 20c and enter your name: ' name
    > do echo "The machine spits out three lollipops at $name."
    > done

    $ # Check your email every five minutes.
    $ while sleep 5m
    > do kmail --check
    > done

    $ # Wait for a host to come back online.
    $ while ! ping -c 1 -W 1 "$host"
    > do echo "$host is still unavailable."
    > done; echo -e "$host is available again!\a"
}}}

--------
    '''In The Manual:
    [http://www.gnu.org/software/bash/manual/bashref.html#SEC19 Looping Constructs]'''
----
    '''In the FAQ:
    [[BR]]
    [http://wooledge.org/mywiki/BashFAQ/015 How can I run a command on all files with the extention .gz?]
    [[BR]]
    [http://wooledge.org/mywiki/BashFAQ/018 How can I use numbers with leading zeros in a loop, e.g. 01, 02?]
    [[BR]]
    [http://wooledge.org/mywiki/BashFAQ/020 How can I find and deal with file names containing newlines, spaces or both?]
    [[BR]]
    [http://wooledge.org/mywiki/BashFAQ/030 How can I rename all my *.foo files to *.bar, or convert spaces to underscores, or convert upper-case file names to lower case?]
    [[BR]]
    [http://wooledge.org/mywiki/BashFAQ/034 Can I do a spinner in Bash?]
    [[BR]]
    [http://wooledge.org/mywiki/BashFAQ/046 I want to check to see whether a word is in a list (or an element is a member of a set).]'''
--------




[[Anchor(io)]]
== Input And Output ==

This basic principle of computer science applies just as well to applications started through ["BASH"].  ["BASH"] makes it fairly easy to play around with the input and output of commands, which gives us great flexibility and increadible opportunities for automation.


[[Anchor(fds)]]
=== File Descriptors ===

Input and output from and to processes always occurs via so called ''File Descriptors'' (in short: FDs).  FDs are kind of like pointers to sources of data.  When something reads from or writes to that FD, the data is being read from or written to the FD's data source.  FDs can point to regular files, but they can also point to more abstract data sources, like the input and output source of a process.

By default, every new process has three FDs.  They are referred to by the names ''Standard Input'', ''Standard Output'' and ''Standard Error''.  In short, they are respectively called `stdin`, `stdout` and `stderr`.  The ''Standard Input'' is where the characters you type on your keyboard usually come from.  The ''Standard Output'' is where the program sends most of its normal information to so that the user can see it, and the ''Standard Error'' is where the program sends its error messages to.  Be aware that GUI applications work in the same way; but the actual GUI doesn't work via these FDs.  GUI applications can still read and write from and to the standard FDs, but they usually don't.  Usually, they do all the user interaction via that GUI; making it hard to control for ["BASH"].  As a result, we'll stick to simple console applications.  Those we can easily feed data on the "Standard Input" and read data from on its "Standard Output" and "Standard Error".

Let's make these definitions a little more concrete.  Here's a demonstration of how "Standard Input" and "Standard Output" work:

{{{
    $ read -p "What is your name? " name; echo "Good day, $name.  Would you like some tea?"
    What is your name? lhunath
    Good day, lhunath.  Would you like some tea?
}}}

`read` is a command that reads information from `stdin` and stores it in a variable.  We specified `name` to be that variable.  Once `read` has read a line of information from `stdin`, it finished and lets `echo` display a message.  `echo` uses `stdout` to send its output to.  `stdin` is connected to your terminal's input device; which is probably going to be your keyboard.  `stdout` is connected to your terminal's output device; which I assume is a computer monitor.  As a result; you can type in your name and are then greeted with a friendly message on your monitor, offering you a cup of tea.

So what is `stderr`?  Let's demonstrate:

{{{
    $ rm secrets
    rm: cannot remove `secrets': No such file or directory
}}}

Unless if you had a file called `secrets` in your current directory; that `rm` command will fail and show an error message explaining what went wrong.  Error messages like these are by convention displayed on `stderr`.  `stderr` is also connected to your terminal's output device, just like `stdout`.  As a result, error messages display on your monitor just like the messages on `stdout`. However, this separation makes it easy to keep errors separated from the application's normal messages.  Some people like to use wrappers to make all the output on `stderr` red, so that they can see the error messages more clearly.  This is not generally advisable, but it is a simple example of the many options this separation provides us with.

--------
    '''Good Practice:
    [[BR]]
    Remember that when you create scripts, you should send your custom error messages
    to the `stderr` FD.  This is a convention and it is very convenient when applications
    follow the convention.  As such, so should you!  You'll about redirection soon, but
    let me show you quickly how it's done:'''
{{{
    echo "Uh oh.  Something went really bad.." >&2
}}}
--------


[[Anchor(redirection)]]
=== Redirection ===

The most basic form of input/output manipulation in ["BASH"] is ''Redirection''.  ''Redirection'' is used to change the data source or destination of an application's FDs.  That way, you can send the application's output to a file instead of the terminal, or have the application read from a file instead of from the keyboard.

Redirection, too, comes in different shapes.  There's ''File Redirection'', ''File Descriptor manipulation'', ''Heredocs'' and ''Herestrings''.

--------
    '''In The Manual:
    [http://www.gnu.org/software/bash/manual/bashref.html#SEC37 Redirections]'''
--------

==== File Redirection ====

''File Redirection'' is probably the most basic form of redirection.  I'll start with this so you can grasp the concept of redirection well.

{{{
    $ echo "The story of William Tell.
    >
    > It was a cold december night.  Too cold to write." > story
    $ cat story
    The story of William Tell.
    
    It was a cold december night.  Too cold to write.
}}}

As a result; the `echo` command will not send its output to the terminal, but the `> story` operation '''changes the destination of the `stdout` FD''' so that it now points to a file called `story`.  Be aware that before the `echo` command is executed, ["BASH"] first checks to see whether that file `story` actually exists.  If it doesn't, it is created as an empty file, so that the FD can be pointed to it.  This behaviour can be toggled with ''Shell Options'' (see later).

We then use the application `cat` to print out the contents of that file.  `cat` is an application that reads the contents of all the files you pass it as arguments.  It then outputs each file one after another on `stdout`.  In essence, it con'''cat'''enates the contents of all the files you pass it as arguments.

'''Warning:''' Far too many code examples and shell tutorials on the Internet tell you to use `cat` whenever you need to read the contents of a file.  '''This is highly ill-adviced!''' `cat` only serves well to contatenate contents of multiple files together, or as a quick tool on the shell prompt to see what's inside a file.  You should '''NOT''' use `cat` to read from files in your scripts.  There will almost always be far better ways to do this.  Please keep this warning in mind.  Useless usage of `cat` will merely result in an extra process to create, and often results in poorer read speed because `cat` cannot determine the context of what it's reading and the purpose for that data.

When we use `cat` without passing any kind of arguments, it obviously doesn't know what files to read the content for.  In this case, `cat` will just read from `stdin` instead of from a file (much like `read`).  Since `stdin` is normally not a regular file, starting `cat` without any arguments will seem to do nothing:

{{{
    $ cat
    
}}}

It doesn't even give you back your shell prompt!  What's going on?  `cat` is still reading from `stdin`, which is your keyboard.  Anything you type now will be sent to `cat`.  As soon as you hit the ''Enter'' key, `cat` will do what it normally does; it will display what it reads on `stdout`, just the same way as when it displayed our story on `stdout`:

{{{
    $ cat
    test?
    test?
    
}}}

Why does it say `test?` twice now?  Well, as you type, your terminal shows you all the characters that you send to `stdin` before sending them there.  That results in the first `test?` that you see.  As soon as you hit ''Enter'', `cat` has read a line from `stdin`, and shows it on `stdout`, which is also your terminal; hence, resulting in the second line: `test?`.  You can press ''Ctrl+D'' to send `cat` the ''End of File'' character.  That'll cause `cat` to think the file `stdin` has closed.  It will stop reading from it and return you to your prompt. Let's use file redirection to attach a file to `stdin`, so that `stdin` is no longer reading from our keyboard, but instead, now reads from the file:

{{{
    $ cat < story
    The story of William Tell.
    
    It was a cold december night.  Too cold to write.
}}}

The result of this is exactly the same as the result from our previous `cat story`; except this time, the way it works is a little different.  In our first example, `cat` opened an FD to the file `story` and read its contents through that FD.  In this recent example, `cat` simply reads from `stdin`, just like it did when it was reading from our keyboard.  However, this time, the `< story` operation has '''modified''' `stdin` so that its data source is the file `story` rather than our keyboard.

Let's summarize:

  * '''`command > file`''': Send the `stdout` of command to `file`.
  * '''`command < file`''': Use the contents of `file` when `command` reads from `stdin`.
  * '''`command 1> file`''': Send the `stdout` of command to `file`.
  * '''`command <0 file`''': Use the contents of `file` when `command` reads from `stdin`.

Redirection operators can take a number.  That number denotes the FD that it changes.  If the number is not present, the `>` operator uses FD 1 by default, because that is the number for `stdout`.  `<` uses FD 0 by default, because that is the number for `stdin`.  The number for the `stderr` FD is 2.  So, let's try sending the output of `stderr` to a file:

{{{
    $ for homedir in /home/*
    > do rm "$homedir/secret"
    > done 2> errors
}}}

In this example, we're looping over each file in `/home`.  We then try to delete the file `secret` in each of them.  Some `homedir`s may not have a secret.  As a result, the `rm` operation will fail and send an error message on `stderr`.

You may have noticed that our redirection operator isn't on `rm`, but it's on that `done` thing.  Why is that?  Well, this way, the redirection applies to all output to `stderr` made inside the whole loop.

Let's see what the result of our loop was?

{{{
    $ cat errors
    rm: cannot remove `/home/axxo/secret': No such file or directory
    rm: cannot remove `/home/lhunath/secret': No such file or directory
}}}

Two error messages in our error log file.  Two people that didn't have a `secret` file in their home directory.

If you're writing a script, and you expect that running a certain command may fail on occasion, but don't want the script's user to be bothered by the possible error messages that command may produce, you can silence an FD.  Silencing it is as easy as normal ''File Redirection''.  We're just going to send all output to that FD into the system's black hole:

{{{
    $ for homedir in /home/*
    > do rm "$homedir/secret"
    > done 2> /dev/null
}}}

The file `/dev/null` is '''always''' empty, no matter what you write or read from it.  As such, when we write our error messages to it, they just disappear.  The `/dev/null` file remains as empty as ever before.  That's because it's not a normal file, it's a ''virtual'' device.

There is one last thing you should learn about ''File Redirection''.  It's interesting that you can make error log files like this to keep your error messages; but as I mentioned before, ["BASH"] makes sure that the file exists before trying to redirect to it.  ["BASH"] '''also makes sure the file is empty''' before redirecting to it.  As a result, each time we run our loop to delete secret files, our log file will be truncated empty before we fill it up again with new error messages.  What if we'd like to keep a record of any error messages generated by our loop?  What if we don't want that file to be truncated each time we start our loop?  The solution is achieved by doubling the redirection operator.  `>` becomes `>>`.  `>>` will not empty a file, it will just append new data to the end of it!

{{{
    $ for homedir in /home/*
    > do rm "$homedir/secret"
    > done 2>> errors
}}}

Hooray!

--------
    '''Good Practice:
    [[BR]]
    It's a good idea to use redirection whenever an application needs file data and
    is built to read data from `stdin`.  A lot of bad examples on the Internet tell
    you to pipe (see later) the output of `cat` into processes; but this is nothing more
    than a very ''bad'' idea.'''
----
    '''In The Manual:
    [http://www.gnu.org/software/bash/manual/bashref.html#SEC38 Redirecting Input],
    [http://www.gnu.org/software/bash/manual/bashref.html#SEC39 Redirecting Output],
    [http://www.gnu.org/software/bash/manual/bashref.html#SEC40 Appending Redirected Output],
    [http://www.gnu.org/software/bash/manual/bashref.html#SEC41 Redirecting Standard Output and Standard Error]'''
--------

==== File Descriptor Manipulation ====

Now that you know how to manipulate process input and output by sending it to and reading it from files; let's make this a little more interesting still.

It's possible to change the source and desination of FDs to point to or from files, that you know.  It's also possible to copy one FD to another.  Let's prepare a simple testbed:

{{{
    $ echo "I am a proud sentence." > file
}}}

We've made a file called `file`, and written a proud sentence into it.  It's time I introduce a new application to you.  Its name is `grep`, and it's increadibly powerful.  `grep` is that one thing that you need more than anything else in your household.  It basically takes a ''search string'' as its first argument and one or more files as extra arguments.  Just like `cat`, `grep` also uses `stdin` if you don't specify any files as extra arguments.  `grep` reads the files (or `stdin` if none were provided) and searches for the ''search string'' you gave it.  Most versions of `grep` even support a `-r` switch, which makes it take directories as well as files as extra arguments, and then searches all the files and directories in those directories that you gave it.  Here's an example of how `grep` can work:

{{{
    $ ls house/
    house/drawer  house/closet  house/dustbin  house/sofa
    $ grep -r socks house/
    house/sofa:socks
}}}

In this silly example we have a directory called house with several pieces of furniture in it as files.  If we're looking for our `socks` in each of those files, we send grep to search the directory `house/`.  `grep` will search everything in there, open each file and look through its contents.  In our example, grep finds `socks` in the file `house/sofa`; presumably tucked away under a pillow.  You want a more realistic example?  Sure:

{{{
    $ grep "$HOSTNAME" /etc/*
    /etc/hosts:127.0.0.1       localhost Lyndir
}}}

Here we instruct `grep` to search for whatever `$HOSTNAME` expands to in whatever `/etc/*` expands to.  It finds my hostname, which is `Lyndir` in the file `/etc/hosts`, and shows me the line in that file that contains the ''search string''.

OK, now that you understand `grep`, let's continue with our ''File Descriptor Manipulation''.  Remeber that we created a file called `file`, and wrote a proud sentence to it?  Let's use `grep` to find where that proud sentence is now:

{{{
    $ grep proud *
    file:I am a proud sentence.
}}}

Good, `grep` found our sentence in `file`.  It writes the result of its operation to `stdout` which is shown on our terminal.  Now let's see if we can make grep send an error message, too:

{{{
    $ grep proud file 'not a file'
    file:I am a proud sentence.
    grep: not a file: No such file or directory
}}}

This time, we instruct `grep` to search for the string `proud` in the files '`file`' and '`not a file`'.  `file` exists, and the sentence is in there, so `grep` happily writes the result to `stdout`.  It moves on to the next file to scan, which is '`not a file`'.  `grep` can't open this file to read its content, because it doesn't exist.  As a result, `grep` emits an error message on `stderr` which is still connected to our terminal.

Now, how would you go about silencing this `grep` statement completely?  We'd like to send all the output that appears on the terminal to a file instead; let's call it `proud.log`:

{{{
    $ grep proud file 'not a file' > proud.log 2> proud.log
}}}

Does that look about right?  We first use `>` to send `stdout` to `proud.log`, and then use `2>` to send `stderr` to `proud.log` as well.  Almost, but not quite.  If you run this command and then look in `proud.log`, you'll see there's only an error message, not the output from `stdout`.  We've created a very bad condition here.  After `stdout` has written its output to the log file, the error message needs to be written to the log file.  The `stderr` redirection truncates the log file and writes its own information there.  Things would go even more wrong if after that new information arrives on `stdout`.  `stdout`'s write operation might cancel an active write operation from `stderr` to continue writing its own information.

We need to prevent having two FDs working on the same destination or source.  We can do this by dublicating FDs:

{{{
    $ grep proud file 'not a file' > proud.log 2>&1
}}}

You need to remember to always read file redirections from right to left.  This is the order in which ["BASH"] assigns and processes them.  First, `stdout` is changed so that it points to our `proud.log`.  Then, we use the `>&` syntax to dublicate FD 1 and put this dublicate in FD 2's stead.  If this is hard for you to grasp, you could read this as: `stdout becomes proud.log and stderr becomes stdout (which is proud.log)`.  As a result, `stdout` obviously writes its information to `proud.log`, but `stderr` writes its information to whatever `stdout` was when the `>&` redirector was used; which was `proud.log` as well.  In this case, the handle that writes to `proud.log` is the same for both `stdout` and `stderr`, and no collisions occur.

Be careful not to confuse the order:

{{{
    $ grep proud file 'not a file' 2>&1 > proud.log
}}}

This would read as `stderr becomes stdout (which is the terminal) and stdout becomes proud.log`.  As a result, `stdout`'s messages will be logged, but the error messages will still go to the terminal.  ''Oops''.

'''Note:
[[BR]]
For compatibility reasons with other shells, ["BASH"] also makes yet another form of redirection available to you. The `&>` redirection operator is actually just a shorter version of what we did here; redirecting both `stdout` and `stderr` to a file:'''

{{{
    $ grep proud file 'not a file' &> proud.log
}}}

This is the same as `> proud.log 2>&1`, just a bit shorter.  You pick.

'''''TODO: Moving FDs and Opening FDs RW.'''''

--------
    '''In The Manual:
    [http://www.gnu.org/software/bash/manual/bashref.html#SEC44 Dublicating File Descriptors],
    [http://www.gnu.org/software/bash/manual/bashref.html#SEC45 Moving File Descriptors],
    [http://www.gnu.org/software/bash/manual/bashref.html#SEC46 Opening File Descriptors for Reading and Writing]'''
----
    '''In the FAQ:
    [[BR]]
    [http://wooledge.org/mywiki/BashFAQ/014 How can I redirect the output of multiple commands at once?]
    [[BR]]
    [http://wooledge.org/mywiki/BashFAQ/032 How can I redirect the output of 'time' to a variable or file?]
    [[BR]]
    [http://wooledge.org/mywiki/BashFAQ/040 How do I use dialog to get input from the user?]
    [[BR]]
    [http://wooledge.org/mywiki/BashFAQ/047 How can I redirect stderr to a pipe?]
    [[BR]]
    [http://wooledge.org/mywiki/BashFAQ/055 Tell me all about 2>&1 -- what's the difference between 2>&1 >foo and >foo 2>&1, and when do I use which?]'''
--------

==== Heredocs And Herestrings ====

Files aren't all that.  They're boring, really.  Strings are so much more interesting.  They're not permanent like files on a hard disk, but they're easy to work with, easy to make an easy to manipulate.

''Heredocs'' and ''Herestrings'' allow you to perform ''Redirection'' as you would with files, just by using strings instead.  Let's try it out!

{{{
    $ grep proud <<END
    > I am a proud sentence.
    > END
    I am a proud sentence.
}}}

This is a ''Heredoc''.  ''Heredocs'' aren't really useful unless if you're trying to embody long strings of several lines inside your scripts; which is '''very bad practice'''.  The way they work, is by adding the `<<STRING` operator at the end of a command.  That'll tell that command's `stdin` that it has to start reading input from the script (or the command line, if you're not in a script).  The input of the ''Heredoc'' stops as soon as you repeat whatever string you used to add to the end of the `<<`.  In the example above, I used the string `END`; but it can really be anything (so long as you quote it if it has whitespace).

Let's check out the very similar but more interesting ''Herestrings'':

{{{
    $ grep proud <<<"I am a proud sentence"
    I am a proud sentence.
}}}

This time, `stdin` reads its information straight from the string you put after the `<<<` operator.  This is very convenient to send data that's in variables into processes:

{{{
    $ grep proud <<<"$USER sits proudly on his throne in $HOSTNAME."
    lhunath sits proudly on his throne in Lyndir.
}}}

--------
    '''Good Practice:
    [[BR]]
    Heredocs are usually a bad idea because scripts should contain logic, not data.
    If you have a document that your script needs; you should ship it in a separate
    file along with your script.  Herestrings, however, come in handy quite often;
    especially for sending variable content to processes like `grep` or `sed` instead
    of files.'''
----
    '''In The Manual:
    [http://www.gnu.org/software/bash/manual/bashref.html#SEC42 Here Documents],
    [http://www.gnu.org/software/bash/manual/bashref.html#SEC43 Here Strings]'''
--------
+<<Include(BashGuide/Introduction, , editlink)>>
<<Include(BashGuide/TheBasics, , editlink)>>
<<Include(BashGuide/Practices, , editlink)>>

Diff for "BashGuide"