Xargs Command Examples: A Practical Guide

This article answers the question “Xargs command examples?” by showing you exactly how to use the xargs command in Linux and Unix-like systems, with practical examples you can run immediately. You will learn what xargs does, how it works, how to use it with find, grep, and other commands, and how to avoid its most common pitfalls.

What is xargs and Why Do You Need It?

Many Unix commands output a list of items to standard output (stdout), but other commands cannot read that list directly as arguments. For example, find prints filenames, but rm expects filenames as arguments, not as piped input. xargs bridges this gap: it reads items from standard input (stdin), and then runs a specified command with those items as arguments. This is why xargs is often described as a “building block” for shell pipelines.

The basic syntax is:

command1 | xargs command2

Here, the output of command1 is split into separate items (by default, separated by spaces, tabs, and newlines) and passed to command2 as its arguments. If you don’t specify a command, xargs defaults to echo, which is useful for testing.

How xargs Works: Input Splitting and Argument Batching

Understanding how xargs processes input helps you avoid surprising results. The input is split into “words” using whitespace as delimiters. However, if a filename contains spaces, that filename will be split into multiple words, which is a classic source of errors. To handle filenames with spaces, you should use the -0 option (null separator) together with the -print0 option in find.

Another key behavior is batching. If the input contains thousands of items, xargs will not pass them all at once (which could exceed the system’s maximum command-line length). Instead, it automatically divides the items into batches that fit within the limit, and runs the command multiple times, once per batch. This is usually what you want, but you can control it with the -n (max arguments per invocation) and -L (max lines per invocation) options.

By default, xargs runs the command only if the input is not empty. If you want to run the command even when there is no input, use the -r option (on GNU versions) or --no-run-if-empty.

Basic xargs Examples: From Simple to Practical

Let’s start with simple examples and then move to real-world uses.

Example 1: Default echo – echo "a b c" | xargs prints a b c. This shows how xargs just echoes its input when no command is given.
Example 2: Count lines in files – find . -name "*.txt" | xargs wc -l counts lines in all text files in the current directory and subdirectories.
Example 3: Delete files found by find – find . -name "*.tmp" | xargs rm removes all files ending with .tmp. However, this is unsafe if filenames have spaces; a better version is find . -name "*.tmp" -print0 | xargs -0 rm.
Example 4: Search for a pattern in a list of files – find . -name "*.log" | xargs grep "ERROR" searches for “ERROR” in all log files.
Example 5: Use a placeholder for the argument – find . -name "*.jpg" | xargs -I {} cp {} /backup/ copies each JPG file to a backup directory. The -I option replaces {} with the current input item, allowing you to place the argument anywhere in the command.

Handling Spaces and Special Characters: The -0 Option

Filenames often contain spaces, apostrophes, or other special characters. If you pipe a list of such filenames to xargs without special handling, the command will break. The solution is to use a null character (\0) as the delimiter instead of whitespace. The find command has a -print0 option that outputs filenames separated by null characters, and xargs has a -0 option to read them.

Example: find . -name "*.mp3" -print0 | xargs -0 rm safely deletes MP3 files even if they have spaces. This is a critical habit to adopt when using xargs with find.

Choosing the Right Options: -n, -L, -I, and -P

The options you choose depend on what you need to do.

-n max-args: Run the command with at most max-args arguments at a time. For example, seq 1 10 | xargs -n 3 echo runs echo four times: with 1 2 3, 4 5 6, 7 8 9, and 10.
-L max-lines: Run the command once per max-lines of input. This is useful when each input line represents a single item, even if it contains spaces.
-I replace-str: Replace occurrences of replace-str in the command with the input item. This implies -L 1 (one line per invocation). This is useful for commands that need the argument in a specific position, like cp.
-P max-procs: Run up to max-procs processes in parallel. This can speed up batch operations, but be careful with commands that are not safe to run concurrently.

Common Problems and How to Avoid Them

The most common issues with xargs are related to filenames with spaces, empty input, and unexpected command behavior.

Problem: Filenames with spaces – Use -print0 with find and -0 with xargs.
Problem: Running a command with no input – By default, xargs runs the command even if the input is empty. If you don’t want that, use -r (GNU) or --no-run-if-empty.
Problem: The command fails on a batch – xargs continues to the next batch even if the command returns a non-zero exit status. If you want to stop on the first failure, use -x (GNU) or --exit.
Problem: Quoting issues – If your command contains quotes or special characters, it’s often easier to use -I to avoid quoting headaches.

xargs vs. find -exec: Which One Should You Use?

Many users wonder whether to use xargs or the -exec option of find. Both can perform similar tasks. The main difference is that xargs batches arguments, which can be more efficient for many files, while find -exec runs the command once per file (unless you use -exec ... +).

For example, find . -name "*.txt" -exec rm {} \; runs rm for each file, which is slow for thousands of files. The equivalent with xargs, find . -name "*.txt" | xargs rm, runs rm with as many files as possible at once. However, find -exec is more portable and safer with unusual filenames if you use -exec ... + (which also batches). In practice, many users prefer find -exec for simplicity, but xargs is more flexible for complex pipelines.

Frequently Asked Questions

How do I use xargs with a command that has multiple arguments?

Use the -I option to specify a placeholder. For example, echo "file1 file2" | xargs -I {} cp {} /backup/ will copy file1 and file2 to /backup/. The placeholder {} is replaced with each input item.

What does the -0 option do in xargs?

The -0 option tells xargs to treat the null character (\0) as the delimiter between items, instead of whitespace. This is essential when filenames contain spaces, because it prevents the filename from being split into multiple arguments. It is typically used with find -print0.

Why does xargs run the command even when there is no input?

By default, xargs runs the command at least once, even if the input is empty. If you want to avoid that, use the -r (or --no-run-if-empty) option on GNU systems. For example, find . -name "*.nonexistent" -print0 | xargs -0 -r rm will not run rm if no files are found.

How can I run commands in parallel with xargs?

Use the -P option to specify the maximum number of processes to run simultaneously. For example, find . -name "*.jpg" -print0 | xargs -0 -P 4 convert -resize 50% would run four convert commands at a time. Be careful with commands that are not safe to run in parallel.

Can xargs handle filenames with newlines?

By default, xargs treats newlines as delimiters, so a filename with a newline would be broken. The only safe way is to use the null delimiter (-0), which is why find -print0 is recommended. This is a rare but real edge case.

Method: the standard formula for this calculation, rounded as each result states. See how the calculators work or report an error.

More cards in this drawer

The whole Numbers and Powers drawer →