xargs : construire des commandes à partir d'entrées

Quand on doit exécuter une commande sur des centaines de fichiers trouvés par find, traiter une liste depuis un fichier ou éviter l'erreur "argument list too long", xargs est l'outil indispensable. Simple et puissant, xargs transforme l'entrée standard en arguments pour une autre commande, permettant de chaîner les commandes efficacement.

Ce que vous allez apprendre

• Transformer stdin en arguments pour une commande
• Limiter le nombre d'arguments avec -n
• Positionner les arguments avec -I
• Gérer les noms de fichiers avec espaces (-0)
• Exécuter des commandes en parallèle avec -P

La commande xargs dans l'écosystème Linux

xargs fait partie des commandes de pipeline sous Linux. Chaque outil a sa spécialité :

Commande	Spécialité	Quand l'utiliser
xargs	Transformer stdin en arguments	Exécuter une commande sur une liste
find	Rechercher des fichiers	Trouver par nom, taille, date
grep	Filtrer des lignes	Rechercher des patterns
parallel	Exécution parallèle avancée	Jobs complexes, machines distantes
tee	Dupliquer un flux	Écrire et afficher simultanément
xargs -P	Parallélisme simple	Jobs locaux en parallèle

Glissez pour voir

Quand utiliser xargs vs find -exec ?

Situation	xargs	find -exec
Performance (moins de forks)	Oui, find | xargs cmd	Non, Fork par fichier
Fichiers avec espaces	Nécessite -print0 | xargs -0	Géré automatiquement
Exécution parallèle	Oui, -P N	Non
Syntaxe simple	Oui	Oui
Sans pipe	Non	Oui, -exec cmd {} \;

Glissez pour voir

Combinaisons fréquentes :

# find + xargs : supprimer des fichiers (sécurisé)
find . -name "*.tmp" -print0 | xargs -0 rm

# grep + xargs : agir sur les fichiers contenant un motif
grep -rl "TODO" src/ | xargs -I {} echo "À traiter: {}"

# cat + xargs : exécuter sur une liste depuis fichier
cat urls.txt | xargs -P 4 -I {} curl -O {}

# ls + xargs : renommer en masse
ls *.bak | xargs -I {} mv {} {}.old

Comprendre la commande xargs en 2 min

🧠 Modèle mental — Comment fonctionne xargs

xargs = Lire stdin → Découper en arguments → Exécuter la commande avec ces arguments

Points clés

• xargs lit stdin et transforme chaque élément en argument
• Par défaut, xargs utilise espaces et retours à la ligne comme séparateurs
• Sans commande spécifiée, xargs utilise echo par défaut
• -n limite le nombre d'arguments par exécution
• -I {} permet de positionner l'argument où on veut
• -0 avec find -print0 gère les noms de fichiers avec espaces

Règles d'or

1

Toujours utiliser -print0 / -0 avec find Les noms de fichiers peuvent contenir des espaces ou caractères spéciaux

2

Tester avec echo ou -p avant d'exécuter Évite les erreurs destructives avec rm, mv, etc.

Vocabulaire essentiel

-n N

Maximum N arguments par commande

-I {}

Remplacer {} par chaque argument

-0

Séparateur null (avec find -print0)

-p

Demander confirmation avant exécution

-t

Afficher la commande avant exécution

-r

Ne pas exécuter si stdin est vide

📚 Pour aller plus loin — 6 options avancées

-P N

Exécuter N commandes en parallèle

-L N

Maximum N lignes par commande

-a fichier

Lire depuis un fichier au lieu de stdin

-d delim

Utiliser delim comme séparateur

--max-procs

Alias de -P

--no-run-if-empty

Alias de -r

xargs lit stdin, découpe par espaces ou retours à la ligne, puis passe les éléments comme arguments à la commande spécifiée.

Syntaxe minimale

Retenez l'ordre de lecture : ce qui est à gauche du pipe produit du texte, ce qui est à droite de xargs reçoit ce texte sous forme d'arguments. Toutes les options se placent entre xargs et la commande cible ; une option écrite après la commande cible lui serait transmise telle quelle, ce qui provoque des erreurs difficiles à lire.

commande_source | xargs [OPTIONS] commande_cible

Le flux de données

Ce tableau sert de grille de diagnostic : quand un enchaînement ne donne pas le résultat attendu, identifiez d'abord à quelle étape ça casse. Neuf fois sur dix le problème se situe à l'étape 3, le découpage de l'entrée, et pas dans la commande cible que l'on accuse spontanément.

Étape	Description	Exemple
1. Source	Génère une liste	find . -name "*.log"
2. Pipe	Transmet à xargs	|
3. xargs	Découpe et regroupe	xargs
4. Cible	Reçoit les arguments	rm → rm f1.log f2.log f3.log

Glissez pour voir

Comportement par défaut

Deux comportements par défaut méritent d'être connus avant tout usage sérieux. D'abord, sans commande cible, xargs appelle echo : c'est ce qui en fait un outil de prévisualisation immédiat. Ensuite, xargs regroupe le maximum d'arguments dans un seul appel plutôt que d'appeler la commande une fois par élément ; c'est ce regroupement qui donne son gain de performance et qui évite l'erreur Argument list too long.

# Sans commande : xargs utilise echo
echo "a b c" | xargs
# Sortie : a b c

# Avec commande : passe tous les arguments
echo "f1.txt f2.txt" | xargs rm
# Équivalent à : rm f1.txt f2.txt

Les options essentielles

Sept options couvrent la quasi-totalité des usages. Deux sont des filets de sécurité à réflexe permanent : -0 contre les noms de fichiers exotiques et -r contre l'exécution à vide. Deux servent au débogage avant d'engager une action destructrice : -t et -p. Les trois autres pilotent le découpage et le parallélisme.

Option	Effet	Exemple
-n N	Maximum N arguments par exécution	xargs -n 2
-I {}	Utiliser comme placeholder	xargs -I {} mv {} {}.bak
-0	Séparateur null (avec find -print0)	find -print0 | xargs -0
-p	Demander confirmation	xargs -p rm
-t	Afficher la commande (trace)	xargs -t echo
-r	Ne pas exécuter si vide	xargs -r rm
-P N	N processus en parallèle	xargs -P 4

Glissez pour voir

Limiter les arguments avec -n

Par défaut, xargs passe tous les arguments en une fois. -n limite :

# Tous les arguments
echo "1 2 3 4 5 6" | xargs echo
# Sortie : 1 2 3 4 5 6

# 2 arguments par exécution
echo "1 2 3 4 5 6" | xargs -n 2 echo
# Sortie :
# 1 2
# 3 4
# 5 6

Positionner l'argument avec -I

Par défaut, xargs ajoute les arguments à la fin. -I {} permet de les positionner :

# Sans -I : arguments à la fin
echo "file.txt" | xargs cp /backup/
# → cp /backup/ file.txt (ERREUR !)

# Avec -I : contrôle du placement
echo "file.txt" | xargs -I {} cp {} /backup/{}
# → cp file.txt /backup/file.txt (correct)

Le point que tout le monde rate : -I ne découpe pas sur les espaces mais sur les retours à la ligne. La page de manuel GNU indique que -I implique -L 1, soit une ligne d'entrée par exécution, et non -n 1 (un argument par exécution). La différence est visible immédiatement :

printf "a b\nc d\n" | xargs -I {} echo "[{}]"
# [a b]
# [c d]      <- 2 exécutions, une par ligne

printf "a b\nc d\n" | xargs -n 1 echo "["
# [ a
# [ b
# [ c
# [ d        <- 4 exécutions, une par mot

C'est une bonne nouvelle : -I traite correctement un nom de fichier contenant un espace tant qu'il occupe une ligne entière. Corollaire à connaître, -n et -I sont mutuellement exclusifs : les combiner déclenche l'avertissement options --max-args and --replace/-I/-i are mutually exclusive et le -n est ignoré.

Gérer les espaces avec -0

Les noms de fichiers avec espaces cassent xargs par défaut :

# INCORRECT : DANGER : "mon fichier.txt" devient 2 arguments
find . -name "*.txt" | xargs rm
# rm essaie de supprimer "mon" et "fichier.txt" séparément !

# CORRECT : SÉCURISÉ : séparateur null
find . -name "*.txt" -print0 | xargs -0 rm
# Gère correctement "mon fichier.txt"

Tester avant d'exécuter

Règle d'or : toujours tester avec echo ou -p d'abord. xargs alimente très souvent rm, mv ou chmod, des commandes sans retour arrière. Les trois lignes ci-dessous forment une progression à respecter dans l'ordre : on regarde, on confirme, puis on exécute. L'étape 1 est la plus utile car elle révèle le découpage réel de l'entrée, c'est-à-dire exactement ce que vous ne voyez pas quand la commande part directement.

# 1. Voir ce qui serait exécuté
find . -name "*.tmp" | xargs echo rm

# 2. Demander confirmation
find . -name "*.tmp" | xargs -p rm

# 3. Exécuter (si ok)
find . -name "*.tmp" -print0 | xargs -0 rm

Exécution parallèle avec -P

-P N autorise xargs à faire tourner jusqu'à N processus simultanés. Le gain est réel sur les tâches limitées par les entrées-sorties (téléchargement, compression) et quasi nul sur une tâche qui sature déjà un cœur. Prenez comme point de départ le nombre de cœurs retourné par nproc, puis mesurez : au-delà, la contention disque annule le bénéfice.

Une limite à connaître avant de lancer : xargs -P n'ordonne pas les sorties. Les lignes des différents processus arrivent entremêlées sur le terminal, car aucun tampon n'est réservé par processus. Si vous avez besoin d'une sortie lisible, redirigez chaque exécution vers son propre fichier.

# Télécharger 4 URLs en parallèle
cat urls.txt | xargs -P 4 -I {} curl -O {}

# Compresser des fichiers en parallèle (4 processus)
find . -name "*.log" -print0 | xargs -0 -P 4 gzip

Erreurs typiques (et solutions)

Ces cinq symptômes couvrent la majorité des tickets liés à xargs. Lisez la colonne du milieu avant celle de droite : la cause est presque toujours un malentendu sur la façon dont xargs a découpé l'entrée, pas un défaut de la commande cible. Les deux premières lignes sont les seules potentiellement destructrices.

Erreur	Cause	Solution
"No such file" avec espaces	Découpage incorrect	-print0 | xargs -0
Commande exécutée sans argument	stdin vide	Ajouter -r
"Argument list too long"	Trop de fichiers	xargs découpe automatiquement (ou -n)
non remplacé	Oubli de -I	Ajouter -I {}
Résultat mélangé en parallèle	Sorties entremêlées	Rediriger vers fichiers séparés

Glissez pour voir

Les modèles d'utilisation courants

Maintenant que vous comprenez la logique de xargs, voici quatorze modèles prêts à l'emploi. Chacun donne sa formule générale et un exemple concret.

Transformation basique

Passer une liste comme arguments à une commande. C'est le comportement de base : xargs regroupe tout ce qu'il reçoit et appelle la commande une seule fois, avec tous les éléments en arguments.

echo "a b c" | xargs <commande>             # formule
echo "file1.txt file2.txt" | xargs rm       # exemple

• commande : la commande qui reçoit les arguments

Lire depuis un fichier

Traiter une liste de fichiers stockée dans un fichier texte.

cat <liste> | xargs <commande>      # formule
cat fichiers.txt | xargs rm         # exemple

• liste : fichier texte contenant les éléments à traiter

Limiter les arguments

Exécuter la commande avec un nombre maximal d'arguments.

xargs -n N <commande>                  # formule
echo "1 2 3 4 5 6" | xargs -n 2 echo   # exemple

• -n N : au plus N arguments par exécution

Positionner l'argument

Utiliser l'argument à un emplacement précis de la commande.

xargs -I {} <commande avec {}>           # formule
ls *.txt | xargs -I {} mv {} {}.bak      # exemple

• -I {} : remplace {} par chaque argument (implique -n 1)

Séparateur null (espaces dans les noms)

Gérer sans risque les noms de fichiers contenant des espaces.

find . -print0 | xargs -0 <commande>                # formule
find . -name "*.txt" -print0 | xargs -0 rm          # exemple

• -print0 : find sépare les résultats par un caractère nul
• -0 : xargs lit ce même séparateur nul

Confirmation interactive

Demander une confirmation avant chaque exécution. Le prompt est lu sur le terminal, pas sur l'entrée standard déjà occupée par le pipe, ce qui explique l'erreur failed to open /dev/tty dans un script non interactif ou une tâche planifiée.

xargs -p <commande>                  # formule
echo "file1 file2" | xargs -p rm     # exemple

• -p : demande y/n avant d'exécuter

Mode verbeux

Afficher chaque commande avant de l'exécuter. La trace part sur stderr, elle ne pollue donc pas une redirection de la sortie standard vers un fichier : vous pouvez garder -t en production sans altérer le résultat collecté.

xargs -t <commande>                  # formule
echo "1 2 3" | xargs -t -n 1 echo    # exemple

• -t : trace, affiche la commande sur stderr

Éviter l'exécution sur entrée vide

Ne rien lancer si l'entrée standard est vide. Sans -r, xargs appelle la commande au moins une fois même sans aucun élément, ce qui donne des erreurs parasites avec rm et peut être franchement dangereux avec une commande qui agit sur le répertoire courant par défaut.

xargs -r <commande>                       # formule
find . -name "*.xyz" | xargs -r rm        # exemple

• -r : no-run-if-empty

Exécution parallèle

Lancer plusieurs instances de la commande en même temps.

xargs -P N <commande>                            # formule
cat urls.txt | xargs -P 4 -I {} curl -O {}       # exemple

• -P N : jusqu'à N processus en parallèle

find + xargs + rm

Supprimer les fichiers trouvés par find. C'est l'enchaînement le plus courant et le plus destructeur du guide : testez-le systématiquement en remplaçant rm par echo rm avant de l'exécuter pour de bon.

find <chemin> -name "<motif>" -print0 | xargs -0 rm     # formule
find /tmp -name "*.tmp" -print0 | xargs -0 rm           # exemple

• Le couple -print0 / -0 rend la suppression sûre

find + xargs + grep

Rechercher du texte dans les fichiers trouvés. L'intérêt par rapport à grep -r est de pouvoir filtrer d'abord sur des critères que grep ne connaît pas : la date, la taille ou le type d'entrée.

find . -name "<motif>" -print0 | xargs -0 grep "<texte>"    # formule
find . -name "*.py" -print0 | xargs -0 grep "import"        # exemple

• xargs passe toute la liste à grep en une seule commande

Renommer en masse

Renommer plusieurs fichiers selon un schéma. C'est le cas typique où -I est indispensable, puisque mv attend l'argument à deux endroits : la source et la destination.

ls <motif> | xargs -I {} mv {} <nouveau_motif>      # formule
ls *.bak | xargs -I {} mv {} {}.old                 # exemple

• -I {} permet de réutiliser l'argument deux fois (source et destination)

Créer une archive

Archiver les fichiers trouvés par find.

find . -name "<motif>" -print0 | xargs -0 tar -czvf <archive>     # formule
find . -name "*.log" -print0 | xargs -0 tar -czvf logs.tar.gz     # exemple

• xargs transmet tous les fichiers à tar d'un coup, tant que la liste tient dans un seul lot. Si elle dépasse la taille de la ligne de commande, xargs relance tar sur le lot suivant et écrase l'archive : seul le dernier lot survit. Sur un gros volume, préférez tar --null --files-from=-, qui lit la liste sur l'entrée standard sans découpage.

Changer les permissions en masse

Appliquer chmod à plusieurs fichiers. Le -type f de find n'est pas un détail : sans lui, chmod +x s'appliquerait aussi aux répertoires, qui ont déjà besoin du bit d'exécution pour être traversés, et vous perdriez la trace de ce que vous avez réellement modifié.

find . -type f -name "<motif>" -print0 | xargs -0 chmod <mode>     # formule
find . -type f -name "*.sh" -print0 | xargs -0 chmod +x            # exemple

• -type f limite aux fichiers réguliers

Les pièges à éviter

Huit erreurs reviennent constamment avec xargs. Plusieurs sont destructrices : xargs enchaîne souvent vers rm.

Noms de fichiers avec espaces

find . -name "*.txt" | xargs rm   # INCORRECT : casse sur "mon fichier.txt"

Symptôme : erreur No such file ou fichiers partiellement supprimés. Cause : xargs découpe sur les espaces, mon fichier.txt devient deux arguments.

find . -name "*.txt" -print0 | xargs -0 rm   # CORRECT : séparateur nul

Exécution sur entrée vide

find . -name "*.xyz" | xargs rm   # INCORRECT : exécute "rm" même sans aucun fichier

Symptôme : message d'erreur ou comportement inattendu. Cause : xargs lance la commande même quand l'entrée est vide.

find . -name "*.xyz" | xargs -r rm   # CORRECT : -r : ne rien faire si vide

Exécuter sans tester

cat liste.txt | xargs rm   # INCORRECT : suppression immédiate, irréversible

Symptôme : des fichiers supprimés par erreur. Cause : aucune vérification avant l'exécution.

cat liste.txt | xargs echo rm   # CORRECT : prévisualiser, puis xargs -p rm

Dépassement de la limite d'arguments

find / -type f | xargs ls   # INCORRECT : "Argument list too long" possible

Symptôme : erreur Argument list too long. Cause : le système limite la taille totale des arguments.

find / -type f -print0 | xargs -0 -n 1000 ls   # CORRECT : xargs découpe en lots

Placeholder sans -I

ls *.txt | xargs mv {} backup/   # INCORRECT : {} pris au sens littéral

Symptôme : erreur de syntaxe, {} non remplacé. Cause : le placeholder {} n'est actif que si -I est déclaré.

ls *.txt | xargs -I {} mv {} backup/   # CORRECT : -I active le placeholder

Sortie mélangée en parallèle

xargs -P 4 commande   # INCORRECT : les sorties des 4 processus s'entremêlent

Symptôme : les lignes des différents processus sont mélangées. Cause : aucune synchronisation de la sortie entre processus parallèles.

xargs -P 4 -I {} sh -c 'commande {} > {}.out'   # CORRECT : une sortie par fichier

Guillemets consommés par le shell

echo "a b" "c d" | xargs -n 1   # INCORRECT : donne 4 arguments, pas 2

Symptôme : le regroupement voulu disparaît, on obtient quatre éléments au lieu de deux. Cause : contrairement à ce qu'on lit souvent, xargs respecte les guillemets présents dans son entrée. Le coupable est le shell, qui supprime les guillemets avant même qu'echo n'écrive quoi que ce soit : xargs reçoit a b c d, sans aucune marque de regroupement. Preuve par l'exemple, si les guillemets atteignent réellement xargs, ils sont honorés :

printf '%s\n' '"a b" "c d"' | xargs -n 1   # affiche 2 lignes : a b, puis c d

En pratique on ne compte pas sur ce mécanisme, parce que -0 et -d désactivent le traitement des guillemets. Le séparateur explicite reste la méthode fiable :

printf "a b\0c d" | xargs -0 -n 1   # CORRECT : séparateur nul, aucune ambiguïté

Pipe après -I

ls | xargs -I {} echo {} | wc -l   # INCORRECT : le pipe sort du périmètre de xargs

Symptôme : le pipe s'applique à la sortie de xargs, pas à chaque élément. Cause : -I capture tout ce qui suit comme une seule commande.

ls | xargs -I {} sh -c 'echo {} | wc -c'   # CORRECT : sh -c encapsule le pipe

Travaux pratiques

Rien ne remplace la pratique. Créez l'environnement de test ci-dessous, puis déroulez les douze étapes. À la fin, nettoyez avec rm -rf ~/xargs-lab.

Préparer le terrain

Ce script crée une arborescence dans ~/xargs-lab : des documents (dont certains avec des espaces dans le nom), des images, des logs et des listes à traiter.

# Créer le lab
mkdir -p ~/xargs-lab/documents ~/xargs-lab/images ~/xargs-lab/logs
cd ~/xargs-lab

# Fichiers avec noms simples
echo "Contenu fichier 1" > documents/rapport.txt
echo "Contenu fichier 2" > documents/notes.txt
echo "Contenu fichier 3" > documents/todo.txt

# Fichiers avec espaces dans le nom (cas problématique)
echo "Fichier avec espace" > "documents/mon rapport.txt"
echo "Autre fichier" > "documents/mes notes importantes.txt"

# Fichiers images
touch images/photo1.jpg images/photo2.jpg images/photo3.png
touch "images/vacances été.jpg"

# Fichiers de log
for i in {1..5}; do
  echo "Log entry $i - $(date)" > logs/app$i.log
done

# Liste de fichiers à traiter
cat > fichiers.txt << 'EOF'
documents/rapport.txt
documents/notes.txt
documents/todo.txt
EOF

# Fichier avec URLs
cat > urls.txt << 'EOF'
https://example.com/page1
https://example.com/page2
https://example.com/page3
EOF

echo "Correct : Lab créé dans ~/xargs-lab"
ls -laR ~/xargs-lab

Les douze étapes

Déroulez-les dans l'ordre : chaque étape réutilise ce que la précédente a produit. Les quatre premières restent inoffensives, les suivantes touchent à des fichiers réels du lab. Après chaque commande, comparez la sortie obtenue à la phrase d'explication qui la suit ; si elles divergent, c'est presque toujours le découpage de l'entrée qui a changé.

1. Comportement par défaut. Observez ce que fait xargs sans commande.

   echo "un deux trois" | xargs

   Sans commande, xargs transmet les arguments à echo, la sortie est un deux trois.

2. Supprimer des fichiers listés (test). Visualisez la suppression des fichiers listés dans fichiers.txt.

   cd ~/xargs-lab && cat fichiers.txt | xargs echo rm

   echo devant rm montre la commande qui serait exécutée, sans rien supprimer.

3. Limiter les arguments. Affichez les nombres 1 à 6, deux par ligne.

   echo "1 2 3 4 5 6" | xargs -n 2 echo

   -n 2 limite chaque appel d'echo à 2 arguments.

4. Positionner l'argument. Créez une copie .bak de chaque .txt du dossier documents.

   ls ~/xargs-lab/documents/*.txt | xargs -I {} cp {} {}.bak

   -I {} remplace {} par chaque argument, ce qui permet de l'employer deux fois.

5. Confirmation interactive. Demandez une confirmation avant chaque suppression.

   echo "test1.tmp test2.tmp" | xargs -p rm

   -p affiche la commande et attend y/n avant de l'exécuter.

6. Afficher les commandes exécutées. Tracez chaque commande avant son exécution.

   echo "1 2 3" | xargs -t -n 1 echo "Nombre:"

   -t écrit la commande sur stderr juste avant de la lancer.

7. Gérer les espaces avec find -print0. Listez tous les .txt de documents, espaces compris.

   find ~/xargs-lab/documents -name "*.txt" -print0 | xargs -0 ls -l

   -print0 et -0 utilisent le caractère nul comme séparateur, mon rapport.txt reste un seul argument.

8. Ne pas exécuter si vide. Évitez de lancer rm si aucun fichier .xyz n'existe.

   find ~/xargs-lab -name "*.xyz" | xargs -r rm

   -r empêche l'exécution lorsque l'entrée est vide.

9. Exécution parallèle. Simulez le téléchargement de 3 URLs en parallèle.

   cat ~/xargs-lab/urls.txt | xargs -P 3 -I {} echo "Downloading {}"

   -P 3 lance jusqu'à 3 commandes simultanément.

10. Combiner find et xargs pour grep. Cherchez Contenu dans tous les .txt.

    find ~/xargs-lab/documents -name "*.txt" -print0 | xargs -0 grep "Contenu"

    xargs passe toute la liste de fichiers à grep en une seule invocation.

11. Pipeline complexe avec sh -c. Comptez les lignes de chaque fichier de log.

    ls ~/xargs-lab/logs/*.log | xargs -I {} sh -c 'echo -n "{} : "; wc -l < "{}"'

    sh -c permet d'utiliser un pipe ou plusieurs commandes pour chaque élément.

12. Compresser des fichiers. Créez une archive tar.gz de tous les .txt.

    find ~/xargs-lab -name "*.txt" -print0 | xargs -0 tar -czvf ~/xargs-lab/archive.tar.gz

    xargs transmet tous les fichiers trouvés à tar en une fois.

Exercices progressifs

Dix exercices pour valider votre maîtrise. Ils se traitent sur le lab ~/xargs-lab. Cherchez d'abord par vous-même, puis dépliez la solution pour vous corriger.

Niveau fondations

Ces quatre exercices portent sur le découpage et le placement des arguments, sans risque pour vos fichiers. Ils se traitent en une ligne chacun. Si vous butez, relancez la commande en ajoutant -t : la trace affichée montre exactement ce que xargs a construit avant d'exécuter.

Exercice 1, Transformation basique. Affichez fichier1 fichier2 fichier3 sur une seule ligne avec xargs. Indice : echo suivi de xargs sans argument.

Voir la solution

echo "fichier1 fichier2 fichier3" | xargs

Sans commande, xargs utilise echo et concatène les arguments.

Exercice 2, Limiter les arguments. Affichez les nombres 1 à 6, deux par ligne. Indice : -n limite le nombre d'arguments.

Voir la solution

echo "1 2 3 4 5 6" | xargs -n 2

-n 2 exécute echo avec 2 arguments à chaque passage.

Exercice 3, Positionner l'argument. Créez les fichiers backup_1.txt, backup_2.txt, backup_3.txt. Indice : -I {} positionne l'argument.

Voir la solution

printf "1\n2\n3\n" | xargs -I {} touch backup_{}.txt

-I {} remplace {} par chaque ligne d'entrée, d'où le printf avec des retours à la ligne. La variante echo "1 2 3" | xargs -I {} touch backup_{}.txt échoue : -I découpant sur les sauts de ligne, elle crée un unique fichier nommé backup_1 2 3.txt. Ajouter -n 1 ne corrige rien, xargs avertit que -n et -I sont mutuellement exclusifs et ignore le -n.

Exercice 4, Mode verbeux. Affichez chaque commande echo avant son exécution. Indice : -t pour trace.

Voir la solution

echo "a b c" | xargs -t -n 1 echo

-t affiche la commande sur stderr avant de l'exécuter.

Niveau composition

On passe à l'enchaînement de plusieurs commandes et à la robustesse. Ces quatre exercices reproduisent les situations qui cassent en production : noms de fichiers avec espaces, entrée vide, recherche sur une liste calculée. La bonne réponse tient toujours compte de ce que produit la commande en amont, pas seulement de ce que doit faire la commande en aval.

Exercice 5, Gérer les espaces. Listez les fichiers .txt du lab, même ceux avec des espaces dans le nom. Indice : find -print0 + xargs -0.

Voir la solution

find ~/xargs-lab -name "*.txt" -print0 | xargs -0 ls -l

-print0 et -0 utilisent le caractère nul comme séparateur.

Exercice 6, Éviter l'exécution vide. N'exécutez pas rm si aucun fichier .xyz n'existe. Indice : -r pour no-run-if-empty.

Voir la solution

find ~/xargs-lab -name "*.xyz" | xargs -r rm

-r empêche l'exécution lorsque l'entrée standard est vide.

Exercice 7, Recherche dans les fichiers trouvés. Cherchez Contenu dans tous les .txt du lab. Indice : find + xargs + grep.

Voir la solution

find ~/xargs-lab -name "*.txt" -print0 | xargs -0 grep "Contenu"

xargs passe tous les fichiers .txt trouvés à grep.

Exercice 8, Confirmation interactive. Demandez une confirmation avant de supprimer chaque fichier. Indice : -p pour prompt, -n 1 un fichier à la fois.

Voir la solution

echo "file1 file2" | xargs -p -n 1 rm

-p demande confirmation ; -n 1 traite un fichier à la fois.

Niveau industrialisation

Les deux derniers exercices sortent du cadre « une commande, une liste ». Ils mobilisent le parallélisme et l'encapsulation par sh -c, seule façon d'utiliser un pipe ou une redirection à l'intérieur de chaque exécution. Chronométrez l'exercice 9 avec time : c'est la démonstration la plus parlante de ce que -P apporte.

Exercice 9, Exécution parallèle. Simulez 4 traitements en parallèle (un sleep puis un echo). Indice : -P pour le parallélisme.

Voir la solution

printf "1\n2\n3\n4" | xargs -P 4 -I {} sh -c 'sleep 1; echo "Done {}"'

-P 4 lance jusqu'à 4 processus simultanément, les 4 se terminent quasi en même temps.

Exercice 10, Pipeline complexe. Pour chaque fichier .log du lab, comptez les lignes contenant Log. Indice : sh -c pour les pipes dans xargs.

Voir la solution

find ~/xargs-lab -name "*.log" -print0 | xargs -0 -I {} sh -c 'echo -n "{} : "; grep -c "Log" "{}"'

sh -c autorise les pipes et redirections pour chaque élément traité.

Dépannage

Quand xargs se comporte mal, le problème vient presque toujours du découpage de l'entrée (espaces, lots, placeholder). Voici comment diagnostiquer.

Méthodes de diagnostic

Ces quatre commandes se lancent dans cet ordre. Les trois premières rendent visible ce que xargs fabrique réellement ; la quatrième donne la limite système à partir de laquelle le noyau refuse la ligne de commande. Sur une machine récente, getconf ARG_MAX retourne souvent plus de deux millions d'octets, mais xargs --show-limits donne la valeur qui compte vraiment : la taille du tampon effectivement utilisé, variables d'environnement déduites.

# Voir ce qui serait exécuté, sans rien exécuter
find . -name "*.tmp" | xargs echo rm

# Afficher chaque commande avant exécution
echo "a b c" | xargs -t -n 1 echo

# Demander confirmation avant chaque exécution
cat liste.txt | xargs -p rm

# Connaître la taille maximale des arguments du système
getconf ARG_MAX

# Voir la limite réellement appliquée par xargs sur cette machine
xargs --show-limits < /dev/null

Erreurs fréquentes

Trois messages reviennent en boucle. Le point commun : xargs les renvoie souvent avec le nom de la commande cible en préfixe, ce qui fait croire à un problème de rm ou de grep. Vérifiez toujours l'entrée avant d'incriminer la commande, en la rejouant avec xargs echo devant.

Message d'erreur	Cause probable	Solution
Argument list too long	Trop de fichiers passés en une fois	Limiter les lots avec xargs -n
No such file or directory	Espaces ou caractères spéciaux dans les noms	Utiliser find -print0 | xargs -0
xargs: unmatched single quote	Apostrophe dans un nom de fichier	Utiliser -0 pour ignorer les caractères spéciaux

Glissez pour voir

Aide-mémoire xargs

Options

Cette liste étend le tableau des sept options essentielles avec trois entrées utiles au quotidien : -L découpe par lignes et non par mots, -a évite le cat inutile en lisant directement un fichier, -d change le séparateur quand l'entrée est un CSV ou une variable. Attention à -d et -0 : tous deux désactivent le traitement des guillemets et de l'antislash.

Option	Rôle	Exemple
-n N	Au plus N arguments par exécution	xargs -n 2
-I {}	{} comme placeholder	xargs -I {} mv {} {}.bak
-0	Séparateur nul (avec find -print0)	find . -print0 | xargs -0
-p	Confirmation avant exécution	xargs -p rm
-t	Affiche la commande (trace)	xargs -t echo
-r	Ne rien exécuter si l'entrée est vide	xargs -r rm
-P N	N processus en parallèle	xargs -P 4
-L N	Au plus N lignes par exécution	xargs -L 1
-a fichier	Lire depuis un fichier au lieu de stdin	xargs -a liste.txt rm
-d delim	Définir le séparateur	xargs -d ","

Glissez pour voir

Enchaînements courants

Quatre motifs à mémoriser tels quels. Le deuxième, find -print0 | xargs -0, est celui à écrire par défaut dès qu'il s'agit de fichiers : il coûte six caractères de plus et supprime toute une classe d'incidents. Le troisième, sh -c, est le seul moyen d'utiliser un pipe ou une redirection à l'intérieur de chaque exécution.

Enchaînement	Rôle	Exemple
cmd | xargs	Transformer stdin en arguments	echo "a b" | xargs echo
find -print0 | xargs -0	Pattern sûr pour les fichiers	find . -name "*.txt" -print0 | xargs -0 rm
xargs -I {} sh -c '…'	Commande complexe avec pipes	xargs -I {} sh -c 'cat {} | wc -l'
cmd | xargs echo	Tester sans exécuter	cat liste | xargs echo rm

Glissez pour voir

Checklist de maîtrise

Vous maîtrisez xargs lorsque vous pouvez cocher chacun de ces points :

• Je sais transformer une entrée standard en arguments
• Je sais limiter le nombre d'arguments avec -n
• Je sais positionner l'argument avec -I {}
• Je sais déboguer avec -t et -p
• Je sais gérer les noms avec espaces grâce à -0
• Je sais éviter l'exécution sur entrée vide avec -r
• Je sais combiner find, xargs et grep
• Je sais exécuter en parallèle avec -P
• Je sais encapsuler un pipe avec sh -c

Conclusion

La commande xargs est le chaînon manquant entre les commandes qui produisent des listes (find, grep -l, cat) et celles qui attendent des arguments (rm, mv, cp). Ses options clés sont -0 (sécurité avec les espaces), -I {} (positionnement), -n (limitation) et -P (parallélisme). Pour des besoins plus avancés (machines distantes, jobs complexes), explorez parallel.

Articles qui pourraient vous intéresser

• Maîtriser find pour la recherche de fichiers
• Maîtriser grep pour la recherche de patterns
• Maîtriser parallel pour l'exécution parallèle
• Personnaliser Bash : .bashrc, alias et prompt

FAQ - Questions Fréquemment Posées

Les questions ci-dessous reprennent les points qui reviennent le plus souvent sur xargs : la syntaxe de base, le traitement des noms de fichiers contenant des espaces, le comportement sur entrée vide, la limite d'arguments et le parallélisme.

Qu'est-ce que la commande xargs sous Linux ?

La commande xargs permet de prendre l'entrée standard (comme une liste de fichiers) et de la transformer en arguments pour une autre commande, automatisant ainsi des tâches répétitives.

Pourquoi utiliser xargs ?

Xargs est utile pour traiter de grandes listes d'arguments sans dépasser la limite de longueur des commandes, et pour chaîner des commandes comme find, grep ou ls avec des actions comme rm ou mv.

Quelle est la syntaxe de base de xargs ?

La syntaxe est : commande_qui_genere | xargs commande_a_executer. Par défaut, xargs utilise echo si aucune commande n’est spécifiée.

Comment limiter le nombre d'arguments par commande ?

On utilise l'option -n, par exemple : echo "1 2 3 4" | xargs -n 2 echo, ce qui exécute la commande avec 2 arguments à la fois.

Comment confirmer chaque commande avant exécution ?

L'option -p demande une confirmation avant chaque exécution, par exemple : echo fichiers | xargs -p rm.

Comment insérer un argument à une place précise dans la commande ?

L'option -I permet de définir un jeton à remplacer, par exemple : echo fichier.txt | xargs -I {} mv {} /tmp/{}.

Comment gérer les fichiers avec des espaces dans leur nom ?

Il faut utiliser find avec -print0 et xargs avec -0 pour gérer correctement les noms de fichiers contenant des espaces : find . -name "*.txt" -print0 | xargs -0 rm.

Quelle option permet d'afficher la commande avant exécution ?

L'option -t affiche chaque commande avant de l'exécuter, utile pour le débogage.

Que fait xargs si aucune commande n’est fournie ?

Par défaut, xargs utilise la commande echo, ce qui permet de tester la chaîne d'arguments facilement.

Comment éviter d'exécuter une commande si l'entrée est vide ?

L'option --no-run-if-empty (ou -r sous GNU) permet de ne rien exécuter si aucune entrée n'est fournie.

Comment supprimer des fichiers listés dans un fichier texte ?

On peut utiliser : cat liste.txt | xargs rm, pour supprimer chaque fichier mentionné dans liste.txt.

Xargs exécute-t-il les commandes en parallèle ?

Non par défaut, mais on peut ajouter l’option -P pour spécifier le nombre de processus parallèles.

Quelle est la limite d'arguments pour xargs ?

Xargs respecte la limite système de longueur des arguments, consultable avec : getconf ARG_MAX.

Comment utiliser xargs pour rechercher un motif dans plusieurs fichiers ?

Par exemple : find . -name "*.txt" | xargs grep "erreur", pour rechercher le mot 'erreur' dans tous les fichiers .txt.

Quelles sont les précautions à prendre avec xargs ?

Toujours tester la commande avec echo ou -p, bien gérer les fichiers avec des espaces avec -0, et être attentif aux commandes destructives comme rm ou mv.

Contrôle de connaissances

Vérifiez que l'essentiel de ce guide est acquis. Les questions portent uniquement sur ce qui vient d'être expliqué ici.

Contrôle de connaissances

Validez vos connaissances avec ce quiz interactif

6 questions

6 min.

70% requis

Informations

• Le chronomètre démarre au clic sur Démarrer
• Questions à choix multiples, vrai/faux et réponses courtes
• Vous pouvez naviguer entre les questions
• Les résultats détaillés sont affichés à la fin

Démarrer le quiz

Lance le quiz et démarre le chronomètre

×

📖 Voir la documentation →