tac commands display the contents of text files, but there’s more to them than meets the eye. Dive a little deeper and learn some productive Linux command line tricks.
These are two simple little commands, often dismissed as being just that—too simple to be of any real use. But once you know the different ways you can use them, you’ll see that they are perfectly capable of doing their fair share of the heavy lifting when it comes to working with files.
The cat Command
cat is used to examine the contents of text files, and to join parts of files together to form a larger file.
At one time—back in the era of the dial-up modem—binary files were often broken into several smaller files to make downloading easier. Instead of downloading one large file, you pulled back each smaller file. If a single file failed to download correctly, you would just retrieve that one file again.
Of course, you then needed a way to reconstitute the collection of smaller files back into the single working binary file. That process was called concatenating. And that’s where
cat came in and where it gets its name from.
Broadband and fiber connections have caused that particular need to fade—much like screechy dial-ups sounds—so what’s left for
cat to do today? Quite a lot actually.
Displaying a Text File
cat list the contents of a text file to a terminal window, use the following command.
Make sure the file is a text file. If you try to list the contents of a binary file to the terminal window, the results will be unpredictable. You might end up with a locked terminal session or worse.
The contents of the file poem1.txt are shown in the terminal window.
That’s only half of the famous poem. Where’s the rest of it? There ‘s another file here called poem2.txt. We can make
cat list the contents of multiple files with one command. All we need to do is list the files in order on the command line.
cat poem1.txt poem2.txt
That looks better; we have the whole poem now.
Using cat With less
The poem is all there, but it shot past the window too fast to read the first few verses. We can pipe the output from
less and scroll down through the text at our own pace.
cat poem1.txt poem2.txt | less
We can now move backward and forward through the text in one stream, even though it is held in two separate text files.
Numbering the Lines in a File
We can have cat number the lines in the file as it is displayed. To do this, we use the
-n (number) option.
cat -n poem1.txt
The lines are numbered as they are displayed in the terminal window.
Don’t Number Blank Lines
We managed to have the lines numbered by
cat, but the blank lines between the verses are being counted as well. To have the text lines numbered but to ignore the blank lines, use the
-b (number-nonblank) option.
cat -b poem1.txt
Now the text lines are numbered, and the blanks lines are skipped.
Don’t Show Multiple Blank Lines
If there are sections of consecutive blank lines in a file, we can ask
cat to ignore all but one blank line. Look at this file.
The next command will cause
cat to display only one blank line from each bunch of blank lines. The option we need to achieve this is the
-s (squeeze-blank) option.
cat -s poem1.txt
This doesn’t affect the contents of the file in any way; it just changes the way
cat displays the file.
If you want to know whether whitespace is caused by spaces or tabs, you can find out using the
-T (show-tabs) option.
cat -T poem1.txt
The tabs are represented by the characters “^I”.
Displaying the Ends of Lines
You can check for trailing whitespace by using the
-E (show-ends) option.
cat -E poem1.txt
The ends of lines are represented by the “$” character.
It doesn’t make sense to have a poem saved in two files, with one half in each. Let’s join them together and make a new file with the entire poem in it.
cat poem1.txt poem2.txt > jabberwocky.txt
cat to check our new file:
Our new file contains the contents of the other two files.
Appending Text to an Existing File
That’s better, but in actual fact, it’s not the entire poem. The last verse is missing. The last verse in Jabberwocky is the same as the first verse.
If we’ve got the first verse in a file, we can add this to the bottom of the jabberwocky.txt file, and we’ll have the complete poem.
In this next command, we have to use
>>, not just
>. If we use a single
> we’ll overwrite jabberwocky.txt. We don’t want to do that. We want to append text to the bottom of it.
cat first_verse.txt >> jabberwocky.txt
Let’s check the contents of the jabberwocky.txt file:
And finally, all the parts of the poem are together.
You can redirect input from the keyboard into a file using
cat. Everything you type is redirected into the file until you hit Ctrl+D. Note that we use a single
> because we want to create the file (or overwrite it, if it exists).
cat > my_poem.txt
We can start typing as soon as we issue the command. We hit Ctrl+D when we’ve finished. We can then check the contents of the new file with:
That sound like a far-off turbine is probably Lewis Carroll spinning in his grave at high speed.
The tac Command
tac is similar to
cat, but it lists the contents of files in reverse order.
Let’s see that:
And the file is listed to the terminal window in reverse order. In this case, it has no effect on its literary merits.
Using tac With stdin
tac without a filename will cause it to operate on the input from the keyboard. Hitting Ctrl+D will stop the input phase, and tac will list in reverse order whatever you’d typed in.
When Ctrl+D is hit, the input is reversed and listed to the terminal window.
Using tac With Log Files
Apart from low-grade parlor tricks, can
tac do anything useful? Yes, it can. Many log files append their newest entries at the bottom of the file. Using
tac (and, counterintuitively,
head) we can pop the last entry into the terminal window.
tac to list the syslog file in reverse, and pipe it into
head. By telling
head to only print the first line it receives (which thanks to
tac is the last line in the file), we see the latest entry in the syslog file.
tac /var/log/syslog | head -1
head prints the latest entry from the syslog file and then exits.
head is only printing one line—as we requested—but the line is so long it wraps around twice. That’s why it looks like three lines of output in the terminal window.
Using tac with Text Records
The last trick
tac has up its sleeve is a beauty.
tac operates on text files by working its way through them line by line, from the bottom up. A line is a sequence of characters terminated by a newline character. But we can tell
tac to work with other delimiters. This allows us to treat “chunks” of data within the text file as data records.
Let’s say we have a log file from some program that we need to review or analyze. Let’s have a look at its format with
As we can see, there is a repeating format to the file. There are sequences of three lines of hexadecimal values. Each set of three lines of hexadecimal has a label line that starts “=SEQ”, followed by a sequence of digits.
If we scroll to the bottom of the file, we can see that there are a lot of these records. The final one is numbered 865.
Let’s assume that for whatever reason we need to work through this file in reverse order, data record by data record. The line order of the three hexadecimal lines in each data record must be preserved.
We’ll make a note that the final three lines in the file start with hexadecimal values 93, E7 and B8, in that order.
tac to reverse the file. It is a very long file so we’ll pipe it into
tac logfile.dat | less
That reverses the file, but it isn’t the result we want. We want the file to be reversed, but the lines in each data record must be in their original order.
We recorded earlier that the final three lines in the file start with hexadecimal values 93, E7 and B8, in that order. The order of those lines has been reversed. Also, the “=SEQ” lines are now below each set of three hexadecimal lines.
tac to the rescue.
tac -b -r -s ^=SEQ.+[0-9]+*$ logfile.dat | less
Let’s break that down.
-s (separator) option informs
tac what we want to use as the delimiter between our records. It tells
tac not to use its usual newline character, but to use our separator instead.
-r (regex) option tells
tac to treat the separator string as a regular expression.
-b (before) option causes
tac to list the separator before each record instead of after it (which is the usual position of its default separator, the newline character).
-s (separator) string
^=SEQ.+[0-9]+*$ is deciphered as follows:
^ character represents the start of the line. This is followed by
=SEQ.+[0-9]+*$. This instructs
tac to look for each occurrence of “=SEQ.” at the start of a line, followed by any sequence of digits (indicated by
[0-9]), and followed by any other set of characters (indicated by
We’re piping the whole lot into
less, as usual.
Our file is now presented in reverse order with each “=SEQ” label line listed before its three lines of hexadecimal data. The three lines of hexadecimal values are in their original order within each data record.
We can check this simply. The first value of the first three lines of hexadecimal (which were the last three lines before the file was reversed) match the values that we took a record of earlier: 93, E7 and B8, in that order.
That’s quite a trick for a terminal window one-liner.
Everything Has a Purpose
In the Linux world, even the seemingly simplest commands and utilities can have surprising and powerful properties.
The design philosophy of simple utilities that do one thing well, and which easily interwork with other utilities, has given rise to some strange little commands, such as
tac. At first glance, it appears to be a bit of an oddity. But when you peer beneath the surface, there is an unexpected power that you can leverage to your advantage.
Or, as another philosophy says, “Do not despise the snake for having no horns, for who is to say it shall not become a dragon?”