Using Pipe and Redirection

Follow Us

Our Communities

Think of this chapter as the plumbing of your Bash scripts, allowing data to flow seamlessly between commands, enabling powerful data manipulation and automation.

Let’s explore the philosophy behind this chapter, the skills you’ll acquire, and why it’s a pivotal point in your journey to becoming a proficient Bash scripter.

What You Will Learn

Input and Output Redirection

You’ll discover how to redirect the standard input and output streams, enabling you to control where data comes from and where it goes.

Pipes and Data Flow

Learn the magic of pipes (|) and how they connect commands, letting you chain multiple operations together effortlessly.

Error Handling and Redirection

Master the art of redirecting error messages (stderr), ensuring your scripts handle exceptions gracefully.

Advanced Redirection Techniques

Explore more advanced techniques like here documents and process substitution, expanding your scripting toolkit.

Personal Experience

As a seasoned scripter, I can attest to the transformative power of pipe and redirection in Bash scripting.

When I first delved into this topic, it was like discovering a hidden passage to a world of efficiency and elegance. I realized that mastering this chapter not only made my scripts cleaner but also vastly expanded their capabilities.

Whether you’re processing log files, automating data analysis, or building complex pipelines, pipe and redirection are indispensable tools in your arsenal.

Importance of Chapter 7

Chapter 7 is the pivot point of our tutorial. It’s where the foundational knowledge from earlier chapters converges to unlock the true potential of Bash scripting.

Pipe and redirection elevate your scripts from basic automation to sophisticated data processing and manipulation tools.

Imagine a scenario where you need to extract specific information from a massive log file, transform it, and then save the results to a new file. Pipe and redirection make this task not just possible but remarkably straightforward.

Without these concepts, your scripts would remain confined to basic input/output, limiting your ability to tackle real-world challenges.

Why It’s Important


Pipe and redirection enable efficient data flow and manipulation, saving both time and system resources.


These tools make your scripts adaptable to various scenarios, from data analysis to text processing and more.


With pipe and redirection, you can automate complex workflows that would otherwise require manual intervention.

Script Modularity

By breaking down tasks into smaller, interconnected commands, your scripts become more modular and easier to maintain.

Table of Content

Input and Output Redirection:

    • Redirecting standard output (>, 1>).
    • Redirecting standard error (2>).
    • Appending to files (>>, 2>>).

Pipes and Data Flow:

    • Using pipes (|) to connect commands.
    • Chaining multiple commands together.
    • Examples of data flow between commands.

Error Handling and Redirection:

    • Redirecting standard error to a file or a pipe.
    • Combining standard output and standard error (2>&1).
    • Handling errors in your scripts.

Advanced Redirection Techniques:

    • Here documents (<<) for providing input to commands.
    • Process substitution (<(command) and >(command)) for complex data manipulations.
    • Combining multiple redirections in a single command.

Practical Examples:

    • Real-world use cases for pipe and redirection in Bash scripting.
    • Processing log files and extracting relevant information.
    • Text manipulation and transformation with pipes.
    • Data analysis and reporting using redirection.

By covering these topics, you’ll gain a deep understanding of how to manage input and output in your Bash scripts, create powerful data pipelines, and handle errors effectively. This knowledge is essential for automating tasks, processing data, and building more advanced Bash scripts.

One step ahead

Congratulations on completing Chapter 7 of your Bash scripting journey, where you’ve explored the dynamic world of pipe and redirection.

You’ve unlocked the key to efficient data flow, powerful data manipulation, and error-handling finesse within your scripts. As you reflect on your progress, remember that the skills you’ve gained here are not just tools; they are catalysts for your scripting success.

As you move forward in your learning, keep in mind this quote by the renowned author and motivational speaker, Zig Ziglar:

“You don’t have to be great to start, but you have to start to be great.”

Each chapter, including this one, is a stepping stone towards mastery. Embrace the challenges, relish the moments of revelation, and keep your curiosity burning.

Bash scripting is a journey that continually rewards your efforts, opening doors to automation, efficiency, and creativity.

With each chapter, you’re not just learning a new concept; you’re gaining the ability to solve real-world problems, streamline your daily tasks, and elevate your scripting skills to new heights.

The path ahead may seem daunting at times, but remember that every seasoned scripter began with the basics and persisted through challenges.

So, as you continue your learning, envision the scripts you’ll create, the problems you’ll solve, and the automation you’ll introduce into your life. The world of Bash scripting is vast and ever-expanding, waiting for you to explore its depths.

Frequently Asked Questions (FAQs)

What is input and output redirection in Bash scripting?

Input and output redirection are techniques that allow you to control where data comes from and where it goes in your Bash scripts. You can redirect the standard input and output streams to files or pipes, enabling flexible data manipulation.

How do I redirect standard output to a file?

To redirect standard output to a file, use the > operator followed by the file’s name. For example, command > output.txt will redirect the output of “command” to the file “output.txt.”


> overwrites the target file with the new data, while >> appends data to the end of the file without overwriting existing content.

How can I redirect both standard output and standard error to a file?

To redirect both standard output and standard error to a file, you can use the 2>&1 syntax. For example, command > output.txt 2>&1 will capture both types of output in “output.txt.”

What is a pipe (|) in Bash, and how does it work?

A pipe (|) allows you to connect the standard output of one command to the standard input of another, creating a data flow between commands. It’s used for chaining commands together to perform complex tasks.

How can I chain multiple commands using pipes?

To chain multiple commands using pipes, simply separate them with |. For example, command1 | command2 | command3 will pass the output of command1 to command2, and so on.

What are here documents in Bash?

Here documents (<<) are a way to provide input to commands directly within your script. They are often used for feeding multi-line input to commands or scripts.

What is process substitution in Bash?

Process substitution (<(command) and >(command)) is a technique for creating temporary files or named pipes to capture the output of a command. It’s especially useful when working with commands that require file input.

How can I handle errors and exceptions when using redirection?

You can handle errors and exceptions by redirecting standard error (stderr) to a file or a pipe and then incorporating error-checking logic into your script to respond to specific error conditions.

What are some practical use cases for pipe and redirection in Bash scripting?

Pipe and redirection are used in various scenarios, such as processing log files, filtering data, generating reports, automating data analysis, and building complex data pipelines.

Conditional testing and Scripting Loop


Bash Functions