Finding Things¶
In the same way that many of us now use "Google" as a verb meaning "to find", Unix programmers often use the word "grep". "grep" is a contraction of "global/regular expression/print", a common sequence of operations in early Unix text editors. It is also the name of a very useful command-line program.
grep finds and prints lines in files that match a pattern. For our examples, we will use a file that contains three haikus taken from a 1998 competition in Salon magazine. For this set of examples, we're going to be working in the writing subdirectory:
%%bash2 --dir ~/library/data/data-shell
cd writing
cat haiku.txt
Let's find lines that contain the word "not":
%%bash2
grep not haiku.txt
Here, not is the pattern we're searching for. The grep command searches through the file, looking for matches to the pattern specified. To use it type grep, then the pattern we're searching for and finally the name of the file (or files) we're searching in.
The output is the three lines in the file that contain the letters "not".
Let's try a different pattern: "The".
%%bash2
grep The haiku.txt
This time, two lines that include the letters "The" are outputted. However, one instance of those letters is contained within a larger word, "Thesis".
To restrict matches to lines containing the word "The" on its own, we can give grep with the -w flag. This will limit matches to word boundaries.
%%bash2
grep -w The haiku.txt
Note that a "word boundary" includes the start and end of a line, so not just letters surrounded by spaces. Sometimes we don't want to search for a single word, but a phrase. This is also easy to do with grep by putting the phrase in quotes.
%%bash2
grep -w "is not" haiku.txt
We've now seen that you don't have to have quotes around single words, but it is useful to use quotes when searching for multiple words. It also helps to make it easier to distinguish between the search term or phrase and the file being searched. We will use quotes in the remaining examples.
Another useful option is -n, which numbers the lines that match:
%%bash2
grep -n "it" haiku.txt
Here, we can see that lines 5, 9, and 10 contain the letters "it".
We can combine options (i.e. flags) as we do with other Unix commands. For example, let's find the lines that contain the word "the". We can combine the option -w to find the lines that contain the word "the" and -n to number the lines that match:
%%bash2
grep -n -w "the" haiku.txt
Now we want to use the option -i to make our search case-insensitive:
%%bash2
grep -n -w -i "the" haiku.txt
Now, we want to use the option -v to invert our search, i.e., we want to output the lines that do not contain the word "the".
%%bash2
grep -n -w -v "the" haiku.txt
grep has lots of other options. To find out what they are, we can type:
%%bash2
grep --help | head -20 # Remove `| head -20` to see full output
While grep finds lines in files, the find command finds files themselves. Again, it has a lot of options; to show how the simplest ones work, we'll use the directory tree shown below.
Nelle's writing directory contains one file called haiku.txt and three subdirectories: thesis (which contains a sadly empty file, empty-draft.md); data (which contains three files LittleWomen.txt, one.txt and two.txt); and a tools directory that contains the programs format and stats, and a subdirectory called old, with a file oldtool.
For our first command, let's run find ..
%%bash2
find .
As always, the . on its own means the current working directory, which is where we want our search to start. find's output is the names of every file and directory under the current working directory. This can seem useless at first but find has many options to filter the output and in this lesson we will discover some of them.
The first option in our list is -type d that means "things that are directories". Sure enough, find's output is the names of the five directories in our little tree (including .):
%%bash2
find . -type d
Notice that the objects find finds are not listed in any particular order. If we change -type d to -type f, we get a listing of all the files instead:
%%bash2
find . -type f
Now let's try matching by name:
%%bash2
find . -name *.txt
We expected it to find all the text files, but it only prints out ./haiku.txt. The problem is that the shell expands wildcard characters like * before commands run. Since *.txt in the current directory expands to haiku.txt, the command we actually ran was:
%%bash2
find . -name haiku.txt
find did what we asked; we just asked for the wrong thing.
To get what we want, let's do what we did with grep: put *.txt in single quotes to prevent the shell from expanding the * wildcard. This way, find actually gets the pattern *.txt, not the expanded filename haiku.txt:
%%bash2
find . -name '*.txt'
As we said earlier, the command line's power lies in combining tools. We've seen how to do that with pipes; let's look at another technique. As we just saw, find . -name '*.txt' gives us a list of all text files in or below the current directory. How can we combine that with wc -l to count the lines in all those files?
The simplest way is to put the find command inside $():
%%bash2
wc -l $(find . -name '*.txt')
When the shell executes this command, the first thing it does is run whatever is inside the $(). It then replaces the $() expression with that command's output. Since the output of find is the four filenames ./data/one.txt, ./data/LittleWomen.txt, ./data/two.txt, and ./haiku.txt, the shell constructs the command:
%%bash2
wc -l ./data/one.txt ./data/LittleWomen.txt ./data/two.txt ./haiku.txt
which is what we wanted. This expansion is exactly what the shell does when it expands wildcards like * and ?, but lets us use any command we want as our own "wildcard".
It's very common to use find and grep together. The first finds files that match a pattern; the second looks for lines inside those files that match another pattern. Here, for example, we can find PDB files that contain iron atoms by looking for the string "FE" in all the .pdb files above the current directory:
%%bash2
grep "FE" $(find .. -name '*.pdb')
The Unix shell is older than most of the people who use it. It has survived so long because it is one of the most productive programming environments ever created - maybe even the most productive. Its syntax may be cryptic, but people who have mastered it can experiment with different commands interactively, then use what they have learned to automate their work. Graphical user interfaces may be better at the first, but the shell is still unbeaten at the second. And as Alfred North Whitehead wrote in 1911, "Civilization advances by extending the number of important operations which we can perform without thinking about them."