Process substitution in Bash works by treating the output of a command as a file, allowing it to be passed to commands that expect filenames. 1. It uses (...) for output, creating temporary file descriptors like /dev/fd/63. 2. This enables comparing command outputs with tools like diff, feeding data to programs that only accept files, and avoiding temporary files. 3. It works with any command that takes filenames, such as cmp, paste, or awk. 4. Real-world use includes passing pipelines into tools expecting filenames, e.g., mytool

Process substitution in Bash is a feature that lets you treat the output of a command as a file. This is super handy when you want to pass the result of a command to another command that expects a filename, not input from stdin.

It uses either or <code>(...) depending on whether you're using it for input or output. Think of it like creating a temporary file on the fly — but without actually writing anything to disk.

How does process substitution work?

At its core, process substitution runs a command and gives you a filename (usually something like /dev/fd/63) that other commands can read from (or write to). This makes it possible to chain commands together in clever ways.

Here’s a simple example:

diff <(ls /tmp) <(ls /var/tmp)

In this case, diff is comparing the output of two ls commands as if they were two separate files. Bash handles running both ls commands and feeds their outputs into diff.

This trick works with any command that takes filenames as arguments — think cmp, paste, awk, etc.

When would you use it?

There are a few common situations where process substitution shines:

• Comparing outputs: Like we saw above with diff, comparing what two commands output as if they were files.
• Feeding data to programs that only take files: Some tools don’t accept input from stdin. With process substitution, you can still give them data from another command.
• Avoiding temporary files: You’d otherwise have to create temp files to hold intermediate results. Now you can skip that step.

A real-world example might be feeding the output of one pipeline into a script or tool that expects a filename:

mytool "$(process_data | filter_output)"

Oops — that won't work because mytool expects a filename. Here's how you fix it with process substitution:

mytool <(process_data | filter_output)

Now mytool gets a real file descriptor it can read from.

Tips and gotchas

Here are a few things to watch out for when using process substitution:

• It only works in shells that support it — Bash and Zsh do, but plain old sh may not.
• The "files" created by process substitution are usually FIFOs or /dev/fd entries — not real disk files. So some programs might act weird if they expect regular files (like if they try to seek back and forth).
• You can use it more than once in a command — like comparing two processes as we did with diff.
• Nesting substitutions can get confusing fast. Keep it readable.

If you’re scripting and need compatibility, remember to shebang with #!/bin/bash, not just #!/bin/sh.

Also, while it's tempting to overuse this trick, sometimes just piping input (|) or redirecting stdin () is simpler and clearer.

That’s the gist of process substitution in Bash — basically a neat way to make command outputs look like files. Not magic, just smart plumbing.

The above is the detailed content of What is process substitution in Bash?. For more information, please follow other related articles on the PHP Chinese website!