NDG Linux Essentials

Chapitre 10: Travailler avec du texte

10.1 Introduction

Un grand nombre de fichiers dans un système de fichiers typique sont des fichiers texte. Les
fichiers texte ne contiennent que du texte, sans les caractéristiques de formatage que vous
pourriez voir dans un fichier de traitement de texte.

Comme il y a un grand nombre de ces fichiers sur un système Linux typique, il existe un
nombre important de commandes pour aider les utilisateurs à manipuler les fichiers texte. Il
existe des commandes permettant à la fois de visualiser et de modifier ces fichiers de
diverses manières.

De plus, l'interpréteur de commandes dispose de fonctionnalités permettant de contrôler la

sortie des commandes. Ainsi, au lieu d'afficher la sortie dans la fenêtre du terminal, celle-ci
peut être redirigée vers un autre fichier ou une autre commande. Ces fonctions de
redirection offrent aux utilisateurs un environnement de travail beaucoup plus souple et
puissant.
 10.1.1 Visualisation des fichiers dans le terminal

La commande cat, abréviation de concatenate, est une commande simple mais utile dont les
fonctions incluent la création et l'affichage de fichiers texte, ainsi que la combinaison de
copies de fichiers texte. L'une des utilisations les plus courantes de cat est l'affichage du
contenu des fichiers texte. Pour afficher un fichier dans la sortie standard à l'aide de la
commande cat, tapez la commande suivie du nom du fichier :

sysadmin@localhost:~$ cd Documents
sysadmin@localhost:~/Documents$ cat food.txt
Food is good.

Bien que le terminal soit la sortie par défaut de cette commande, la commande cat peut
également être utilisée pour rediriger le contenu des fichiers vers d'autres fichiers ou vers
l'entrée d'une autre commande en utilisant des caractères de redirection.

10.1.2 Visualisation des fichiers à l'aide d'un pagette

Si l'affichage de petits fichiers avec la commande cat ne pose aucun problème, ce n'est pas
un choix idéal pour les gros fichiers. La commande cat ne permet pas de mettre en pause et
de relancer l'affichage, de sorte que le contenu du fichier est entièrement affiché à l'écran.
Pour les fichiers plus volumineux, utilisez une commande de pagination pour en visualiser le
contenu. Les commandes de pagination affichent une page de données à la fois, ce qui vous
permet d'avancer et de reculer dans le fichier en utilisant les touches de déplacement.

Il existe deux commandes de pagination couramment utilisées :

 La commande less offre une capacité de pagination très avancée. Il s'agit

généralement du paginateur par défaut utilisé par des commandes telles que la
commande man.
 La commande more existe depuis les premiers jours d'UNIX. Bien qu'elle ait moins de
fonctionnalités que la commande less, la commande less n'est pas incluse dans
toutes les distributions Linux. La commande more est toujours disponible.

Les commandes more et less permettent aux utilisateurs de se déplacer dans le document à
l'aide de commandes clavier. Comme les développeurs ont basé la commande less sur la
fonctionnalité de la commande more, toutes les commandes clavier disponibles dans la
commande more fonctionnent également dans la commande less.

Notre contenu se concentre sur la commande less, plus avancée. La commande more est
toujours utile pour les cas où la commande less n'est pas disponible. N'oubliez pas que la
plupart des commandes clavier fournies fonctionnent pour les deux commandes.

10.1.2.1 Commandes de déplacement du pager

Pour visualiser un fichier avec la commande less, passez le nom du fichier comme argument :

sysadmin@localhost:~/Documents$ less words

Il existe de nombreuses commandes de mouvement pour la commande less, chacune avec

de multiples touches ou combinaisons de touches possibles. Bien que cela puisse sembler
intimidant, il n'est pas nécessaire de mémoriser toutes ces commandes de mouvement.
Lorsque vous visualisez un fichier avec la commande less, utilisez la touche H ou Shift+H pour
afficher un écran d'aide :

SUMMARY OF LESS COMMANDS

Commands marked with * may be preceded by a number, N.

Notes in parentheses indicate the behavior if N is given.
A key preceded by a caret indicates the Ctrl key; thus ^K is ctrl-K.

h H Display this help.

q :q Q :Q ZZ Exit.
------------------------------------------------------------------------
 MOVING

e ^E j ^N CR * Forward one line (or N lines).

y ^Y k ^K ^P * Backward one line (or N lines).
f ^F ^V SPACE * Forward one window (or N lines).
b ^B ESC-v * Backward one window (or N lines).
z * Forward one window (and set window to N).
w * Backward one window (and set window to N).
ESC-SPACE * Forward one window, but don't stop at end-of-file.
d ^D * Forward one half-window (and set half-window to N).
u ^U * Backward one half-window (and set half-window to N).
ESC-) RightArrow * Left one half screen width (or N positions).
ESC-( LeftArrow * Right one half screen width (or N positions).
HELP -- Press RETURN for more, or q when done

Le premier groupe de commandes de mouvement sur lequel nous allons nous concentrer est
celui qui est le plus couramment utilisé. Pour rendre les choses encore plus pratiques, les
touches qui sont identiques en plus et en moins sont résumées ci-dessous afin de démontrer
comment se déplacer en plus et en moins en même temps :

Key Movement

Spacebar Window forward

B Window backward

Enter Line forward

Q Exit

H Help

Lorsque vous utilisez less comme un pager, le moyen le plus simple d'avancer d'une page est
d'appuyer sur la barre d'espacement.
 10.1.2.2 Commandes de recherche du téléavertisseur

Il y a deux façons d'effectuer une recherche dans la commande less : recherche en avant ou
en arrière à partir de votre position actuelle.

Pour lancer une recherche vers l'avant à partir de votre position actuelle, utilisez la touche
barre oblique /. Ensuite, tapez le texte ou le motif à rechercher et appuyez sur la touche
Entrée.

Abdul
Abdul's
Abe
/frog

Si une correspondance est trouvée, le curseur se déplace dans le document jusqu'à cette
correspondance. Par exemple, dans le graphique suivant, l'expression "grenouille" a été
recherchée dans le fichier de mots :

bullfrog
bullfrog's
bullfrogs
bullheaded
bullhorn
bullhorn's

Remarquez que "grenouille" n'a pas besoin d'être un mot en soi. Remarquez également que,
bien que la commande less se déplace vers la première correspondance à partir de la
position actuelle, toutes les correspondances sont mises en évidence.

Si aucune correspondance en avant de votre position actuelle ne peut être trouvée, la

dernière ligne de l'écran indiquera Pattern not found :

Pattern not found (press RETURN)

Pour effectuer une recherche en arrière à partir de votre position actuelle, appuyez sur la
touche point d'interrogation ?, puis tapez le texte ou le motif à rechercher et appuyez sur la
touche Entrée. Le curseur se déplace vers l'arrière jusqu'à la première correspondance qu'il
trouve ou signale que le motif est introuvable.

Si une recherche permet de trouver plus d'une correspondance, utilisez la touche n pour
passer à la correspondance suivante et utilisez la combinaison de touches Shift+N pour
passer à une correspondance précédente.
Les termes de recherche utilisent en fait des modèles appelés expressions régulières. Vous
trouverez plus de détails sur les expressions régulières plus loin dans ce chapitre.

10.1.3 Head and Tail

Les commandes head et tail sont utilisées pour afficher uniquement les premières ou les
dernières lignes d'un fichier, respectivement (ou, lorsqu'elles sont utilisées avec un pipe, la
sortie d'une commande précédente). Par défaut, les commandes head et tail affichent dix
lignes du fichier fourni en argument.

Par exemple, la commande suivante affiche les dix premières lignes du fichier
/etc/sysctl.conf :

sysadmin@localhost:~/Documents$ cd
sysadmin@localhost:~$ head /etc/sysctl.conf
#
# /etc/sysctl.conf - Configuration file for setting system variables
# See /etc/sysctl.d/ for additional system variables
# See sysctl.conf (5) for information.
#

#kernel.domainname = example.com

# Uncomment the following to stop low-level messages on console

#kernel.printk = 3 4 1 3

En passant un nombre comme option, les commandes head et tail afficheront le nombre de
lignes spécifié, au lieu des dix standard. Par exemple, pour afficher les cinq dernières lignes
du fichier /etc/sysctl.conf, utilisez l'option -5 :

sysadmin@localhost:~$ tail -5 /etc/sysctl.conf

# Protects against creating or following links under certain conditions
# Debian kernels have both set to 1 (restricted)
# See https://www.kernel.org/doc/Documentation/sysctl/fs.txt
#fs.protected_hardlinks=0
#fs.protected_symlinks=0

L'option -n peut également être utilisée pour indiquer le nombre de lignes à sortir. Passez un
nombre comme argument à l'option :
sysadmin@localhost:~$ head -n 3 /etc/sysctl.conf
#
# /etc/sysctl.conf - Configuration file for setting system variables
# See /etc/sysctl.d/ for additional system variables

Option de valeur négative

Traditionnellement, sous UNIX, le nombre de lignes à afficher était spécifié en tant qu'option
avec l'une ou l'autre des commandes, ainsi -3 signifiait afficher trois lignes. Pour la
commande tail, -3 ou -n -3 signifie toujours afficher trois lignes.

Cependant, la version GNU de la commande head reconnaît -n -3 comme affichant toutes les
lignes sauf les trois dernières, et pourtant la commande head reconnaît toujours l'option -3
comme affichant les trois premières lignes.

Option de valeur positive

La version GNU de la commande tail permet une variation de la manière de spécifier le

nombre de lignes à imprimer. Si l'option -n est utilisée avec un nombre préfixé par le signe
plus, alors la commande tail reconnaît que cela signifie qu'il faut afficher le contenu en
commençant par la ligne spécifiée et en continuant jusqu'à la fin.

Par exemple, l'exemple suivant affiche le contenu du fichier /etc/passwd de la ligne 25 à la

fin du fichier :

sysadmin@localhost:~$ nl /etc/passwd | tail -n +25

25 sshd:x:103:65534::/var/run/sshd:/usr/sbin/nologin
26 operator:x:1000:37::/root:/bin/sh
27 sysadmin:x:1001:1001:System Administrator,,,,:/home/sysadmin:/bin/b
ash

Considérez ceci

Les modifications de fichiers en direct peuvent être visualisées à l'aide de l'option -f de la

commande tail, utile lorsque vous souhaitez voir les modifications apportées à un fichier au
moment où elles se produisent.

Un bon exemple de ceci est l'affichage des fichiers journaux en tant qu'administrateur
système. Les fichiers journaux peuvent être utilisés pour résoudre des problèmes et les
administrateurs les visualisent souvent de manière "interactive" avec la commande tail tout
en exécutant des commandes dans une fenêtre séparée.
Par exemple, si vous vous connectez en tant qu'utilisateur root, vous pouvez résoudre des
problèmes avec le serveur de messagerie en visualisant les modifications en direct du fichier
journal /var/log/mail.log.

10.2 Command Line Pipes

Le caractère pipe | peut être utilisé pour envoyer la sortie d'une commande à une autre. En
général, lorsqu'une commande produit un résultat ou génère une erreur, la sortie est
affichée à l'écran ; cependant, ce n'est pas forcément le cas. Au lieu d'être imprimée à
l'écran, la sortie d'une commande devient une entrée pour la commande suivante. Cet outil
peut s'avérer puissant, notamment lorsqu'il s'agit de rechercher des données spécifiques ; la
tuyauterie est souvent utilisée pour affiner les résultats d'une commande initiale.

Dans les exemples précédents, les commandes head et tail ont reçu des fichiers comme
arguments sur lesquels opérer. Cependant, le caractère pipe vous permet d'utiliser ces
commandes non seulement sur des fichiers, mais aussi sur la sortie d'autres commandes.
Cela peut être utile pour lister un grand répertoire, par exemple le répertoire /etc :

sysadmin@localhost:~$ ls /etc
X11 gss mke2fs.conf rpc
adduser.conf host.conf modprobe.d rsyslog.conf
alternatives hostname modules rsyslog.d
apparmor hosts modules-load.d securetty
apparmor.d hosts.allow motd security
apt hosts.deny mtab selinux
bash.bashrc init.d nanorc services
bind initramfs-tools netplan shadow
bindresvport.blacklist inputrc network shadow-
binfmt.d insserv.conf.d networks shells
ca-certificates iproute2 newt skel
ca-certificates.conf issue nsswitch.conf ssh
calendar issue.net opt ssl
console-setup kernel os-release subgid
cron.d ld.so.cache pam.conf subgid-
cron.daily ld.so.conf pam.d subuid
cron.hourly ld.so.conf.d passwd subuid-
cron.monthly ldap passwd- sudoers
cron.weekly legal perl sudoers.d
crontab libaudit.conf pinforc sysctl.conf
dbus-1 locale.alias ppp sysctl.d
debconf.conf locale.gen profile systemd
debian_version localtime profile.d terminfo
default logcheck protocols timezone
deluser.conf login.defs python3 tmpfiles.d
depmod.d logrotate.conf python3.6 ucf.conf
dhcp logrotate.d rc0.d udev
dpkg lsb-release rc1.d ufw
environment machine-id rc2.d update-motd.d
fstab magic rc3.d updatedb.conf
gai.conf magic.mime rc4.d vim
groff mailcap rc5.d vtrgb
group mailcap.order rc6.d wgetrc
group- manpath.config rcS.d xdg
gshadow mc resolv.conf
gshadow- mime.types rmt

La commande précédente liste un grand nombre de fichiers. Si vous l'exécutez dans notre
terminal, la sortie est coupée et ne peut être visualisée qu'en la faisant défiler vers le haut.
Pour visualiser plus facilement le début de la sortie, il faut la diriger vers la commande head.
L'exemple suivant affiche uniquement les dix premières lignes :

sysadmin@localhost:~$ ls /etc | head

X11
adduser.conf
alternatives
apparmor
apparmor.d
apt
bash.bashrc
bind
bindresvport.blacklist
binfmt.d

La sortie complète de la commande ls est transmise à la commande head par le shell au lieu
d'être imprimée à l'écran. La commande head prend cette sortie de la commande ls comme
données d'entrée, et la sortie de head est ensuite imprimée à l'écran.

Plusieurs pipes peuvent être utilisés consécutivement pour lier plusieurs commandes entre
elles. Si trois commandes sont reliées par un pipe, la sortie de la première commande est
transmise à la seconde. Ensuite, la sortie de la deuxième commande est transmise à la
troisième commande. La sortie de la troisième commande est ensuite imprimée à l'écran.

Il est important de choisir soigneusement l'ordre dans lequel les commandes sont
transmises, car chaque commande ne voit que l'entrée de la commande précédente. Les
exemples ci-dessous illustrent ce point en utilisant la commande nl, qui ajoute les numéros
de ligne à la sortie. Dans le premier exemple, la commande nl est utilisée pour numéroter les
lignes de la sortie de la commande ls précédente :

sysadmin@localhost:~$ ls /etc/ssh | nl
1 moduli
2 ssh_config
3 ssh_host_ecdsa_key
4 ssh_host_ecdsa_key.pub
5 ssh_host_ed25519_key
6 ssh_host_ed25519_key.pub
7 ssh_host_rsa_key
8 ssh_host_rsa_key.pub
9 ssh_import_id
10 sshd_config

Dans l'exemple suivant, notez que la commande ls est exécutée en premier et que sa sortie
est envoyée à la commande nl, qui numérote toutes les lignes de la sortie de la commande
ls. Ensuite, la commande tail est exécutée, affichant les cinq dernières lignes de la sortie de
la commande nl :

sysadmin@localhost:~$ ls /etc/ssh | nl | tail -5

6 ssh_host_ed25519_key.pub
7 ssh_host_rsa_key
8 ssh_host_rsa_key.pub
9 ssh_import_id
10 sshd_config

Comparez le résultat ci-dessus avec l'exemple suivant :

Remarquez que les numéros de ligne sont différents. Comment cela se fait-il ?

Dans le deuxième exemple, la sortie de la commande ls est d'abord envoyée à la commande

tail qui ne saisit que les cinq dernières lignes de la sortie. Ensuite, la commande tail envoie
ces cinq lignes à la commande nl, qui les numérote de 1 à 5.
Les pipes peuvent être puissants, mais il est nécessaire de considérer comment les
commandes sont pipées pour s'assurer que la sortie désirée est affichée.

10.3 Redirection des entrées/sorties

La redirection des entrées/sorties (E/S) permet de transmettre des informations de ligne de

commande à différents flux. Avant d'aborder la redirection, il est important de comprendre
les flux standard.

STDIN

L'entrée standard, ou STDIN, est une information saisie normalement par l'utilisateur via le
clavier. Lorsqu'une commande demande des données à l'interpréteur de commandes, ce
dernier offre à l'utilisateur la possibilité de taper des commandes qui, à leur tour, sont
envoyées à la commande en tant que STDIN.

STDOUT

La sortie standard, ou STDOUT, est la sortie normale des commandes. Lorsqu'une

commande fonctionne correctement (sans erreur), la sortie qu'elle produit est appelée
STDOUT. Par défaut, STDOUT s'affiche dans la fenêtre du terminal où la commande
s'exécute. STDOUT est également connu sous le nom de flux ou de canal n°1.

STDERR

L'erreur standard, ou STDERR, est un message d'erreur généré par les commandes. Par
défaut, STDERR est affiché dans la fenêtre du terminal dans lequel la commande est
exécutée. STDERR est également connu sous le nom de flux ou canal n°2.

La redirection d'E/S permet à l'utilisateur de rediriger STDIN pour que les données
proviennent d'un fichier et STDOUT/STDERR pour que la sortie aille vers un fichier. La
redirection est réalisée à l'aide des caractères fléchés < >.

10.3.1 STDOUT

STDOUT peut être dirigé vers des fichiers. Pour commencer, observez la sortie de la
commande echo suivante qui s'affiche à l'écran :

sysadmin@localhost:~$ echo "Line 1"

Line 1

En utilisant le caractère >, la sortie peut être redirigée vers un fichier à la place :

sysadmin@localhost:~$ echo "Line 1" > example.txt

Cette commande n'affiche aucune sortie car la sortie STDOUT a été envoyée vers le fichier
example.txt au lieu de l'écran. Vous pouvez voir le nouveau fichier avec la sortie de la
commande ls.

sysadmin@localhost:~$ ls
Desktop Downloads Pictures Templates example.txt
Documents Music Public Videos

Le fichier contient la sortie de la commande echo, qui peut être visualisée avec la commande
cat :

sysadmin@localhost:~$ cat example.txt

Line 1

Il est important de comprendre que la flèche unique écrase tout le contenu d'un fichier
existant :

sysadmin@localhost:~$ cat example.txt

Line 1
sysadmin@localhost:~$ echo "New line 1" > example.txt
sysadmin@localhost:~$ cat example.txt
New line 1

Le contenu original du fichier a disparu, remplacé par la sortie de la nouvelle commande

echo.

Il est également possible de préserver le contenu d'un fichier existant en l'annexant. Utilisez
les deux flèches >> pour ajouter un fichier au lieu de l'écraser :

sysadmin@localhost:~$ cat example.txt

New line 1
sysadmin@localhost:~$ echo "Another line" >> example.txt
sysadmin@localhost:~$ cat example.txt
New line 1
Another line

Au lieu d'être écrasée, la sortie de la commande echo est ajoutée au bas du fichier.
 10.3.2 STDERR

STDERR peut être redirigé de la même manière que STDOUT. Lorsque l'on utilise le caractère
flèche pour rediriger, le flux n°1 (STDOUT) est supposé, sauf si un autre flux est spécifié.
Ainsi, le flux n°2 doit être spécifié lors de la redirection de STDERR en plaçant le nombre 2
avant le caractère flèche >.

Pour démontrer la redirection de STDERR, observez d'abord la commande suivante qui

produit une erreur car le répertoire spécifié n'existe pas :

sysadmin@localhost:~$ ls /fake
ls: cannot access /fake: No such file or directory

Notez qu'il n'y a rien dans l'exemple ci-dessus qui implique que la sortie est STDERR. La
sortie est clairement un message d'erreur, mais comment pouvez-vous savoir qu'elle est
envoyée à STDERR ? Une façon simple de le déterminer est de rediriger STDOUT :

sysadmin@localhost:~$ ls /fake > output.txt

ls: cannot access /fake: No such file or directory

Dans l'exemple ci-dessus, STDOUT a été redirigé vers le fichier output.txt. Ainsi, la sortie qui
est affichée ne peut pas être STDOUT car elle aurait été placée dans le fichier output.txt au
lieu du terminal. Puisque toutes les sorties de commandes vont soit vers STDOUT soit vers
STDERR, la sortie affichée ci-dessus doit être STDERR.

La sortie STDERR d'une commande peut être envoyée dans un fichier :

sysadmin@localhost:~$ ls /fake 2> error.txt

Dans l'exemple, le 2> indique que tous les messages d'erreur doivent être envoyés dans le
fichier error.txt, ce qui peut être confirmé à l'aide de la commande cat :

sysadmin@localhost:~$ cat error.txt

ls: cannot access /fake: No such file or directory

10.3.3. Rediriger des flux multiples

Il est possible de diriger à la fois le STDOUT et le STDERR d'une commande en même temps.
La commande suivante produit à la fois STDOUT et STDERR car l'un des répertoires spécifiés
existe et l'autre non :

sysadmin@localhost:~$ ls /fake /etc/ppp

ls: cannot access /fake: No such file or directory
/etc/ppp:
ip-down.d ip-up.d

Si seul le STDOUT est envoyé dans un fichier, le STDERR est toujours imprimé à l'écran :

sysadmin@localhost:~$ ls /fake /etc/ppp > example.txt

ls: cannot access /fake: No such file or directory
sysadmin@localhost:~$ cat example.txt
/etc/ppp:
ip-down.d
ip-up.d

Si seul le STDERR est envoyé dans un fichier, le STDOUT est toujours imprimé à l'écran :

sysadmin@localhost:~$ ls /fake /etc/ppp 2> error.txt

/etc/ppp:
ip-down.d
ip-up.d
sysadmin@localhost:~$ cat error.txt
ls: cannot access /fake: No such file or directory

STDOUT et STDERR peuvent tous deux être envoyés dans un fichier en utilisant le caractère
esperluette & devant le caractère flèche >. Le jeu de caractères &> signifie à la fois 1> et 2> :

sysadmin@localhost:~$ ls /fake /etc/ppp &> all.txt

sysadmin@localhost:~$ cat all.txt
ls: cannot access /fake: No such file or directory
/etc/ppp:
ip-down.d
ip-up.d

Notez que lorsque vous utilisez &>, la sortie apparaît dans le fichier avec tous les messages
STDERR en haut et tous les messages STDOUT en dessous de tous les messages STDERR :
sysadmin@localhost:~$ ls /fake /etc/ppp /junk /etc/sound &> all.txt
sysadmin@localhost:~$ cat all.txt
ls: cannot access '/fake': No such file or directory
ls: cannot access '/junk': No such file or directory
ls: cannot access '/etc/sound': No such file or directory
/etc/ppp:
ip-down.d
ip-up.d

Si vous ne voulez pas que STDERR et STDOUT aillent tous deux dans le même fichier, ils
peuvent être redirigés vers des fichiers différents en utilisant à la fois > et 2>. Par exemple,
pour diriger STDOUT vers example.txt et STDERR vers error.txt, exécutez ce qui suit :

sysadmin@localhost:~$ ls /fake /etc/ppp > example.txt 2> error.txt

sysadmin@localhost:~$ cat error.txt
ls: cannot access /fake: No such file or directory
sysadmin@localhost:~$ cat example.txt
/etc/ppp:
ip-down.d
ip-up.d

L'ordre dans lequel les flux sont spécifiés n'a pas d'importance.

10.3.4. STDIN

Le concept de redirection de STDIN est difficile car il est plus difficile de comprendre
pourquoi vous voudriez rediriger STDIN. En ce qui concerne STDOUT et STDERR, leur objectif
est simple : il est parfois utile de stocker la sortie dans un fichier pour une utilisation
ultérieure.

La plupart des utilisateurs de Linux finissent par rediriger STDOUT de manière routinière,
STDERR à l'occasion, et STDIN très rarement.

Il y a très peu de commandes qui nécessitent de rediriger STDIN car avec la plupart des
commandes, si vous voulez lire des données d'un fichier dans une commande, vous pouvez
spécifier le nom du fichier comme argument de la commande.

Pour certaines commandes, si vous ne spécifiez pas de nom de fichier en argument, elles
reviennent à l'utilisation de STDIN pour obtenir des données. Par exemple, considérez la
commande cat suivante :

sysadmin@localhost:~$ cat
hello

hello⁠⁠ 
how are you?
how are you?
goodbye
goodbye

Note

Si vous tentez d'exécuter la commande cat sans arguments, arrêtez le processus et revenez à
l'invite en utilisant Ctrl+C.

Dans l'exemple précédent, la commande cat ne reçoit pas de nom de fichier en argument.
Elle demande donc les données à afficher à l'écran à partir de STDIN. L'utilisateur tape hello,
et la commande cat affiche hello à l'écran. Bien que cela soit légèrement divertissant, ce
n'est pas particulièrement utile.

Cependant, si la sortie de la commande cat était redirigée vers un fichier, cette méthode
pourrait être utilisée soit pour ajouter du texte à un fichier existant, soit pour placer du texte
dans un nouveau fichier.

La première commande de l'exemple ci-dessous redirige la sortie de la commande cat vers

un fichier nouvellement créé appelé new.txt. Cette action est suivie de la fourniture à la
commande cat du fichier new.txt comme argument pour afficher le texte redirigé dans
STDOUT.

sysadmin@localhost:~$ cat > new.txt

Hello
How are you?
Goodbye
sysadmin@localhost:~$ cat new.txt
Hello
How are you?
Goodbye

Alors que l'exemple précédent démontre un autre avantage de la redirection de STDOUT, il

n'aborde pas pourquoi ou comment STDIN peut être dirigé. Pour comprendre cela,
considérez une nouvelle commande appelée tr. Cette commande prend un ensemble de
caractères et les traduit en un autre ensemble de caractères.

Par exemple, pour mettre en majuscule une ligne de texte, utilisez la commande tr comme
suit :
sysadmin@localhost:~$ tr 'a-z' 'A-Z'
watch how this works
WATCH HOW THIS WORKS

La commande tr prend le STDIN du clavier et convertit toutes les lettres en minuscules avant
d'envoyer le STDOUT à l'écran.

Il semblerait qu'une meilleure utilisation de la commande tr serait d'effectuer la traduction

sur un fichier, et non sur une entrée clavier. Cependant, la commande tr ne prend pas en
charge les arguments de nom de fichier :

sysadmin@localhost:~$ cat example.txt

/etc/ppp:
ip-down.d
ip-up.d
sysadmin@localhost:~$ tr 'a-z' 'A-Z' example.txt
tr: extra operand `example.txt'
Try `tr --help' for more information

Il est toutefois possible d'indiquer à l'interpréteur de commandes de récupérer STDIN à

partir d'un fichier plutôt que du clavier en utilisant le caractère < :

sysadmin@localhost:~$ tr 'a-z' 'A-Z' < example.txt

/ETC/PPP:
IP-DOWN.D
IP-UP.D

La plupart des commandes acceptent les noms de fichiers comme arguments, ce cas
d'utilisation est donc relativement rare. Cependant, pour celles qui ne le font pas, cette
méthode peut être utilisée pour que l'interpréteur de commandes lise le fichier au lieu de
compter sur la commande pour avoir cette capacité.

Une dernière remarque pour sauvegarder la sortie résultante, redirigez-la dans un autre
fichier :

sysadmin@localhost:~$ tr 'a-z' 'A-Z' < example.txt > newexample.txt

sysadmin@localhost:~$ cat newexample.txt
/ETC/PPP:
IP-DOWN.D
IP-UP.D

10.4 Tri des fichiers ou des entrées

La commande sort peut être utilisée pour réorganiser les lignes des fichiers ou des entrées
dans l'ordre du dictionnaire ou numérique. L'exemple suivant crée un petit fichier, en
utilisant la commande head pour récupérer les 5 premières lignes du fichier /etc/passwd et
envoyer la sortie dans un fichier appelé mypasswd.

sysadmin@localhost:~$ head -5 /etc/passwd > mypasswd

sysadmin@localhost:~$ cat mypasswd
root:x:0:0:root:/root:/bin/bash
daemon:x:1:1:daemon:/usr/sbin:/usr/sbin/nologin
bin:x:2:2:bin:/bin:/usr/sbin/nologin
sys:x:3:3:sys:/dev:/usr/sbin/nologin
sync:x:4:65534:sync:/bin:/bin/sync

Maintenant nous allons trier le fichier mypasswd :

sysadmin@localhost:~$ sort mypasswd

bin:x:2:2:bin:/bin:/usr/sbin/nologin
daemon:x:1:1:daemon:/usr/sbin:/usr/sbin/nologin
root:x:0:0:root:/root:/bin/bash
sync:x:4:65534:sync:/bin:/bin/sync
sys:x:3:3:sys:/dev:/usr/sbin/nologin

En examinant de près la sortie de l'exemple précédent, la commande sort a classé les lignes
du fichier par ordre alphabétique. Comparez cette sortie à celle de la commande cat
précédente.

10.4.1 Champs et options de tri

La commande de tri peut réorganiser la sortie en fonction du contenu d'un ou plusieurs

champs. Les champs sont déterminés par un délimiteur de champ contenu sur chaque ligne.
En informatique, un délimiteur est un caractère qui sépare une chaîne de texte ou de
données ; par défaut, il s'agit d'un espace, comme les espaces ou les tabulations.

La commande suivante peut être utilisée pour trier numériquement le troisième champ du
fichier mypasswd. Trois options sont utilisées pour réaliser ce tri :
Option Function

-t: The -t option specifies the field delimiter. If the file or input is separated by a
delimiter other than whitespace, for example a comma or colon, the -t option will
allow for another field separator to be specified as an argument.
The mypasswd file used in the previous example uses a colon : character as a
delimiter to separate the fields, so the following example uses the -t: option.

-k3 The -k option specifies the field number. To specify which field to sort by, use the -
k option with an argument to indicate the field number, starting with 1 for the first
field.
The following example uses the -k3 option to sort by the third field.

-n This option specifies the sort type.

The third field in the mypasswd file contains numbers, so the -n option is used to
perform a numeric sort.

sysadmin@localhost:~$ sort -t: -n -k3 mypasswd

root:x:0:0:root:/root:/bin/bash
daemon:x:1:1:daemon:/usr/sbin:/usr/sbin/nologin
bin:x:2:2:bin:/bin:/usr/sbin/nologin
sys:x:3:3:sys:/dev:/usr/sbin/nologin
sync:x:4:65534:sync:/bin:/bin/sync

Une autre option couramment utilisée pour la commande sort est l'option -r, qui permet
d'effectuer un tri inverse. L'exemple suivant montre la même commande que l'exemple
précédent, avec l'ajout de l'option -r, ce qui fait que les nombres les plus élevés dans le
troisième champ apparaissent en haut de la sortie :

sysadmin@localhost:~$ sort -t: -n -r -k3 mypasswd

sync:x:4:65534:sync:/bin:/bin/sync
sys:x:3:3:sys:/dev:/usr/sbin/nologin
bin:x:2:2:bin:/bin:/usr/sbin/nologin
daemon:x:1:1:daemon:/usr/sbin:/usr/sbin/nologin
root:x:0:0:root:/root:/bin/bash

Enfin, vous pouvez souhaiter effectuer des tris plus complexes, comme le tri par un champ
primaire, puis par un champ secondaire. Par exemple, considérez le fichier de valeurs
séparées par des virgules suivant, un fichier où le caractère virgule est le délimiteur de
champ :

Follow Along
Use the following command to switch to the Documents directory:
sysadmin@localhost:~$ cd ~/Documents

sysadmin@localhost:~/Documents$ cat os.csv

1970,Unix,Richie
1987,Minix,Tanenbaum
1970,Unix,Thompson
1991,Linux,Torvalds

Pour trier d'abord par le système d'exploitation (champ n° 2) puis par l'année (champ n° 1) et
ensuite par le nom de famille (champ n° 3), utilisez la commande suivante :

sysadmin@localhost:~/Documents$ sort -t, -k2 -k1n -k3 os.csv

1991,Linux,Torvalds
1987,Minix,Tanenbaum
1970,Unix,Richie
1970,Unix,Thompson

The following table breaks down the options used in the previous example:

Option Function

-t, Specifies the comma character as the field delimiter

-k2 Sort by field #2

-k1n Numerically sort by field #1

-k3 Sort by field #3

Use the following command to return to the home directory:

sysadmin@localhost:~/Documents$ cd
sysadmin@localhost:~$
10.5 Visualisation des statistiques de fichiers

La commande wc fournit le nombre de lignes, de mots et d'octets (1 octet = 1 caractère dans

un fichier texte) pour un fichier, ainsi que le nombre total de lignes si plus d'un fichier est
spécifié. Par défaut, la commande wc permet d'imprimer jusqu'à trois statistiques pour
chaque fichier fourni, ainsi que le total de ces statistiques si plus d'un nom de fichier est
fourni :

sysadmin@localhost:~$ wc /etc/passwd /etc/passwd-

35 56 1710 /etc/passwd
34 55 1665 /etc/passwd-
69 111 3375 total

La sortie de l'exemple précédent comporte quatre colonnes :

1. Nombre de lignes
2. Nombre de mots
3. Nombre d'octets
4. Nom du fichier

Il est également possible de ne visualiser que des statistiques spécifiques, en utilisant

l'option -l pour afficher uniquement le nombre de lignes, l'option -w pour afficher
uniquement le nombre de mots, l'option -c pour afficher uniquement le nombre d'octets, ou
toute combinaison de ces options.

La commande wc peut être utile pour compter le nombre de lignes produites par une autre
commande via un pipe. Par exemple, si vous voulez connaître le nombre total de fichiers
dans le répertoire /etc, envoyez la sortie de ls à wc et comptez seulement le nombre de
lignes :

sysadmin@localhost:~$ ls /etc/ | wc -l
142

10.6 Filtrer les sections de fichiers

La commande cut permet d'extraire des colonnes de texte d'un fichier ou de l'entrée
standard. Elle est principalement utilisée pour travailler avec des fichiers de base de données
délimités. Encore une fois, les fichiers délimités sont des fichiers qui contiennent des
colonnes séparées par un délimiteur. Ces fichiers sont très courants sur les systèmes Linux.

Par défaut, la commande cut s'attend à ce que son entrée soit séparée par le caractère
tabulation, mais l'option -d permet de spécifier d'autres délimiteurs tels que les deux points
ou la virgule.
L'option -f permet de spécifier les champs à afficher, soit sous la forme d'une plage de traits
d'union, soit sous la forme d'une liste séparée par des virgules.

Dans l'exemple suivant, les premier, cinquième, sixième et septième champs du fichier de
base de données mypasswd sont affichés :

sysadmin@localhost:~$ cut -d: -f1,5-7 mypasswd

root:root:/root:/bin/bash
daemon:daemon:/usr/sbin:/usr/sbin/nologin
bin:bin:/bin:/usr/sbin/nologin
sys:sys:/dev:/usr/sbin/nologin
sync:sync:/bin:/bin/sync

La commande cut est également capable d'extraire des colonnes de texte en fonction de la
position des caractères avec l'option -c - utile lorsque vous travaillez avec des fichiers de
base de données à largeur fixe ou des sorties de commande.

Par exemple, les champs de la commande ls -l sont toujours dans les mêmes positions de
caractères. La commande suivante affichera uniquement le type de fichier (caractère 1), les
autorisations (caractères 2-10), un espace (caractère 11) et le nom du fichier (caractères
50+) :

sysadmin@localhost:~$ ls -l | cut -c1-11,50-

total 44
drwxr-xr-x Desktop
drwxr-xr-x Documents
drwxr-xr-x Downloads
drwxr-xr-x Music
drwxr-xr-x Pictures
drwxr-xr-x Public
drwxr-xr-x Templates
drwxr-xr-x Videos
-rw-rw-r-- all.txt
-rw-rw-r-- example.txt
-rw-rw-r-- mypasswd
-rw-rw-r-- new.txt

10.7 Filtrer le contenu des fichiers

La commande grep peut être utilisée pour filtrer les lignes d'un fichier ou la sortie d'une
autre commande qui correspond à un modèle spécifié. Ce modèle peut être aussi simple que
le texte exact que vous voulez faire correspondre ou peut être beaucoup plus avancé grâce à
l'utilisation d'expressions régulières.

Par exemple, pour trouver tous les utilisateurs qui peuvent se connecter au système avec
l'interpréteur de commandes BASH, la commande grep peut être utilisée pour filtrer les
lignes du fichier /etc/passwd pour les lignes contenant le motif bash :

sysadmin@localhost:~$ grep bash /etc/passwd

root:x:0:0:root:/root:/bin/bash
sysadmin:x:1001:1001:System Administrator,,,,:/home/sysadmin:/bin/bash

Pour faciliter la visualisation de ce qui correspond exactement, utilisez l'option --color. Cette
option met en évidence les éléments correspondants en rouge :

sysadmin@localhost:~$ grep --color bash /etc/passwd

root:x:0:0:root:/root:/bin/bash
sysadmin:x:1001:1001:System Administrator,,,,:/home/sysadmin:/bin/bash

Note

Sur nos machines virtuelles, la commande grep est aliasée pour inclure automatiquement
l'option --color.

Dans certains cas, il n'est pas important de trouver les lignes spécifiques qui correspondent
au motif, mais plutôt le nombre de lignes correspondant au motif. L'option -c fournit un
compte du nombre de lignes correspondant :

sysadmin@localhost:~$ grep -c bash /etc/passwd

2

Lorsque vous visualisez la sortie de la commande grep, il peut être difficile de déterminer les
numéros de ligne d'origine. Cette information peut être utile lorsqu'on retourne dans le
fichier (peut-être pour l'éditer) pour trouver rapidement une des lignes correspondantes.

L'option -n de la commande grep permet d'afficher les numéros de ligne originaux. Pour
afficher toutes les lignes et leurs numéros de ligne dans le fichier /etc/passwd qui
contiennent le motif bash :

sysadmin@localhost:~$ grep -n bash /etc/passwd

1:root:x:0:0:root:/root:/bin/bash
27:sysadmin:x:1001:1001:System Administrator,,,,:/home/sysadmin:/bin/bash

L'option -v inverse la correspondance, en affichant toutes les lignes qui ne contiennent pas le
motif. Pour afficher toutes les lignes ne contenant pas nologin dans le fichier /etc/passwd :

sysadmin@localhost:~$ grep -v nologin /etc/passwd

root:x:0:0:root:/root:/bin/bash
sync:x:4:65534:sync:/bin:/bin/sync
operator:x:1000:37::/root:/bin/sh
sysadmin:x:1001:1001:System Administrator,,,,:/home/sysadmin:/bin/bash

L'option -i ignore les distinctions de casse (capitalisation). L'exemple suivant recherche le

motif the dans newhome.txt, en permettant à chaque caractère d'être en majuscule ou en
minuscule :

sysadmin@localhost:~$ cd Documents
sysadmin@localhost:~/Documents$ grep -i the newhome.txt
There are three bathrooms.
**Beware** of the ghost in the bedroom.
The kitchen is open for entertaining.
**Caution** the spirits don't like guests.

L'option -w ne renvoie que les lignes contenant des correspondances qui forment des mots
entiers. Pour être un mot, la chaîne de caractères doit être précédée et suivie d'un caractère
non-mot. Les caractères de mot comprennent les lettres, les chiffres et le caractère de
soulignement.

Les exemples suivants recherchent le motif are dans le fichier newhome.txt. La première
commande effectue une recherche sans option, tandis que la deuxième commande inclut
l'option -w. Comparez les résultats :

sysadmin@localhost:~/Documents$ grep are newhome.txt

There are three bathrooms.
**Beware** of the ghost in the bedroom.
sysadmin@localhost:~/Documents$ grep -w are newhome.txt
There are three bathrooms.

10.8 Expressions régulières de base

Les expressions régulières, également appelées regex, sont un ensemble de caractères
normaux et spéciaux qui sont utilisés pour trouver des motifs simples ou complexes,
respectivement, dans les fichiers. Ces caractères sont des caractères utilisés pour exécuter
une fonction de correspondance particulière dans une recherche.

Les caractères normaux sont des caractères alphanumériques qui se correspondent eux-
mêmes. Par exemple, un a correspond à un a. Les caractères spéciaux ont des significations
particulières lorsqu'ils sont utilisés dans des motifs par des commandes comme la
commande grep. Ils se comportent d'une manière plus complexe et ne correspondent pas à
eux-mêmes.

Il existe des expressions régulières de base (disponibles pour une grande variété de
commandes Linux) et des expressions régulières étendues (disponibles pour les commandes
Linux plus avancées). Les expressions régulières de base comprennent les éléments suivants
:

Character Matches

. Any single character

[ ] A list or range of characters to match one character

If the first character within the brackets is the caret ^, it means any
character not in the list

* The previous character repeated zero or more times

^ If the first character in the pattern, the pattern must be at the beginning of the
line to match, otherwise just a literal ^ character

$ If the last character in the pattern, the pattern must be at the end of the line to
match, otherwise just a literal $ character
La commande grep n'est qu'une des nombreuses commandes qui prennent en charge les
expressions régulières. Parmi les autres commandes, citons les commandes more et less.

Bien que certaines des expressions régulières soient inutilement encadrées par des
guillemets simples, il est bon d'utiliser des guillemets simples autour des expressions
régulières pour éviter que l'interpréteur de commandes n'essaie d'en interpréter une
signification particulière.

10.8.1 La période . Character

L'une des expressions les plus utiles est le caractère point . Il correspond à n'importe quel
caractère, à l'exception du caractère de nouvelle ligne. Considérons le contenu non filtré du
fichier ~/Documents/red.txt :

sysadmin@localhost:~/Documents$ cat red.txt

red
reef
rot
reeed
rd
rod
roof
reed
root
reel
read

Le motif r..f trouverait toute ligne contenant la lettre r suivie d'exactement deux caractères
et ensuite la lettre f :

sysadmin@localhost:~/Documents$ grep 'r..f' red.txt

reef
roof

La ligne ne doit pas nécessairement être une correspondance exacte, elle doit simplement
contenir le motif, comme on le voit ici lorsque r..t est recherché dans le fichier /etc/passwd :

sysadmin@localhost:~/Documents$ grep 'r..t' /etc/passwd

root:x:0:0:root:/root:/bin/bash
operator:x:1000:37::/root:

Le caractère point peut être utilisé un nombre illimité de fois. Pour trouver tous les mots qui
ont au moins quatre caractères, on peut utiliser le modèle suivant :
sysadmin@localhost:~/Documents$ grep '....' red.txt
reef
reeed
roof
reed
root
reel
read

10.8.2 Les caractères de parenthèse [ ].

Lorsque vous utilisez le caractère ., n'importe quel caractère peut correspondre à celui-ci.
Dans certains cas, vous voulez spécifier exactement les caractères que vous voulez faire
correspondre, comme un caractère alphabétique minuscule ou un caractère numérique.

Les crochets [ ] correspondent à un seul caractère de la liste ou de la plage de caractères

possibles contenus dans les crochets. Par exemple, étant donné le fichier profile.txt :

sysadmin@localhost:~/Documents$ cat profile.txt

Hello my name is Joe.
I am 37 years old.
3121991
My favorite food is avocados.
I have 2 dogs.
123456789101112

Pour trouver toutes les lignes du fichier profile.txt contenant un numéro, utilisez le modèle
[0123456789] ou [0-9] :

sysadmin@localhost:~/Documents$ grep '[0-9]' profile.txt

I am 37 years old.
3121991
I have 2 dogs.
123456789101112

Notez que chaque caractère possible peut être énuméré [abcd] ou fourni sous la forme
d'une plage [a-d], à condition que la plage soit dans l'ordre correct. Par exemple, [d-a] ne
fonctionnerait pas car il ne s'agit pas d'une plage valide :
sysadmin@localhost:~/Documents$ grep '[d-a]' profile.txt
grep: Invalid range end

La plage est spécifiée par une norme appelée table ASCII. Cette table est une collection de
tous les caractères imprimables dans un ordre spécifique. Vous pouvez voir la table ASCII
avec la commande ascii. Un petit échantillon :

041 33 21 ! 141 97 61 a
042 34 22 “ 142 98 62 b
043 35 23 # 143 99 63 c
044 36 24 $ 144 100 64 d
045 37 25 % 145 101 65 e
046 38 26 & 146 102 66 f

La valeur ASCII de la lettre a est 97 tandis que la valeur de d est 100. Comme 97 est plus petit
que 100, l'intervalle a-d (97-100) est un intervalle valide.

Qu'en est-il de l'exemption de caractères ? Par exemple, pour faire correspondre un

caractère qui peut être tout sauf un x, un y ou un z ? Il serait inefficace de fournir un
ensemble avec tous les caractères sauf x, y ou z.

Pour faire correspondre un caractère qui n'est pas l'un des caractères listés, commencez le
jeu par le symbole ^. Pour trouver toutes les lignes qui contiennent des caractères non
numériques, insérez un ^ comme premier caractère à l'intérieur des parenthèses. Ce
caractère annule les caractères énumérés :

sysadmin@localhost:~/Documents$ grep '[^0-9]' profile.txt

Hello my name is Joe.
I am 37 years old.
My favorite food is avocados.
I have 2 dogs.

Considérez ceci

Ne confondez pas [^0-9] avec les lignes qui ne contiennent pas de chiffres. Il correspond en
fait à des lignes qui ne contiennent pas de nombres. Regardez le fichier original pour voir la
différence. Les troisième et sixième lignes ne contiennent que des chiffres ; elles ne
contiennent pas de non-nombres, donc ces lignes ne correspondent pas.
 10.8.3. Le caractère astérisque *.

Le caractère astérisque * est utilisé pour correspondre à zéro ou plusieurs occurrences d'un
caractère ou d'un motif qui le précède. Par exemple, e* correspondrait à zéro ou plusieurs
occurrences de la lettre e :

sysadmin@localhost:~/Documents$ cat red.txt

red
reef
rot
reeed
rd
rod
roof
reed
root
reel
read
sysadmin@localhost:~/Documents$ grep 're*d' red.txt
red
reeed
rd
reed

Il est également possible de faire correspondre zéro ou plusieurs occurrences d'une liste de
caractères en utilisant les crochets. Le motif [oe]* utilisé dans l'exemple suivant correspond
à zéro ou plusieurs occurrences du caractère o ou du caractère e :

sysadmin@localhost:~/Documents$ grep 'r[oe]*d' red.txt

red
reeed
rd
rod
reed

Lorsqu'il est utilisé avec un seul autre caractère, * n'est pas très utile. L'un des motifs
suivants correspondrait à chaque chaîne ou ligne du fichier : '.*' 'e*' 'b*' 'z*' parce que le
caractère astérisque * peut correspondre à zéro occurrence d'un motif.
sysadmin@localhost:~/Documents$ grep 'z*' red.txt
red
reef
rot
reeed
rd
rod
roof
reed
root
reel
read

sysadmin@localhost:~/Documents$ grep 'e*' red.txt

red
reef
rot
reeed
rd
rod
roof
reed
root
reel
read

Pour rendre le caractère astérisque utile, il est nécessaire de créer un motif qui inclut plus
que le seul caractère qui le précède. Par exemple, les résultats ci-dessus peuvent être affinés
en ajoutant un autre e pour que le motif ee* corresponde effectivement à chaque ligne
contenant au moins un e.

sysadmin@localhost:~/Documents$ grep 'ee*' red.txt

red
reef
reeed
reed
reel
read

10.8.4 Caractères d'ancrage

Lors de l'exécution d'une correspondance de motif, la correspondance peut se produire

n'importe où sur la ligne. Les caractères d'ancrage sont l'une des façons d'utiliser les
expressions régulières pour restreindre les résultats de la recherche. Ils indiquent si la
correspondance se produit au début ou à la fin de la ligne.

Par exemple, le motif root apparaît de nombreuses fois dans le fichier /etc/passwd :

sysadmin@localhost:~/Documents$ grep 'root' /etc/passwd

root:x:0:0:root:/root:/bin/bash
operator:x:1000:37::/root:

Le caractère ^ (accent circonflexe) est utilisé pour s'assurer qu'un motif apparaît en début de
ligne. Par exemple, pour trouver toutes les lignes de /etc/passwd qui commencent par root,
utilisez le motif ^root. Notez que ^ doit être le premier caractère du motif pour être efficace
:

sysadmin@localhost:~/Documents$ grep '^root' /etc/passwd

root:x:0:0:root:/root:/bin/bash

Le deuxième caractère d'ancrage $ peut être utilisé pour s'assurer qu'un motif apparaît à la
fin de la ligne, ce qui réduit efficacement les résultats de la recherche. Pour trouver les lignes
qui se terminent par un r dans le fichier alpha-first.txt, utilisez le motif r$ :

sysadmin@localhost:~/Documents$ cat alpha-first.txt

A is for Animal
B is for Bear
C is for Cat
D is for Dog
E is for Elephant
F is for Flower
sysadmin@localhost:~/Documents$ grep 'r$' alpha-first.txt
B is for Bear
F is for Flower
 10.8.5 Caractère de barre oblique inverse

Dans certains cas, vous pouvez vouloir faire correspondre un caractère qui se trouve être un
caractère spécial d'expression régulière. Par exemple, considérez l'exemple suivant :

Là encore, la position de ce caractère est importante. Le $ doit être le dernier caractère du

motif pour être efficace en tant qu'ancre.

sysadmin@localhost:~/Documents$ cat newhome.txt

Thanks for purchasing your new home!!

**Warning** it may be haunted.

There are three bathrooms.

**Beware** of the ghost in the bedroom.

The kitchen is open for entertaining.

**Caution** the spirits don't like guests.

Good luck!!!
sysadmin@localhost:~/Documents$ grep 're*' newhome.txt
Thanks for purchasing your new home!!
**Warning** it may be haunted.
There are three bathrooms.
**Beware** of the ghost in the bedroom.
The kitchen is open for entertaining.
**Caution** the spirits don't like guests.

Dans le résultat de la commande grep ci-dessus, la recherche de re* correspond à chaque

ligne contenant un r suivi de zéro ou plus de la lettre e. Pour rechercher un caractère
astérisque * réel, placez un caractère backslash \ avant le caractère astérisque * :

sysadmin@localhost:~/Documents$ grep 're\*' newhome.txt

**Beware** of the ghost in the bedroom.
10.8.6 Expressions régulières étendues

L'utilisation d'expressions régulières étendues nécessite souvent qu'une option spéciale soit
fournie à la commande pour les reconnaître. Historiquement, il existe une commande
appelée egrep, qui est similaire à grep, mais qui peut comprendre les expressions régulières
étendues. Maintenant, la commande egrep est dépréciée en faveur de l'utilisation de grep
avec l'option -E.

The following regular expressions are considered extended:

Character Meaning

? Matches previous character zero or one time, so it is an optional character

+ Matches previous character repeated one or more times

| Alternation or like a logical "or" operator

Pour correspondre à colo suivi de zéro ou un caractère u suivi d'un caractère r :

sysadmin@localhost:~/Documents$ grep -E 'colou?r' spelling.txt

American English: Do you consider gray to be a color or a shade?
British English: Do you consider grey to be a colour or a shade?

Pour faire correspondre un ou plusieurs caractères e :

sysadmin@localhost:~/Documents$ grep -E 'e+' red.txt

red
reef
reeed
reed
reel
read

Pour s'accorder avec le gris ou la grisaille :

sysadmin@localhost:~/Documents$ grep -E 'gray|grey' spelling.txt
American English: Do you consider gray to be a color or a shade?
British English: Do you consider grey to be a colour or a shade?