Linux command: cat

Almost everyone who uses Linux reaches for cat within the first hour. You type it to read a config file, to peek at a log, or to dump a short script to the screen. It feels like "the command that prints a file". That is true, but it is not the whole story, and it is not even what the name means. The real job of cat is to join files together, and once you see that, a lot of Unix suddenly fits into place.

2. Where the Name Comes From

The name cat is short for concatenate, which means "to link together in a series". It has nothing to do with the animal.

cat  =  conCATenate

The name tells you the original purpose exactly. In early Unix, if you wanted to join three files into one, you ran cat part1 part2 part3 and captured the combined output. Printing a single file to the screen was a happy side effect: joining one file and letting the result fall onto the terminal.

Like most early Unix commands, the name was kept short on purpose. Early Unix was typed on slow teletype terminals that printed each character onto paper, so short names saved both time and ink. That is why cat is three letters and not "concatenate".

4. Simple Use Cases

4.1 The Simplest Possible Use

Give cat a filename and it prints that file to the screen. In the examples below, the line that starts with $ is what you type, and the lines under it are what the system prints back.

$ cat notes.txt
Buy milk
Call the dentist
Finish the report

The whole file is sent to the terminal at once. This is ideal for short files: a config file, a small script, a note. For long files it is the wrong tool, and section 7 explains why.

4.2 Joining Several Files: The Original Job

Give cat more than one file and it prints them in order, one after another, with no separator between them. This is the concatenation the name promises:

$ cat chapter1.txt chapter2.txt chapter3.txt
(the full text of chapter 1)
(the full text of chapter 2)
(the full text of chapter 3)

On its own this just floods the screen. It becomes useful the moment you send the combined stream somewhere, which brings us to redirection.

4.3 Saving the Result to a New File

The shell operator > redirects standard output into a file instead of the screen. Combine it with cat to actually join files into a new one:

$ cat chapter1.txt chapter2.txt chapter3.txt > book.txt

Now book.txt contains the three chapters, in order, as one file. This single line is the reason cat exists. Note that the joining is done by cat, but the saving is done by the shell's >, not by cat itself.

A useful distinction: cat produces a stream, the shell decides where the stream goes. > writes it to a new file, >> appends it to an existing one, and a pipe | hands it to the next command.

4.4 Reading From the Keyboard

Run cat with no filename at all and it reads from standard input, which by default is your keyboard. It echoes back each line you type until you press Ctrl-D, the key that signals "end of input":

$ cat
hello
hello
this is a test
this is a test
[Ctrl-D]

Combine that with a redirect and you have the classic quick way to create a short file without opening an editor:

$ cat > shopping.txt
milk
eggs
bread
[Ctrl-D]
$ cat shopping.txt
milk
eggs
bread

You type the lines, press Ctrl-D, and the text lands in shopping.txt. It is not an editor, so you cannot go back and fix a line above, but for three lines it is faster than anything else.

6. Advanced Use Cases

6.1 Appending and Building Files

With >> you add to the end of a file instead of overwriting it. This lets you assemble a file piece by piece:

$ cat header.txt > page.html      # start fresh (overwrites)
$ cat body.txt >> page.html       # add to the end
$ cat footer.txt >> page.html     # add to the end again

Be careful with the single >: it truncates the target to empty before writing. A common and painful mistake is cat a.txt > a.txt, which empties the file before cat ever reads it. To combine a file with others in place, write to a new name first.

6.2 The Dash: Mixing Files and Standard Input

A single dash - stands for standard input in the file list, so you can splice piped data between real files. This example puts a header, then whatever another command sends, then a footer:

$ echo "=== start ===" | cat header.txt - footer.txt

Here cat prints header.txt, then the text arriving on standard input (the line from echo), then footer.txt. The dash is a small feature that turns cat into a flexible stream-joiner.

6.3 Here-Documents: A Better Way to Write a Block

The keyboard-and-Ctrl-D trick from section 4 has a cleaner cousin called a here-document. You give the shell a marker word, and everything up to that word becomes the input. This is the professional way to write a block of text into a file, especially inside scripts:

$ cat > config.yml <<EOF
server: web01
port: 8080
debug: false
EOF

Everything between <<EOF and the closing EOF is fed to cat, which writes it to config.yml. The marker can be any word; EOF is just the common convention. If you quote the marker as <<'EOF', the shell leaves $variables untouched instead of expanding them, which matters when the block contains dollar signs.

6.4 cat as a Building Block in Pipes

Because cat just prints text, it feeds naturally into the rest of the Unix toolbox through a pipe:

$ cat access.log | wc -l           # count the lines
$ cat *.txt | sort | uniq          # merge, sort, remove duplicates
$ cat notes.md | grep TODO         # find matching lines

The middle example is where cat genuinely shines: joining many files (*.txt) into a single stream before handing it to sort. That is real concatenation doing real work. The first and last examples, however, are a trap that section 7 explains.

6.5 tac: cat Backwards

GNU ships a companion called tac, which is cat spelled backwards and does exactly that: it prints a file with its lines in reverse order, last line first.

$ tac notes.txt
Finish the report
Call the dentist
Buy milk

It is genuinely useful for logs, where the newest entries sit at the bottom. tac error.log | head shows you the most recent lines first.

8. Best Practices

• Use cat for what it is named after. Reach for it when you join several files. For a single file feeding another command, give that command the filename directly.
• Do not cat a large file. Use less to read it, or head and tail for the ends. Save your terminal buffer and your patience.
• Never redirect a file onto itself. cat a > a empties the file. Write to a new name, then rename it if needed.
• Reveal hidden characters when a match fails. When a script does not behave, run cat -A to expose tabs, trailing spaces, and stray line endings.
• Reach for the manual without hesitation. The habit that separates beginners from professionals is not memorising every flag; it is typing man cat the moment a question comes up.

$ man cat                            # the full manual page
$ cat --help                         # a quick flag summary (GNU)
$ info coreutils 'cat invocation'    # the verbose GNU manual

10. Summary

The cat command looks trivial, but it is a clean lesson in how Unix reads input and writes output.

• cat means "concatenate". Its real job is to join files and send the result to standard output; printing one file is the simple case.
• It dates back to Unix in 1971 and runs, unchanged in spirit, on every Unix-like system today.
• cat a b c > out joins files into a new one. > overwrites, >> appends, and a pipe | hands the stream to the next command.
• With no filename, cat reads the keyboard until Ctrl-D. A here-document (<<EOF) is the cleaner way to write a block of text.
• Useful flags: -n and -b number lines, -s squeezes blank lines, and -A reveals tabs, line ends, and hidden characters.
• The dash - means standard input, so you can splice piped data between real files. tac prints a file in reverse.
• Avoid the "useless use of cat": if the next command can read a file itself, skip cat and the pipe.
• Under the hood, cat is a small loop of read() and write() over the three standard streams: stdin (0), stdout (1), and stderr (2). It copies bytes without interpreting them.
• Know where cat stops: less to read long files, head and tail for the ends, grep to search, tee to save and display at once, and xxd or strings for binaries.
• When in doubt, type man cat.

This is the quick reference worth keeping:

cat file             print one file
cat a b c            join files, in order, to the screen
cat a b c > out      join files into a new file
cat f1 >> f2         append f1 to the end of f2
cat > file           type text, end with Ctrl-D
cat -n file          print with line numbers
cat -A file          reveal tabs, line ends, and control chars
cat -s file          collapse repeated blank lines
grep x file          NOT cat file | grep x
less file            read a long file the right way
tee file             save a stream to a file AND the screen
tac file             print a file in reverse