Explication détaillée de la commande xargs sous Linux et de la différence entre xargs et pipes

Pourquoi utiliser xargs, la source du problème

J'entre souvent en contact avec la commande xargs au travail, notamment dans les scripts écrits par d'autres, mais il est facile de se confondre avec les pipelines. expliquez en détail ce qu'est la commande xargs, pourquoi vous devez utiliser la commande xargs et la différence avec les tuyaux. Pourquoi utiliser xargs ? Nous savons que la commande linux peut lire le contenu à traiter à partir de deux endroits, l'un via les paramètres de ligne de commande et l'autre via l'entrée standard. Par exemple, cat et grep sont de telles commandes. Par exemple :

echo 'main' | cat test.cpp

Dans ce cas, cat affichera le contenu de test.cpp au lieu de 'main'string. test.cpp n'existe pas, la commande cat signalera que le fichier n'existe pas et ne tentera pas de lire à partir de l'entrée standard. echo 'main' | importera la sortie standard de echo (c'est-à-dire la chaîne 'main') dans l'entrée standard de cat via un pipeline, c'est-à-dire qu'il y a du contenu dans l'entrée standard de cat à ce moment-là. et son contenu est la chaîne 'main' mais dans le contenu ci-dessus, cat ne lira pas le contenu à traiter à partir de son entrée standard. (Remarque : l'entrée standard a un tampon, tout comme nous utilisons la fonction scanf pour lire à partir de l'entrée standard dans le programme, elle lit en fait à partir du tampon d'entrée standard). En fait, de nombreuses commandes Linux sont conçues pour obtenir d'abord les paramètres à partir des paramètres de ligne de commande, puis les lire à partir de l'entrée standard, ce qui se reflète dans le programme. Les paramètres de ligne de commande sont int main(int argc,char via le. fonction principale *argv[]) Les paramètres de fonction sont obtenus et l'entrée standard est lue via la fonction d'entrée standard telle que scanf en langage C. Là où ils obtiennent, c'est différent. Par exemple :

echo 'main' | cat

Cette commande amènera cat à lire le contenu de son entrée standard et à le traiter, c'est-à-dire qu'il affichera la chaîne « principale ». La commande echo dirige le contenu de sa sortie standard « main » vers la sortie standard de cat via un tube.

cat

Si vous tapez simplement cat et appuyez sur Entrée, le programme attendra la saisie. Nous devons saisir le contenu à traiter depuis le clavier vers cat. être traité à partir de l'entrée standard, car le nom du fichier à traiter n'est pas spécifié dans notre ligne de commande cat. La plupart des commandes ont un paramètre - s'il est spécifié directement à la fin de la commande - cela signifie lire à partir de l'entrée standard,

Par exemple :

echo 'main' | cat -

Ceci est également réalisable et affichera ' main ' String, entrez également cat - l'effet d'appuyer directement sur Entrée est le même que d'entrer cat et d'appuyer directement sur Entrée, mais que se passe-t-il si :

echo 'main' | cat test.cpp -

Spécifiez les paramètres test.cpp et - en même temps, à ce moment, le programme cat est toujours Le contenu de test.cpp sera affiché. Mais il existe un programme avec une stratégie différente, c'est grep, par exemple :

echo 'main' | grep 'main' test.cpp -

Le résultat de cette commande est :

test.cpp:int main()
(standard input):main

À ce moment, grep traitera l'entrée standard et les fichiers en même temps Le contenu de test.cpp, c'est-à-dire que l'entrée standard sera recherchée 'main' et le fichier test.cpp (le nom du fichier est obtenu à partir du paramètre de ligne de commande grep) sera recherché pour « principal ». C'est-à-dire que lorsque les deux paramètres test.cpp et - existent en même temps dans la ligne de commande, différents programmes les gèrent différemment. Nous avons vu que cat et grep sont traités différemment. Mais une chose est la même : recherchez d'abord la source du contenu à traiter sur la ligne de commande (que ce soit à partir d'un fichier, d'une entrée standard ou des deux), si les paramètres liés à la source du contenu à traiter ne sont pas trouvés. dans la ligne de commande Par défaut, le contenu à traiter est lu à partir de l'entrée standard

.

De plus, de nombreux programmes ne traitent pas l'entrée standard, comme kill et rm. Si les paramètres de ligne de commande ne spécifient pas ce qu'il faut traiter, ces programmes ne liront pas l'entrée standard par défaut. Par conséquent :

echo '516' | kill

Ce genre de destin ne peut pas être réalisé.

echo 'test' | rm -f

Cela est également inefficace.

Ces deux commandes n'acceptent que le contenu de traitement spécifié dans les paramètres de ligne de commande et n'obtiennent pas le contenu de traitement à partir de l'entrée standard. C'est normal quand on y pense. Kill signifie mettre fin au processus, et rm signifie supprimer le fichier

si le pid du processus à terminer et le nom du fichier à supprimer doivent être lus dans le fichier. entrée standard, c'est aussi le cas. Mais il est naturel que les outils de traitement de texte comme cat et grep lisent le contenu à traiter à partir d'une entrée standard. Mais parfois, nos scripts ont besoin de l'effet echo '516' | kill, tel que ps -ef | grep 'ddd' | Ce besoin est naturel et très courant chez nous, alors comment devons-nous obtenir cet effet ? Il existe plusieurs solutions :

1. Sous la forme de

, cela équivaut en fait à la commande obtenue en épissant des chaînes, et son effet est similaire à kill $pid<🎜. >

2.

for procid in $(ps -aux | grep "some search" | awk '{print $2}'); do kill -9 $procid; done

其实与第一种原理一样，只不过需要多次kill的时候是循环处理的，每次处理一个

3.

 ps -ef | grep 'ddd' | xargs kill

OK，使用了xargs命令，铺垫了这么久终于铺到了主题上。xargs命令可以通过管道接受字符串，并将接收到的字符串通过空格分割成许多参数(默认情况下是通过空格分割) 然后将参数传递给其后面的命令，作为后面命令的命令行参数

xargs是什么，与管道有什么不同

xargs与管道有什么不同呢，这是两个很容易混淆的东西，看了上面的xargs的例子还是有点云里雾里的话，我们来看下面的例子弄清楚为什么需要xargs：

echo '--help' | cat

输出：

--help
echo '--help' | xargs cat

输出：

Usage: cat [OPTION]... [FILE]...
Concatenate FILE(s), or standard input, to standard output.
 -A, --show-all   equivalent to -vET
 -b, --number-nonblank number nonempty output lines
 -e      equivalent to -vE
 -E, --show-ends   display $ at end of each line
 -n, --number    number all output lines
 -s, --squeeze-blank  suppress repeated empty output lines
 -t      equivalent to -vT
 -T, --show-tabs   display TAB characters as ^I
 -u      (ignored)
 -v, --show-nonprinting use ^ and M- notation, except for LFD and TAB
  --help  display this help and exit
  --version output version information and exit

可以看到 echo &#39;--help&#39; | cat 该命令输出的是echo的内容，也就是说将echo的内容当作cat处理的文件内容了，实际上就是echo命令的输出通过管道定向到cat的输入了。然后cat从其标准输入中读取待处理的文本内容。这等价于在test.txt文件中有一行字符 '--help' 然后运行 cat test.txt 的效果。

而 echo '--help' | xargs cat 等价于 cat --help 什么意思呢，就是xargs将其接受的字符串 --help 做成cat的一个命令参数来运行cat命令，同样 echo 'test.c test.cpp' | xargs cat 等价于 cat test.c test.cpp 此时会将test.c和test.cpp的内容都显示出来。

xargs的一些有用的选项

相信到这里应该都知道xargs的作用了，那么我们看看xargs还有一些有用的选项：

1. -d 选项

默认情况下xargs将其标准输入中的内容以空白(包括空格、Tab、回车换行等)分割成多个之后当作命令行参数传递给其后面的命令，并运行之，我们可以使用 -d 命令指定分隔符，例如：

echo '11@22@33' | xargs echo

输出：

11@22@33

默认情况下以空白分割，那么11@22@33这个字符串中没有空白，所以实际上等价于 echo 11@22@33 其中字符串 '11@22@33' 被当作echo命令的一个命令行参数

echo '11@22@33' | xargs -d '@' echo

输出：

11 22 33

指定以@符号分割参数，所以等价于 echo 11 22 33 相当于给echo传递了3个参数，分别是11、22、33

2. -p 选项

使用该选项之后xargs并不会马上执行其后面的命令，而是输出即将要执行的完整的命令(包括命令以及传递给命令的命令行参数)，询问是否执行，输入 y 才继续执行，否则不执行。这种方式可以清楚的看到执行的命令是什么样子，也就是xargs传递给命令的参数是什么，例如：

echo '11@22@33' | xargs -p -d '@' echo

输出：

echo 11 22 33

?...y ==>这里询问是否执行命令 echo 11 22 33 输入y并回车，则显示执行结果，否则不执行

11 22 33 ==>执行结果

3. -n 选项

该选项表示将xargs生成的命令行参数，每次传递几个参数给其后面的命令执行，例如如果xargs从标准输入中读入内容，然后以分隔符分割之后生成的命令行参数有10个，使用 -n 3 之后表示一次传递给xargs后面的命令是3个参数，因为一共有10个参数，所以要执行4次，才能将参数用完。例如：

echo '11@22@33@44@55@66@77@88@99@00' | xargs -d '@' -n 3 echo

输出结果：

11 22 33
44 55 66
77 88 99
00

等价于：

echo 11 22 33
echo 44 55 66
echo 77 88 99
echo 00

实际上运行了4次，每次传递3个参数，最后还剩一个，就直接传递一个参数。

4. -E 选项，有的系统的xargs版本可能是-e eof-str

该选项指定一个字符串，当xargs解析出多个命令行参数的时候，如果搜索到-e指定的命令行参数，则只会将-e指定的命令行参数之前的参数(不包括-e指定的这个参数)传递给xargs后面的命令

echo '11 22 33' | xargs -E '33' echo

输出：

11 22

可以看到正常情况下有3个命令行参数 11、22、33 由于使用了-E '33' 表示在将命令行参数 33 之前的参数传递给执行的命令，33本身不传递。等价于 echo 11 22 这里-E实际上有搜索的作用，表示只取xargs读到的命令行参数前面的某些部分给命令执行。

注意：-E只有在xargs不指定-d的时候有效，如果指定了-d则不起作用，而不管-d指定的是什么字符，空格也不行。

echo '11 22 33' | xargs -d ' ' -E '33' echo => 输出 11 22 33
echo '11@22@33@44@55@66@77@88@99@00 aa 33 bb' | xargs -E '33' -d '@' -p echo => 输出 11 22 33 44 55 66 77 88 99 00 aa 33 bb
## -0 选项表示以 '\0' 为分隔符，一般与find结合使用
find . -name "*.txt"

输出：

./2.txt
./3.txt
./1.txt     => 默认情况下find的输出结果是每条记录后面加上换行，也就是每条记录是一个新行
find . -name "*.txt" -print0

输出：

./2.txt./3.txt./1.txt     => 加上 -print0 参数表示find输出的每条结果后面加上 '\0' 而不是换行
find . -name "*.txt" -print0 | xargs -0 echo

输出：

./2.txt ./3.txt ./1.txt
find . -name "*.txt" -print0 | xargs -d '\0' echo

输出：

./2.txt ./3.txt ./1.txt

xargs的 -0 和 -d '\0' 表示其从标准输入中读取的内容使用 '\0' 来分割，由于 find 的结果是使用 '\0' 分隔的，所以xargs使用 '\0' 将 find的结果分隔之后得到3个参数： ./2.txt ./3.txt ./1.txt   注意中间是有空格的。上面的结果就等价于 echo ./2.txt ./3.txt ./1.txt

En fait, il est également possible d'utiliser le délimiteur d'espace par défaut de xargs find . Si la commande find n'ajoute pas -print0, une nouvelle ligne est en fait ajoutée après chaque chaîne dans les résultats de la recherche.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!