Use of Pipes on Unix systems

Pipes in Unix-like systems, such as Debian, are a powerful tool that allow us to combine and redirect the output of commands efficiently. By using pipes, we can take the output of one command and send it directly as input to another, allowing us to perform more complex tasks and save time by avoiding the use of temporary files. In this manual, we will explore in detail how to use pipes in Debian to improve our command line productivity.

1. Pipes Basics

Pipes are represented by the vertical symbol |. When used on the command line, it indicates that the output of the command to the left of the pipe will be the input of the command to the right of the pipe.

Example 1:

ls | grep archivo

In this example, the output of the ls, command, which lists the files in the current directory, will be sent as input to the grep command which will filter out only the lines containing the word "file".

2. Pipes with Simple Commands

Pipes are especially useful when combined with simple commands to perform specific tasks.

Example 2:

ls -l | grep "archivo.txt" | wc -l

In this example, we list the contents of the directory in long format (ls -l), filter out only the lines containing "archivo.txt" (grep "archivo.txt"), and finally, count how many lines match (wc -l). This will give us the number of files named "file.txt" in the current directory.

3. Pipes with More Complex Command

Pipes are also effective when combined with more complex commands and additional options.

Example 3:

ps aux | grep "firefox" | awk '{print $2}' | xargs kill -9

In this example, we use pipes to find the process ID (PID) of the Firefox run, filter it using grep, extract just the PID using awk, and then send that PID as an argument to kill (forcibly terminate) the process using kill -9.

4. Multiple Chained Pipes

It is possible to chain multiple pipes together to perform even more complex tasks.

Example 4:

cat access.log | grep "Error" | sort | uniq -c | sort -nr

In this example, we read the contents of the access.log, file, filter out only the lines containing "Error" (grep "Error"), then sort the lines alphabetically (sort), count how many times each line appears (uniq -c), and finally, sort the result in reverse order of frequency (sort -nr). This will give us a summary of the most frequent errors in the log file.

5. Pipes and File Redirection

We can combine pipes with file redirection to save the results in a file.

Example 5:

ls -l | grep "archivo.txt" > resultado.txt

In this example, we list the contents of the directory in long format, filter out only the lines containing "archivo.txt", and redirect the output to a file named resultado.txt.

6. Pipes with Custom Commands

In addition to the standard commands, we can use our own scripts or custom commands and combine them with pipes.

Example 6:

mi_script.py | grep "patrón" | sed 's/foo/bar/g'

In this example, we run our custom script mi_script.py, filter out the lines containing the desired pattern, and then use the sed command to replace all occurrences of "foo" with "bar".

Conclusion

Pipes on Unix-like systems, such as Debian, are a powerful tool that can significantly improve our command line efficiency. By combining and redirecting the output of different commands, we can perform more complex tasks quickly and effectively. With this manual, we hope to have provided you with a solid understanding of the use of pipes on Unix systems, allowing you to take full advantage of this functionality for your daily system administration and data analysis tasks.