La commande cat de Linux est l'une des commandes Linux les plus fré­quem­ment utilisées. Elle est surtout utile pour afficher le contenu d'un fichier en sortie standard. Cependant, il existe un certain nombre d'autres uti­li­sa­tions, que nous abordons dans cet article.

Qu'est-ce que la commande cat de Linux ?

Malgré son nom, la commande cat de Linux n'a rien à voir avec les chats. En fait, cette commande permet de faire quelque chose d'assez banal : la commande cat de Linux lit le contenu des fichiers et l'affiche sur la sortie standard. L'origine du nom vient du terme « con­ca­té­na­tion » (plus d'in­for­ma­tions à ce sujet ci-dessous).

Examinons le schéma de base d'un appel à la commande cat de Linux. Comme vous pouvez le voir, nous écrivons d'abord 'cat', suivi d'options si né­ces­saire, puis du nom/chemin des fichiers à afficher :

cat [Options] <Nomdefichier>

La commande cat de Linux ap­par­tient aux outils de base (Coreutils) GNU. Il s'agit d'une col­lec­tion de commandes de base en ligne de commande. Les coreutils sont des « logiciels libres et open source » (FOSS) et sont présents dans presque toutes les dis­tri­bu­tions Linux. De plus, la commande cat de Linux est dis­po­nible sous macOS ainsi que sous Windows en utilisant le « sous-système Windows pour Linux » (WSL/WSL2).

Conseil

Pour dé­ter­mi­ner si la commande cat de Linux est dis­po­nible sur votre système, procédez comme suit : ouvrez un terminal et exécutez la commande ‘which cat’. Si la commande cat de Linux est présente sur votre système, le chemin de l'exé­cu­table cat (par exemple, '/bin/cat') est affiché. Si un message d'erreur s'affiche, la commande cat de Linux n'est pas dis­po­nible sur votre système.

Options de la commande cat de Linux

Comme la plupart des commandes du terminal, la commande cat de Linux est contrôlée par des pa­ra­mètres op­tion­nels lors­qu'elle est appelée. Ces options suivent le nom de la commande. Il convient de noter qu'une dis­tinc­tion est faite entre les ma­jus­cules et les mi­nus­cules. Il existe gé­né­ra­le­ment deux manières d’écrire la plupart des options :

1. Forme courte : -, par exemple 'cmd -h'

La forme abrégée n'est pas très explicite. Plusieurs options peuvent être combinées en une seule, par exemple 'ls -la' au lieu de 'ls -l -a'. La forme courte est adaptée pour tra­vail­ler ra­pi­de­ment avec des commandes connues en ligne de commande.

2. Forme longue : --, par exemple 'cmd --help'

La forme longue est facile à com­prendre, mais elle est plus longue à taper et prend plus de place. La forme longue est adaptée à la création de scripts. Les noms d'options sig­ni­fi­ca­tifs sont utilisés à des fins de do­cu­men­ta­tion.

Examinons les options les plus im­por­tantes de la commande cat de Linux :

Option Ex­pli­ca­tion
-h, --help afficher l'aide de la commande cat de Linux
-n numéroter toutes les lignes
-s combiner plusieurs lignes vierges en une seule
-b numéroter toutes les lignes sauf les lignes vides
-v afficher les ca­rac­tères in­vi­sibles
-e comme -v, y compris le marqueur de fin de ligne
-t comme -v, y compris le marqueur de ta­bu­la­tion
-et Com­bi­nai­son de -e et -t ; numéroter tous les ca­rac­tères in­vi­sibles

Que signifie réel­le­ment la con­ca­té­na­tion ?

Le nom de la commande cat de Linux vient de « con­ca­té­na­tion », lui-même dérivé du terme latin « catena » pour chaîne. La con­ca­té­na­tion est un concept important en in­for­ma­tique. Ce terme décrit le chaînage, l'en­chaî­ne­ment ou la jonction d'élé­ments de struc­tures de données de con­te­neurs si­mi­laires. En par­ti­cu­lier, plusieurs tableaux ou chaînes peuvent être combinés en un seul tableau ou une seule chaîne dans la plupart des langages. Dans ce processus, les éléments in­di­vi­duels des con­te­neurs con­ca­té­nés sont combinés dans un nouveau conteneur tout en con­ser­vant l'ordre.

Un exemple simple en pseudo-code : nous passons plusieurs chaînes de ca­rac­tères à la fonction cat, qui sont combinées en une seule chaîne.

cat("Pierre ", "et ", "Paul") -> "Pierre et Paul"

La commande cat de Linux fait con­cep­tuel­le­ment la même chose : elle traite en tant qu’éléments les lignes groupées dans un fichier.

Les dif­fé­rents langages de pro­gram­ma­tion utilisent des symboles dif­fé­rents pour l'opé­ra­teur de con­ca­té­na­tion des chaînes de ca­rac­tères. Examinons quelques exemples de langages de pro­gram­ma­tion po­pu­laires. Dans tous les cas, le résultat de la con­ca­té­na­tion est la chaîne « Pierre et Paul » :

Opérateur Langue(s) Exemple
+ Java, Ja­vaS­cript, Python Pierre + "et" + " Paul"
. PHP, Perl Pierre . "et" . " Paul"
.. Lua Pierre .. "et" .. " Paul"
~ Twig Pierre ~ "et" ~ " Paul"
& Vi­sual­Ba­sic Pierre & "et" & " Paul"

Certains langages, notamment Python, utilisent le même opérateur pour con­ca­té­ner d'autres struc­tures de données con­te­neu­ri­sées telles que des listes :

# Concaténer les listes
[1, 2, 3] + [45, 56, 67]
# -> [1, 2, 3, 45, 56, 67]
# Attention, PAS :
# [[1, 2, 3], [45, 56, 67]]
# Concaténation de tuples
(1, 2) + (33, 44)
# -> (1, 2, 33, 44)

Le langage sta­tis­tique « R » est in­té­res­sant : il ne connaît pas d'opé­ra­teur de con­ca­té­na­tion. Au lieu de cela, la fonction 'c()' est utilisée. Essayez de deviner la sig­ni­fi­ca­tion du « c ». C’est bien cela : il signifie « con­ca­té­ner ». On voit ici la con­ca­té­na­tion imbriquée de plusieurs valeurs :

c(c(1, 2, 3), c(45, 56, 67))
# -> 1, 2, 3, 45, 56, 67

Comment la commande cat de Linux est-elle utilisée en pratique ?

L'uti­li­sa­tion réelle de la commande cat de Linux est limitée. Cela suit la phi­lo­so­phie UNIX : « faire une chose, et la faire bien ». La plupart des scénarios opé­ra­tion­nels résultent du chaînage de commande avec d'autres commandes. Des re­di­rec­tions de l'entrée et de la sortie standard sont utilisées. Plus pré­ci­sé­ment, il s'agit de ce que l’on appelle les pipes et les re­di­rec­tions. Ils sont fournis par le shell et leur uti­li­sa­tion s'étend à toutes les commandes :

Re­di­rec­tion Symbole Uti­li­sa­tion Ex­pli­ca­tion
Pipe | cmd1 | cmd2 Trans­fé­rer la sortie de la commande cmd1 vers l’entrée de la commande cmd2
Input-Redirect < cmd < data Entrée de la commande cmd lue à partir du fichier data
Output-Redirect > cmd > data Écrit la sortie de la commande cmd dans le fichier data ; si né­ces­saire, le fichier existant est écrasé
Output-Redirect >> cmd >> data Écrit la sortie de la commande cmd à la fin du fichier data ; si né­ces­saire, le fichier data est créé

La commande cat de Linux est souvent utilisée avec un certain nombre d'autres commandes Linux. Examinons quelques-unes des plus courantes :

Commande Linux Ex­pli­ca­tion
split divise un fichier en morceaux ; l'opé­ra­tion peut être annulée avec cat
uniq supprimer les lignes d'entrée qui ap­pa­rais­sent plus d'une fois
sort Trier les lignes de l'entrée par ordre al­pha­nu­mé­rique
head, tail Limiter la sortie aux lignes de début et de fin

Passons main­te­nant aux scénarios d'uti­li­sa­tion courante de la commande cat de Linux.

Uti­li­sa­tion de la commande cat de Linux pour sortir des fichiers sur la ligne de commande

L'uti­li­sa­tion la plus courante de la commande cat de Linux est pro­ba­ble­ment d'afficher le contenu complet d’un fichier sur la ligne de commande. Cette fonction est utile pour jeter un coup d'œil rapide sur un fichier. Con­trai­re­ment à l’ouverture du fichier dans un éditeur, vous ne devez pas craindre de modifier ac­ci­den­tel­le­ment le fichier. Voici un exemple de sortie d'un fichier sur la sortie standard :

cat ./path/to/file.txt

Examinons quelques scénarios courants. Imaginez que vous êtes connecté via SSH sur un serveur exécutant WordPress. Vous êtes dans le ré­per­toire racine de WordPress et vous voulez voir le contenu du fichier de con­fi­gu­ra­tion 'wp-config.php'. Alors l’appel suivant de la commande cat de Linux est suffisant :

cat wp-config.php

Souvent, la sortie d’un fichier sur la sortie standard est suf­fi­sante. Cependant, dans certains cas, nous pouvons vouloir copier le contenu du fichier dans le presse-papiers. En outre, la sortie visible peut présenter un risque pour les données sensibles. Dans les deux cas, il est bon de trans­mettre la sortie de la commande cat de Linux à un programme qui écrit les données dans le presse-papiers. Sous macOS, l’outil de ligne de commande 'pbcopy' est dis­po­nible à cet effet ; sous Windows avec WSL/2 et les dif­fé­rentes dis­tri­bu­tions Linux, des outils équi­va­lents tels que 'clip' ou 'xclip' sont dis­po­nibles.

Prenons l’exemple suivant : nous voulons copier notre clé publique SSH pour mettre en place un dépôt GitHub. Supposons également que la clé nommée 'id_rsa.pub' se trouve dans le ré­per­toire '.ssh/' de notre ré­per­toire uti­li­sa­teur. Nous pouvons ensuite réaliser l’opération sous macOS avec l'appel suivant de la commande cat de Linux :

cat ~/.ssh/id_rsa.pub > pbcopy

Comme le nom de la commande cat de Linux le suggère, plusieurs fichiers peuvent être combinés et édités en une seule fois. Imaginons que nous ayons en­re­gis­tré des listes de fruits, de légumes et de produits laitiers dans trois fichiers du ré­per­toire 'food/'. Avec l'appel suivant de la commande cat de Linux, nous combinons les trois listes en une seule et l'écri­vons dans le fichier 'food.txt' :

cat ./food/fruit.txt ./food/veggies.txt ./food/dairy.txt > food.txt

Comme d’habitude sur la ligne de commande, nous pouvons utiliser le caractère générique '*'pour sé­lec­tion­ner tous les fichiers d'un ré­per­toire :

cat ./food/*.txt > food.txt

Écrire du texte dans un fichier avec la commande cat de Linux

En utilisant les re­di­rec­tions de sortie men­tion­nées ci-dessus, vous pouvez écrire du texte dans un fichier avec la commande cat de Linux. Cela peut être utilisé de trois façons :

  1. Créez un nouveau fichier dans lequel le texte saisi est écrit.
  2. Écraser un fichier existant avec le texte saisi.
  3. Attacher le texte saisi à un fichier existant.

Examinons les trois scénarios. Tout d’abord, nous écrivons du texte depuis la ligne de commande dans un fichier inexis­tant :

  1. Invoquez la commande cat de Linux et trans­fé­rez la sortie vers un fichier inexis­tant. La commande accepte les données de l'entrée standard jusqu'à ce que le caractère de fin de fichier (« End-of-file », EOF) soit lu :
cat > new.txt
  1. Saisissez le texte souhaité sur la ligne de commande.
  2. Terminez la saisie en appuyant sur la com­bi­nai­son de touches [Ctrl] + [D]. Cette com­bi­nai­son de touches cor­res­pond au caractère de fin de fichier.

Le texte saisi se trouve main­te­nant dans le fichier 'new.txt'. Nous vérifions cela en appelant la commande 'cat new.txt'.

Utilisons la même approche pour joindre le texte saisi à un fichier existant :

  1. Appelez la commande cat de Linux et trans­fé­rez la sortie dans un fichier existant :
cat >> existing.txt
  1. Saisissez le texte souhaité sur la ligne de commande.
  2. Terminez la saisie en appuyant sur la com­bi­nai­son de touches [Ctrl] + [D].

Si nous utilisons le symbole '>' au lieu du transfert de sortie '>>', le fichier existant est écrasé par le texte saisi. Faites attention : le contenu précédent est ir­ré­vo­ca­ble­ment perdu !

Préparer les données pour un trai­te­ment ultérieur avec la commande cat de Linux

Une uti­li­sa­tion courante de la commande cat de Linux consiste à combiner les données de plusieurs fichiers. Souvent, les données résumées passent par des filtres pour les préparer à un trai­te­ment ultérieur. Ce schéma se retrouve toujours lorsque des données si­mi­laires sont réparties sur plusieurs fichiers. Chacun de ces fichiers contient une entrée par ligne. Pensez, par exemple, à des listes de noms, d’adresses IP ou autres.

Afin d’obtenir une vue d’ensemble de toutes les ca­rac­té­ris­tiques des données, effectuez la tâche suivante : nous voulons combiner toutes les entrées, en sup­pri­mant toute entrée en double. Enfin, les entrées doivent être triées et écrites dans un nouveau fichier. À titre d’exemple concret, imaginons que nous ayons un ensemble de fichiers texte. Chaque fichier contient les noms des acteurs d'un épisode par­ti­cu­lier de la série de dessins animés « Les Simpsons ». Si nous combinons les entrées de tous les fichiers comme décrit, nous obtenons une liste de tous les acteurs des Simpsons.

Les fichiers décrits dans notre exemple avec les acteurs des Simpsons res­sem­ble­raient sché­ma­ti­que­ment à ceci :

simpsons-1.txt simpsons-2.txt simpsons-3.txt
Lisa Bart Bart
Marge Lisa Maggie
Homer Homer Nelson
Flanders Milhouse

Supposons également que les dif­fé­rents fichiers texte se trouvent dans le ré­per­toire « simpsons/ ». L’appel suivant de la commande Linux-Cat, concaténé avec les commandes 'uniq' et 'sort', est suffisant pour écrire la liste de tous les acteurs des Simpsons dans le fichier 'simpsons.txt' :

cat ./simpsons/*.txt | uniq | sort > simpsons.txt

Nu­mé­ro­ta­tion des lignes d'un fichier texte avec la commande cat de Linux

Une uti­li­sa­tion courante de la commande cat de Linux consiste à numéroter les lignes d’un fichier texte. Imaginons que nous ayons un fichier texte avec des entrées, une entrée par ligne. Main­te­nant, nous voulons préfixer chaque ligne avec le numéro de ligne. Cela est utile, par exemple, lorsque nous trans­met­tons le fichier à une autre partie pour examen. Cela permet aux deux parties de se référer à des lignes spé­ci­fiques dans la cor­res­pon­dance.

La nu­mé­ro­ta­tion est très facile avec la commande cat de Linux. Nous utilisons l'option '-n' et une re­di­rec­tion de sortie :

cat -n doc.txt > doc.numbered.txt

Dans le scénario décrit, il peut être judicieux de numéroter toutes les lignes, à l’exception des lignes vides. En outre, nous combinons plusieurs lignes vierges en une seule. Pour cela, nous utilisons la com­bi­nai­son des options '-s' et '-b' :

cat -sb doc.txt > doc.numbered.txt

Com­bi­nai­son de fichiers modèles avec la commande cat de Linux

Un schéma bien connu de la pro­gram­ma­tion Web consiste à assembler des documents à partir de pièces détachées. La com­bi­nai­son des parties dites « modèles » et des parties uniques permet d'obtenir des documents di­ver­si­fiés dont la structure est cohérente. Nor­ma­le­ment, vous utilisez PHP avec l'ins­truc­tion 'include' ou un langage de modèle spécial comme Twig. Cependant, le même principe peut également être mis en œuvre avec la commande cat de Linux.

Imaginons que nous ayons plusieurs modèles de parties dans le ré­per­toire 'parts/'. L’en-tête et le pied de page doivent être iden­tiques dans tous les documents générés. La structure et le contenu de l'en-tête et du pied de page sont définis dans les fichiers 'header.html' et 'footer.html'. En outre, il existe plusieurs fichiers contenant le contenu réel des documents dans le ré­per­toire 'main/'. Les documents finis sont en­re­gis­trés dans le ré­per­toire de sortie 'www/'. Pour créer un document, l'appel suivant de la commande cat de Linux est suffisant :

cat ./parts/header.html ./main/home.html ./parts/footer.html > ./www/index.html

Un autre scénario opé­ra­tion­nel : une base de code doit être fournie avec un texte de licence pour la pu­bli­ca­tion. La licence doit être insérée au début de chaque fichier de code. Imaginons la dis­po­si­tion suivante des ré­per­toires :

  • Fichiers de code source Python avec l'ex­ten­sion '.py' dans le ré­per­toire 'src/'
  • Un fichier de licence 'license.py' dans le ré­per­toire 'inc/'
  • Un ré­per­toire 'dist/' ini­tia­le­ment vide pour stocker les fichiers traités

Nous utilisons la commande cat de Linux dans une boucle. Chaque fois que le corps de la boucle est exécuté, le même fichier de licence est concaténé avec l'un des fichiers sources. Le résultat est écrit dans un nouveau fichier de code source portant le même nom :

for file in ./src/*.py ; do
    cat ./inc/license.py "$file" > "./dist/${file}"
done

Fusionner des fichiers frac­tion­nés avec la commande cat de Linux

La plupart du temps, la commande cat de Linux est utilisée pour traiter les fichiers de texte brut. Cependant, la commande fonc­tionne également avec les fichiers binaires. Ceci est utile dans certains scénarios. D'une part, les commandes Linux 'split' ou 'csplit' peuvent être utilisées pour réas­sem­bler des fichiers qui ont été divisés en plusieurs parties. Nous montrons ici l’approche générale :

# Nom du fichier à désassembler
file_name="./path/to/file"
# Spécifier explicitement l'extension du fichier pour l'ajouter après la fusion
extension="txt"
# Diviser le fichier original en morceaux de 10 kilo-octets avec le préfixe 'part_'
split -b 10k "${file_name}.${extension}" part_
# Fusionner les morceaux individuels dans un nouveau fichier
cat part_* > combined
# Restaurer l'extension de fichier originale
mv combined "combined.${extension}"

D’autre part, la commande cat de Linux se prête à la com­bi­nai­son de té­lé­char­ge­ments partiels. De nombreux outils per­met­tent de mettre les té­lé­char­ge­ments en pause et de les reprendre plus tard. Cela est par­ti­cu­liè­re­ment utile pour té­lé­char­ger un gros fichier sur une connexion réseau faible. N’hésitez pas à essayer l’exemple sur votre propre système :

# Créer un dossier de test sur le bureau
mkdir ~/Desktop/cat-test/
# Changez pour le dossier de test
cd ~/Desktop/cat-test/
# Image de chat du domaine public de WikiMedia
image=https://upload.wikimedia.org/wikipedia/commons/f/fa/Cat_using_computer.jpg
# Télécharger l'image avec 'curl' en deux parties
curl -s -r 0-500000 "$image" -o first-half &
curl -s -r 500001- "$image" -o second-half &
wait
# Combiner les parties et écrire dans le fichier JPEG
cat first-half second-half > image.jpg

Com­bi­nai­son de flux de données avec la commande cat de Linux

La commande cat de Linux peut être utilisée pour combiner des flux de données dans le trai­te­ment vidéo. Nous montrons ici le schéma général. Tout d'abord, nous créons plusieurs flux vidéo courts à partir d'une image JPEG en utilisant la commande ffmpeg. Nous les combinons ensuite en une seule vidéo continue :

# Créer une boucle à partir de l'image
ffmpeg -y -loop 1 -i image.jpg -t 3 \
    -c:v libx264 -vf scale=w=800:h=-1 \
    still.ts
# Créer un fondu enchaîné à partir de l'image
ffmpeg -y -loop 1 -i image.jpg -t 3 \
    -c:v libx264 -vf scale=w=800:h=-1,fade=in:0:75 \
    fadein.ts
# Créer un fondu à partir de l'image
ffmpeg -y -loop 1 -i image.jpg -t 3 \
    -c:v libx264 -vf scale=w=800:h=-1,fade=out:0:75 \
    fadeout.ts
# Combinez le fondu en entrée, la boucle et le fondu en sortie
cat fadein.ts still.ts fadeout.ts > video.ts

Quand ne pas utiliser la commande cat de Linux ?

L'uti­li­sa­tion inutile de la commande cat de Linux est un « anti-modèle » bien connu. Cette situation est décrite dans de nombreux articles ; il existe même un prix « Uti­li­sa­tion inutile de cat ». D’une manière générale, la commande cat de Linux doit être utilisée lorsqu'il est né­ces­saire de combiner plusieurs fichiers. Si vous voulez traiter un seul fichier, c'est gé­né­ra­le­ment possible sans cat.

Examinons l’approche générale qui peut nous aider à minimiser l'uti­li­sa­tion inutile de la commande cat de Linux. Le modèle suivant se retrouve souvent dans les messages de forum et les articles de blog :

cat example.txt | less

La commande cat de Linux est appelée pour lire un seul fichier. La sortie est transmise via une re­di­rec­tion de pipe à la commande less pour afficher le contenu du fichier page par page. Cependant, on peut aussi le faire plus sim­ple­ment :

less < example.txt

Nous appelons la commande less et utilisons la re­di­rec­tion d’entrée du shell pour lire le fichier. Et même cette approche peut être encore sim­pli­fiée :

less example.txt

Au lieu d'uti­li­ser la re­di­rec­tion des entrées, nous passons le fichier à traiter à la commande less. Cela est dû au fait que presque toutes les commandes Linux prennent le(s) nom(s) de fichier(s) comme pa­ra­mètres.

Quelles sont les al­ter­na­tives à la commande cat de Linux ?

Comme décrit ci-dessus, la commande cat de Linux est souvent utilisée inu­ti­le­ment. Il existe des solutions de rechange pour certains des scénarios d'uti­li­sa­tion les plus courants. Nous pré­sen­tons ici trois exemples:

Commande Uti­li­sa­tion al­ter­na­tive Exemple
less / more Sortie du contenu du fichier page par page sur le terminal ou « affichage du contenu page par page sur le terminal » less file.txt, more file.txt
touch Créer un nouveau fichier vide touch new.txt
echo Écrire du texte dans un fichier echo "Text" > file.txt

Quelles sont les commandes si­mi­laires à la commande cat de Linux ?

Il existe un certain nombre de commandes Linux qui sont si­mi­laires à la commande cat. Pour faire une petite blague, les noms de ces commandes sont souvent basés sur le terme cat. Il y a d'abord la commande tac, dont le nom est sim­ple­ment cat inversé. Et voici comment fonc­tionne la commande tac : comme la commande cat de Linux, mais avec la sortie inversée. Ainsi, lorsque la commande tac est appelée avec un seul fichier, la dernière ligne est sortie en premier au lieu de la première comme avec cat.

Une autre commande dont le nom est similaire à la commande cat de Linux est la commande nc, abrégée pour « Netcat ». Cette commande est souvent appelée le « couteau suisse pour TCP/IP ». Au lieu d'opérer sur des fichiers locaux comme cat, Netcat lit et écrit des données via des con­nexions réseau. Vous pouvez en savoir plus dans notre article sur le sujet.

Comme al­ter­na­tive plus récente à la commande cat de Linux, il y a la commande bat. Sur la page GitHub de la commande, elle est appelée « clone de cat avec des ailes » (« A cat clone with wings »). La commande bat conserve les fonc­tion­na­li­tés de base de la commande cat de Linux, mais offre quelques fonctions de confort. En par­ti­cu­lier, la commande bat ajoute une co­lo­ra­tion syn­taxique à la sortie des fichiers de code source.

Aller au menu principal