Commandes shell sur une seule ligne : conditions et boucles

Quand on écrit un script shell, les conditions et les boucles s’étalent naturellement sur plusieurs lignes. C’est lisible, mais parfois encombrant — surtout quand on veut lancer un petit traitement directement dans le terminal, dans une tâche planifiée (cron) ou dans une commande unique. Il existe alors une astuce bien pratique : condenser une structure de contrôle complète sur une seule ligne. On parle de « one-liner ». Cet article explique comment faire, avec des exemples concrets, et surtout dans quels cas c’est utile.

Les exemples de cet article fonctionnent à l’identique dans les principaux shells Unix : Bash, KSH (Korn shell) et sh. La syntaxe présentée est universelle.

Le principe : le point-virgule remplace le saut de ligne

Tout repose sur un caractère : le point-virgule ;. Dans un shell, le ; est un séparateur de commandes : il termine une commande, exactement comme le ferait un retour à la ligne. C’est cette équivalence qui rend l’astuce possible. Partout où un script « normal » passe à la ligne, on peut à la place écrire un ; et continuer sur la même ligne.

Une structure de contrôle comme if ou for n’est, au fond, qu’une suite de mots-clés et de commandes. En remplaçant les sauts de ligne par des ; aux bons endroits, on l’écrit sur une seule ligne. Voyons cela concrètement.

Les conditions en une ligne

Voici une condition classique, écrite sur plusieurs lignes comme on l’apprend d’abord :

if [ -f "$fichier" ]
then
    echo "Le fichier existe"
else
    echo "Absent"
fi

La même condition, condensée sur une seule ligne, donne :

if [ -f "$fichier" ]; then echo "Le fichier existe"; else echo "Absent"; fi

Le résultat est strictement identique. Observez où se placent les ; : après la condition (avant then), après chaque commande interne (avant else et avant fi). La règle est simple : partout où il y aurait eu un saut de ligne, on met un ;. Seule exception à retenir : après then et après else, on ne met pas de ; — ces mots-clés sont directement suivis de la commande.

Les boucles en une ligne

Le même principe s’applique aux boucles. Une boucle for multi-lignes :

for i in 1 2 3
do
    echo "Itération $i"
done

… devient, en une seule ligne :

for i in 1 2 3; do echo "Itération $i"; done

Là encore, les ; remplacent les sauts de ligne : après la liste de valeurs (avant do) et après la commande interne (avant done). Notez qu’après do, pas de ; — comme pour then, il est suivi directement de la commande.

Le même principe vaut pour une boucle while :

n=1; while [ $n -le 3 ]; do echo "n vaut $n"; n=$((n+1)); done

Cette ligne affiche « n vaut 1 », « n vaut 2 », « n vaut 3 ». On y voit même deux astuces combinées : l’initialisation n=1 est enchaînée à la boucle par un ;, et la boucle elle-même est condensée.

Des exemples plus concrets

L’intérêt devient évident sur des cas réels. Parcourir des fichiers et agir sur chacun, en une ligne :

for f in /etc/hostname /etc/hosts; do echo "Fichier : $f"; done

On peut même imbriquer une condition dans une boucle, toujours sur une seule ligne :

for x in 5 12 8; do if [ $x -gt 10 ]; then echo "$x est grand"; else echo "$x est petit"; fi; done

Cette ligne parcourt les valeurs 5, 12 et 8, et affiche pour chacune si elle est « grande » (supérieure à 10) ou « petite ». Le résultat : « 5 est petit », « 12 est grand », « 8 est petit ». Toute la logique — une boucle contenant une condition — tient sur une ligne.

À quoi ça sert vraiment ?

Cette astuce n’est pas qu’un exercice de style. Elle répond à des besoins concrets.

Lancer un traitement rapide dans le terminal. Quand on veut faire une action ponctuelle directement en ligne de commande, écrire un script multi-lignes est fastidieux. Un one-liner se tape d’un coup et s’exécute immédiatement — parfait pour « parcourir ces fichiers et faire X » sans créer de fichier.

Les tâches planifiées (cron). Une entrée de crontab attend une commande sur une seule ligne. Si votre tâche comporte une condition ou une boucle, la forme condensée est la façon naturelle de l’y intégrer, sans avoir à créer un script séparé pour un traitement simple.

Les commandes à distance et les enchaînements. Quand on exécute une commande sur une machine distante, ou qu’on veut passer un traitement en un seul appel, le one-liner permet de tout condenser. Il se marie bien avec les autres opérateurs d’enchaînement du shell : && (exécuter la suite seulement si la commande précédente a réussi) et || (seulement si elle a échoué). Par exemple, commande && echo "OK" || echo "Échec" tient naturellement sur une ligne.

Les pipelines de traitement. Enchaîner des commandes avec des tubes (|) pour filtrer et transformer des données est, par nature, une écriture en une ligne — le one-liner est le langage naturel de ce genre de manipulation.

Quand l’utiliser… et quand l’éviter

Le one-liner est un outil, pas une religion. Il brille pour les traitements courts et ponctuels : une commande qu’on tape dans le terminal, une entrée de cron, un enchaînement simple. Dans ces cas, condenser fait gagner du temps et évite de créer un fichier pour trois lignes.

En revanche, méfiez-vous du piège de la lisibilité. Un one-liner qui devient trop long ou trop complexe — plusieurs conditions imbriquées, une logique élaborée — devient vite illisible et difficile à maintenir ou à déboguer. Dès qu’un traitement gagne en complexité, mieux vaut revenir à un script multi-lignes classique, bien indenté, qui se relit et se corrige facilement. La règle de bon sens : condensez ce qui est court et jetable ; structurez ce qui est durable et complexe.

En résumé

Écrire conditions et boucles sur une seule ligne, en quelques idées clés :

• Le point-virgule ; remplace le saut de ligne : c’est lui qui permet de tout condenser.
• Une condition devient if ... ; then ... ; else ... ; fi ; une boucle devient for ... ; do ... ; done.
• Après then et do, pas de ; — ils précèdent directement la commande.
• C’est idéal pour le terminal, les crons, les commandes distantes et les pipelines.
• À réserver aux traitements courts : au-delà, un script multi-lignes reste plus lisible.

Cette astuce fonctionne dans tous les grands shells Unix (Bash, KSH, sh) et fait partie de la boîte à outils de quiconque travaille en ligne de commande. Bien utilisée, elle rend le travail quotidien plus fluide — à condition de ne jamais sacrifier la lisibilité sur l’autel de la concision.