Detailed Tutorial on Using xargs Command on Linux

Hello everyone, I am Liang Xu.

When using Linux, have you ever encountered a situation where you needed to string some commands together, but one of the commands didn't accept piped input? In this case, we can use the xargs command. xargs can send the output of one command as an argument to another command.

In Linux, all standard applications have three data streams associated with them. They are the standard input stream (stdin), the standard output stream (stdout), and the standard error stream (stderr). These streams operate through text, we use text to send input (stdin) to the command, and the response (stdout) will be displayed in the terminal window as text. Error messages are also displayed as text in the terminal window (stderr).

One of the great features of Linux and Unix-like operating systems is the ability to pipe the standard output stream of one command to the standard input stream of another command. The first command doesn't care whether its output is written to the terminal window, and the second command doesn't care whether its input comes from the keyboard.

Although all Linux commands have three standard streams, not all commands accept the standard output of another command as input to its standard input stream. Therefore we cannot pipe input to these commands.

xargs is a command that builds execution pipelines using standard data streams. By using the xargs command we can make commands like echo , rm , and mkdir accept standard input as their arguments.

xargs Command

xargs accepts input from a pipe or from a file. xargs uses that input as arguments to the command we specify. If we do not specify a specific command to xargs , echo is used by default. xargs always produces a single line of output, even if the input data is multi-line.

If we use the -1 (list one file per line) option of ls , we will get a list of file names:

$ ls -1 ./*.sh

This command lists the shell script files in the current directory.

What happens if we pipe the output to xargs ?

$ ls -1 ./*.sh | xargs 

As you can see, the output is written to the terminal as a long string of text. From this we can see that xargs can pass output as arguments to other commands.

Using xargs with wc command

We can easily let wc command count the number of words, characters and lines in multiple files using xargs command

$ ls *.c | xargs wc

The execution results are as follows:

The command results show the statistics for each file as well as the total.

This command performs the following operations:

ls lists all .page files and passes that list to xargs . xargs passes all file names to wc . wc processes these file names as command-line arguments.

Using xargs with a confirmation message

We can use the -p (interactive) option to have xargs prompt us if we want to proceed.

If we pass a string of file names to the touch command via xargs , touch will create those files.

$ echo 'one two three' | xargs -p touch 

The terminal displays the command to be executed, and xargs waits for us to enter y or Y , n or N and press Enter to respond. If only Enter is pressed, it is treated as n . This command is only executed when we enter y or Y

We press y and Enter, and then use ls to check if the file has been created.

$ ls one two three 

Using xargs with multiple commands

We can use xargs with multiple commands using -I (initial argument) option. This option defines替換字符串. Anywhere the replacement string appears on the command line, the value we supplied to xargs is inserted.

This is a bit abstract, so let’s explain it with an example.

Let's first use the tree command to view the subdirectories in the current directory. The -d (directory) option causes tree command to ignore files and output only directories.

$ tree -d 

Now there is only one subdirectory images.

In the file directors.txt we have the names of some directories that we want to create. Let's first use cat to view the contents.

$ cat directories.txt 

We pass these contents as input data to xargs and execute the following command:

$ cat directories.txt | xargs -I % sh -c 'echo %; mkdir %'

This command performs the following operations:

cat directories.txt : Pass the contents of the directories.txt file (all the names of directories to be created) to xargs . xargs -I % : defines the replacement string % . sh -c: Starts a new subshell. -c (commond) causes the shell to read commands. 'echo %; mkdir %': Each ％ will be replaced by the directory name passed by xargs . The echo command prints the directory name, and mkdir command creates the directory.

Command execution results:

We can verify with tree that the directory has been created.

$ tree -d 

Copy files to multiple locations

We can use xargs command to copy files to multiple locations with one command.

First, pipe the names of the two directories to xargs . and have xargs pass only one of the arguments at a time to the command being used.

To call cp twice, each time with one of the two directories as a command line argument, we can do this by setting -n (max number) option of xargs to 1.

We also use the -v (verbose) option here to let cp provide feedback on what it is doing.

$ echo ~/dir1/ ~/dir2/ | xargs -n 1 cp -v ./*.c

We copied the files to two directories, one directory at a time. cp returns detailed information, allowing us to see what operations were performed.

Deleting files in nested directories

If the file names contain spaces or other special characters (such as newlines), xargs will not be able to interpret the file names correctly. We can fix this by using the -0 (null terminator) option. In this case, xargs will use the null character as the final separator for the file name.

Here we take the find command as an example. find has its own option to handle spaces and special characters in file names, the -print0 (full name, null character) option.

$ find . -name "*.png" -type f -print0 | xargs -0 rm -v -rf "{}"

This command performs the following actions:

find . -name “*.png”: find will search the current directory for objects whose names match *.png. type -f specifies that only files should be searched. -print0: The name will be null-terminated, and spaces and special characters will be preserved. xargs -0: xargs will also consider file names to be null-terminated, and spaces and special characters will not cause problems. rm -v -rf "{}": rm will give feedback on the operation in progress ( -v ), recursively operate (-r), and directly delete the file without sending an error message ( -f ). Replace "{}" with each file name.

After the command is executed, all subdirectories will be searched and the matching files will be deleted.

Deleting Nested Directories

Suppose we want to delete a set of nested subdirectories, first use tree to view them.

$ tree -d 

$ find . -name "level_one" -type d -print0 | xargs -0 rm -v -rf "{}"

This command uses find to recursively search the current directory for a directory called level_one, and then passes the directory name to rm via xargs .

The difference between this command and the previous one is that the item searched is the name of the top-level directory, and -type d specifies that the directory is to be searched, not the file.

The name of each directory is printed as it is removed. We can use tree to view the effect again:

$ tree -d 

All nested subdirectories have been deleted.

Delete all files except one file type

We can use find , xargs , and rm to remove all types of files and keep only the type of files we want to keep. This requires providing the file type you want to keep.

The -not option causes find to return all file names that do not match the search pattern. We again use the -I (initialization argument) option of xargs . The replacement string defined this time is {} . This has the same effect as the replacement string % we used earlier.

$ find . -type f -not -name "*.sh" -print0 | xargs -0 -I {} rm -v {} 

After the command is executed, we confirm the result through ls . As you can see, only files matching *.sh remain in the directory.

$ ls -l 

Creating Compressed Files with Xargs

We can use the find command to search for files and pass the file names to the tar command through xargs to create a compressed file.

We will search for * .sh files in the current directory.

$ find ./ -name "*.sh" -type f -print0 | xargs -0 tar -cvzf script_files.tar.gz

The command execution result will list all .sh files and create a compressed file.

Summarize

This is the end of this article on how to use the xargs command on Linux. For more information about using the xargs command on Linux, please search for previous articles on 123WORDPRESS.COM or continue to browse the following related articles. I hope you will support 123WORDPRESS.COM in the future!