When working with shell scripts and command-line operations, a common requirement is to take the output of one command and use it as separate arguments for another command. The naive approach of simple command substitution often fails because the entire output gets treated as a single argument.

The most reliable method uses xargs combined with command substitution:

./command1 | xargs command2

This works because:

• The pipe (|) sends command1's output to xargs
• xargs splits the input by whitespace (default behavior)
• Each word becomes a separate argument to command2

For outputs containing spaces or special characters:

./command1 | xargs -d '\n' command2  # Use newline as delimiter
./command1 | xargs -0 command2      # Null-delimited items (most robust)

In bash/zsh, you can capture output into an array:

args=($(./command1))
command2 "${args[@]}"

Finding and processing files:

find . -name "*.log" -print0 | xargs -0 rm  # Safely delete all log files

Processing text output:

echo "one two three" | xargs mkdir  # Creates three directories

For large numbers of arguments, xargs automatically splits them into multiple invocations to avoid "Argument list too long" errors:

find / -type f | xargs grep "search_term"  # Searches all files efficiently

---

When working with command-line operations, a common scenario arises where we need to use the output of one command (command1) as multiple arguments for another command (command2). The default behavior of command substitution would treat the entire output as a single argument, which isn't what we want when dealing with space-separated values.

The most straightforward approach uses xargs, which is designed specifically for this purpose:

./command1 | xargs command2

This works because:

1. command1 outputs "word1 word2 word3"
2. xargs splits this output by whitespace
3. Each word becomes a separate argument to command2

For more complex scenarios, we might need additional control:

When words contain spaces

./command1 | xargs -d '\n' command2

When limiting argument count

./command1 | xargs -n 2 command2  # Passes 2 arguments at a time

For bash users, command substitution with array expansion provides another option:

command2 $(./command1)

Or more explicitly:

args=($(./command1))
command2 "${args[@]}"

Let's say we have a script find_files.sh that outputs filenames:

#!/bin/bash
echo "file1.txt file2.txt backup.log"

And we want to pass these to wc -l:

./find_files.sh | xargs wc -l

This would execute:

wc -l file1.txt file2.txt backup.log

For very large outputs (thousands of arguments), the default behavior might hit system limits. In such cases:

./command1 | xargs --show-limits
./command1 | xargs -s 10000 command2  # Set max chars per command

Be cautious when using this pattern with untrusted input, as it could lead to command injection. For safer handling:

./command1 | xargs -0 command2  # If output is null-delimited

Or in bash:

mapfile -t args < <(./command1)
command2 "${args[@]}"