Redirections avancées, here-doc et xargs

Le shell fait bien plus que rediriger > et <. Le here-doc permet d’intégrer un bloc de texte directement dans un script sans fichier temporaire. La process substitution traite la sortie d’une commande comme si c’était un fichier. Et xargs transforme n’importe quel flux en arguments d’une commande — avec ou sans parallélisme.

Ce sont des techniques directement ciblées par l’objectif LFCS (“Create and Edit Text Files”, “Use Input/Output Redirection”).

Ce que vous allez apprendre

• Créer du contenu textuel multiligne avec << EOF dans des scripts
• Contrôler l’interpolation des variables dans un here-doc
• Comparer deux sorties de commandes avec diff <(...) sans fichier temporaire
• Extraire les lignes communes ou uniques avec comm et la process substitution
• Transformer un flux en arguments avec xargs, -I {}, -n1 et -P
• Protéger les noms de fichiers avec espaces grâce à -print0 | xargs -0

Prérequis

• Maîtrise du shell bash (redirections >, <, pipes |)
• Bases des commandes de traitement de texte (grep, sort, diff)

Lab A — Shell local : tous les exemples s’exécutent directement dans votre terminal. Créez le dossier de travail :

mkdir -p ~/Projets/lab-linux/exploiter/redirections-avancees
cd ~/Projets/lab-linux/exploiter/redirections-avancees

---

Here-doc : un bloc de texte sans fichier

Un here-doc permet d’injecter un bloc de texte multiligne directement dans une commande ou un script — sans créer de fichier intermédiaire.

Syntaxe de base

cat << 'EOF'
Serveur : web01
IP      : 192.168.1.10
Rôle    : nginx reverse proxy
EOF

Le marqueur peut s’appeler EOF, END, HEREDOC ou n’importe quoi d’autre — c’est la convention EOF qui est universelle. La ligne de fermeture doit être seule sur sa ligne, sans espace avant.

Avec interpolation de variables

SERVEUR="web01"
IP="192.168.1.10"

cat << EOF
Rapport généré le $(date +%Y-%m-%d)
Hôte    : $SERVEUR
Adresse : $IP
EOF

Sortie :

Rapport généré le 2026-04-09
Hôte    : web01
Adresse : 192.168.1.10

Quand le marqueur n’est pas entre guillemets (<< EOF), le shell interprète $VAR et $(cmd).

Sans interpolation — marqueur entre guillemets

cat << 'EOF'
Pour accéder à $SERVEUR, tapez : ssh $USER@$IP
Expansion désactivée : $(date) ne sera pas remplacé
EOF

Sortie littérale — aucune variable n’est expansée. Utile pour générer des scripts ou du code contenant des variables shell.

Règle simple

<< EOF → le shell interprète les variables << 'EOF' → le texte est copié tel quel

Créer un fichier directement

cat > /etc/nginx/conf.d/app.conf << 'EOF'
server {
    listen 80;
    server_name app.local;
    location / {
        proxy_pass http://127.0.0.1:3000;
    }
}
EOF

La combinaison cat > fichier << 'EOF' est la base de nombreux scripts de déploiement et d’infrastructure-as-code.

Here-doc indenté avec <<-

Pour indenter proprement un here-doc dans une fonction ou un bloc if :

generer_config() {
    local host=$1
    cat <<-EOF
  Hôte : $host
  Date : $(date +%Y-%m-%d)
  Status : actif
  EOF
}

generer_config "web01"

<<- supprime les tabulations en début de ligne (pas les espaces — utiliser des vraies tabs dans l’éditeur).

---

Alimenter des commandes avec un here-doc

Le here-doc n’est pas réservé à cat. Il peut alimenter n’importe quelle commande qui lit sur stdin :

# Passer des requêtes SQL à mysql
mysql -u root -p ma_base << 'EOF'
SELECT user, host FROM mysql.user;
SHOW DATABASES;
EOF

# Alimenter sed avec un here-doc
sed 's/prod/staging/' << 'EOF'
Serveur prod01
Base prod-db
Config : prod.conf
EOF

# Transmettre une liste de paquets à xargs
xargs apt-get install -y << 'EOF'
curl
jq
tree
htop
EOF

---

Process substitution : <(cmd) traite une sortie comme un fichier

La process substitution permet de passer la sortie d’une commande là où un outil attend un fichier. Bash crée un descripteur de fichier virtuel (/dev/fd/N) à la volée.

diff entre deux sorties de commandes

Sans process substitution, comparer deux sorties requiert des fichiers temporaires :

# Méthode classique — 3 étapes
ls /etc/*.conf | sort > /tmp/list_conf.txt
ls /var/log/*.conf 2>/dev/null | sort > /tmp/list_log_conf.txt
diff /tmp/list_conf.txt /tmp/list_log_conf.txt
rm /tmp/list_conf.txt /tmp/list_log_conf.txt

Avec process substitution — une ligne :

diff <(ls /etc/*.conf | sort) <(ls /var/log/*.conf 2>/dev/null | sort)

Cas d’usage typique : comparer deux fichiers dans un ordre trié que vous ne voulez pas enregistrer.

# Comparer deux listes triées
diff <(sort liste1.txt) <(sort liste2.txt)

Sortie :

2d1
< bravo
4d2
< delta
5a4,5
> foxtrot
> golf
> hotel

comm avec process substitution

comm compare deux fichiers supposés triés. La process substitution évite de pré-trier sur disque :

# Lignes présentes dans liste1 mais pas dans liste2
comm -23 <(sort liste1.txt) <(sort liste2.txt)

Option	Affiche
-23	Uniquement colonne 1 (liste1 seule)
-13	Uniquement colonne 2 (liste2 seule)
-12	Uniquement les lignes communes

Glissez pour voir

# Utilisateurs système avec UID ≥ 1000 qui ne sont pas connectés
comm -23 \
  <(awk -F: '$3 >= 1000 {print $1}' /etc/passwd | sort) \
  <(who | awk '{print $1}' | sort -u)

wc sur une sortie filtrée

# Compter les lignes d'erreur dans un log sans fichier temporaire
wc -l < <(grep "ERROR" /var/log/syslog 2>/dev/null)

Bash uniquement

La process substitution <(...) est une fonctionnalité bash (et zsh). Elle n’existe pas en sh POSIX. Dans un script, vérifiez la ligne shebang : #!/bin/bash.

---

xargs : transformer un flux en arguments

xargs lit stdin ligne par ligne (ou mot par mot) et passe chaque entrée comme argument à une commande. C’est l’alternative aux boucles for f in $(ls ...) — plus robuste et plus efficace.

Usage basique

# Compter les lignes de tous les fichiers .txt
ls *.txt | xargs wc -l

Équivaut à wc -l liste1.txt liste2.txt mais fonctionne même avec 1000 fichiers (la limite d’arguments shell ne s’applique pas).

# Afficher la taille de toutes les configs nginx
find /etc/nginx -name "*.conf" | xargs ls -lh

-I {} : placer l’argument à un endroit précis

Par défaut, xargs ajoute l’argument à la fin. -I {} permet de le placer n’importe où dans la commande :

# Copier des fichiers listés dans un fichier vers un dossier backup
cat liste1.txt | xargs -I {} cp {} backup/

# Renommer en ajoutant une extension .bak
find /etc -name "*.conf" -maxdepth 1 | xargs -I {} cp {} {}.bak

-n1 : un appel par argument

Sans -n1, xargs regroupe les arguments pour minimiser le nombre d’appels. Avec -n1, chaque entrée déclenche un appel séparé :

# Voir chaque fichier séparément
echo "liste1.txt liste2.txt" | xargs -n1 wc -l

Sortie :

5 liste1.txt
5 liste2.txt

Vs sans -n1 : wc -l liste1.txt liste2.txt (un seul appel avec total).

-P : traitement parallèle

# Compresser tous les logs en parallèle (4 processus simultanés)
find /var/log -name "*.log" | xargs -P4 gzip

# Télécharger une liste d'URLs en parallèle
cat urls.txt | xargs -P8 -I {} wget -q {}

Quand utiliser -P ?

-P est utile pour les tâches I/O-bound (compression, téléchargement, copie réseau). Pour les tâches CPU-bound, la valeur recommandée est le nombre de cœurs : $(nproc).

Here-doc + xargs : la combinaison la plus lisible

# Installer une liste de paquets définie dans le script
xargs apt-get install -y << 'EOF'
git
curl
jq
htop
tree
EOF

# Copier une liste de fichiers avec une source explicite
cat << 'EOF' | xargs -I {} cp /etc/{} /tmp/backup/
passwd
group
hosts
hostname
EOF

---

Pièges courants

Here-doc : fermeture sur une ligne seule

# ERREUR — espace avant EOF
cat << 'EOF'
contenu
  EOF   # ← ne ferme pas le here-doc !
EOF

Le marqueur de fermeture doit être seul, sans espace, en colonne 1 (sauf avec <<- qui tolère les tabs).

Process substitution : bash requis

#!/bin/sh   # ← ERREUR si on utilise <(...)
diff <(sort f1) <(sort f2)   # Syntax error: unexpected "("

Solution : changer le shebang en #!/bin/bash.

xargs et noms avec espaces

# Problème : "fichier avec espace.txt" devient 3 arguments
ls *.txt | xargs wc -l
# → wc: fichier: No such file or directory

Solution : find avec -print0 (séparateur null) et xargs -0 :

find . -name "*.txt" -print0 | xargs -0 wc -l

xargs : rien à traiter

Si le flux est vide, xargs appelle quand même la commande sans argument — ce qui peut être indésirable :

# Sécuriser avec --no-run-if-empty (ou -r)
find . -name "*.bak" -print0 | xargs -0 -r rm

---

Tableau récapitulatif

Technique	Syntaxe	Usage typique
Here-doc avec interpolation	<< EOF	Générer des configs dans un script
Here-doc sans interpolation	<< 'EOF'	Générer du code ou des templates
Here-doc indenté	<<- EOF	Lisibilité dans les fonctions
Process substitution	<(cmd)	diff, comm, comparaisons à la volée
xargs basique	cmd | xargs cmd2	Appliquer une commande à une liste
xargs avec position	... | xargs -I {} cmd {}	Renommage, copie, transformation
xargs parallèle	... | xargs -P4 cmd	Compression, téléchargement en masse
Protéger les espaces	find -print0 | xargs -0	Noms de fichiers avec espaces

Glissez pour voir

---

À retenir

• << EOF interprète les variables ; << 'EOF' ne le fait pas — le choix est explicite, pas accidentel.
• La process substitution <(cmd) évite les fichiers temporaires et rend les scripts plus lisibles.
• xargs est plus robuste et plus efficace que for f in $(ls ...) pour traiter des listes.
• Toujours utiliser -print0 | xargs -0 dès que des noms de fichiers peuvent contenir des espaces.
• La process substitution ne fonctionne qu’avec bash — vérifier le shebang dans les scripts.

Traiter des données avec awk Filtrer par champ, calculer des totaux et reformater des sorties avec awk.

Transformer des fichiers avec sed Substitution, adresses, in-place et groupes de capture avec sed.

Écrire un script shell Variables, conditions, boucles et fonctions — les bases du scripting bash.

Trier et compter des données sort, uniq, wc, tr et cut pour analyser des sorties en ligne de commande.

Référence xargs Toutes les options xargs : -I, -P, -0, -n, --max-procs — le condensé pour traiter des listes en masse.

×

📖 Voir la documentation →