xargs is a very useful tool when processing large amounts of files in the terminal. It can efficiently receive input (such as file names) and run commands. The basic usage is to pipe the file list to xargs and specify the command to execute, such as find . -name "*.txt" | xargs rm will delete all .txt files; but if the file name contains spaces, you should use find . -name "*.txt" -print0 | xargs -0 rm to handle it safely. 1. Use -n to control the number of parameters for each command call, such as xargs -n 1 gzip means compressing files one by one; 2. Use -P to execute multiple processes in parallel, such as xargs -n 1 -P 4 convert_to_web.sh can run four conversion tasks simultaneously; 3. Use -r to prevent errors when the input is empty, such as xargs -r rm does not execute or report errors when there is no file; 4. xargs can be combined with find, grep and other commands to achieve cross-file search or flexible execution, such as xargs grep "import" or xargs -I {} mv {} /tmp/. Mastering these common techniques can deal with most practical scenarios.

When you need to process a lot of files in the terminal, xargs is a handy tool that takes input (like filenames) and runs commands on them efficiently. It's especially useful when dealing with long lists that would otherwise overflow the command line.

Basic Usage: Passing Files to a Command

The most straightforward way to use xargs is to pipe a list of files into it and tell it what command to run. For example:

 find . -name "*.txt" | xargs rm

This finds all .txt files in the current directory and deletes them. What's happening here is find generates the list, and xargs batches those filenames into rm commands.

One thing to watch out for: if your filenames have spaces, this can break. So it's better to use -print0 and -0 together to handle spaces safely:

 find . -name "*.txt" -print0 | xargs -0 rm

That way, filenames are separated by null characters instead of whitespace, which avoids issues.

Controlling How Many Arguments Are Passed

By default, xargs tries to fit as many arguments per command line as possible. But sometimes you want more control — like running the command once per input line.

Use -n to specify how many arguments go into each command call. For example:

 find . -name "*.log" | xargs -n 1 gzip

This compresses each .log file individually. This might be slower but gives finer control, especially if you're debugging or logging output.

If you're working with very large numbers of files, you might also try -P to run multiple processes at once (parallel execution):

 find . -name "*.jpg" | xargs -n 1 -P 4 convert_to_web.sh

This would run four instances of convert_to_web.sh at once, potentially speeding things up.

Handling Input That Might Be Empty

Sometimes your input list could be empty — especially if you're scripting something automated. In that case, xargs will complain or even fail.

To avoid errors, use the -r option:

 find . -name "*.bak" | xargs -r rm

Now, if there are no .bak files, xargs won't run rm at all — and won't throw an error either.

This is super helpful in scripts where you don't want unnecessary failures just because nothing matched.

Combining With Other Commands

xargs shines brightest when combined with tools like find , grep , or ls . One common pattern is using it with grep to filter content across many files:

 find . -name "*.py" | xargs grep "import"

This searches all .py files for lines containing "import".

Another trick is using {} to place the input arguments somewhere specific in the command. For example:

 find . -name "*.tmp" | xargs -I {} mv {} /tmp/

Here, {} represents the input filename, and it gets slotted into both the source and destination parts of the mv command. Handy when you need flexibility.

These are the basics you'll use most often. There are more advanced options, but these cover most real-world scenarios.

The above is the detailed content of How to use xargs to process a list of files?. For more information, please follow other related articles on the PHP Chinese website!