Understanding builtin commands in a shell pipeline

Discover why directory changes using pipes in shell commands don't behave as expected and learn how different shells handle these pipelines.
---

Visit these links for original content and any more details, such as alternate solutions, latest updates/developments on topic, comments, revision history etc. For example, the original title of the Question was: builtin commands in a shell pipeline

If anything seems off to you, please feel free to write me at vlogize [AT] gmail [DOT] com.
---
Understanding builtin commands in a shell pipeline

When working in a command-line environment, particularly within Linux, you'll often use a technique known as piping. This allows you to connect multiple commands in sequence, letting each command pass its output directly to the next. However, you might have encountered a simple yet baffling problem when trying to change directories via a command pipeline.

The Problem Explained

Imagine this scenario: You type the following command in your shell:

[[See Video to Reveal this Text or Code Snippet]]

At first glance, the command seems straightforward. It lists the contents of the current directory, sorts them, and attempts to change the current directory to /home. However, you notice that nothing actually happens. The expected change of the working directory does not occur. Why is this?

Let's break down the scenario:

The command uses the pipe (|) which connects the output of one command to the input of the next.

The command sequence appears to logically lead to a change in directory, but it fails to do so.

The Solution

Understanding Process Isolation in Linux

To understand why the cd /home command does not function as intended within the pipeline, we must first understand how processes work in Linux.

Independent Processes: Every command in a pipeline runs in a separate process, isolated from each other.

Output Handling: While the output of ls is sent to sort, the cd /home command runs in its own process and, once it completes, exits without affecting the parent shell.

BASH vs. ZSH Behavior

In BASH:

All commands in a pipeline are executed in their own distinct processes.

For instance, when you run:

[[See Video to Reveal this Text or Code Snippet]]

The cd /home command executes in isolation and changes the directory of its subprocess, which exits immediately afterward, leaving the parent shell's working directory unchanged.

In ZSH:

The behavior is slightly different. In ZSH, all commands in a pipeline except for the last one run in separate processes.

Therefore, if you run:

[[See Video to Reveal this Text or Code Snippet]]

The cd /home command can indeed change the working directory of the shell because it's the last command in the pipeline.

Conversely, if you apply a different order:

[[See Video to Reveal this Text or Code Snippet]]

The cd command will execute in its own process and will not affect the current shell's working directory, while ls and sort processes will simply operate on the original shell state.

Conclusion

When using pipelines, remember that the isolated nature of commands in separate processes can lead to unexpected behavior, especially with commands that alter the state of the shell, like cd. Understanding how your chosen shell (BASH vs ZSH) handles these pipelines can greatly enhance your command-line efficiency and prevent confusion.

By mastering these nuances of shell command execution, you can avoid potential pitfalls and make better use of pipelines in your everyday shell tasks.