Ce document est une introduction à la pratique et à l'utilisation de l'éditeur de flux "SED", qui essaie de couvrir certaines fonctionnalités assez méconnues, pour ne pas dire "quasi inconnues", qui font de "SED" un outil indispensable dans la boîte à outils de tout Linuxien désireux de se rompre aux maniements et aux arcanes du traitement de fichiers via une console et un shell.
Conventionnellement, Sed utilise comme caractère délimiteur pour son mécanisme de substitution le caractère "/" (slash - barre oblique) :
sed 's/motif/remplacement/' fichier
Dans la plupart des cas, ce choix par défaut est très satisfaisant, mais peut s'avérer vite un vrai casse-tête si le motif ou la chaîne de remplacement contiennent eux aussi un ou des slash(es) comme c'est souvent le cas, par exemple, pour les chemins d'une arborescence (PATH).
Vous pouvez bien évidemment protéger ce(s) slash(es) en les préfixant d'un "\" (backslash - anti-slash - barre oblique inverse), opération très fastidieuse et contraignante s'il en est, si le motif (ou la chaîne de remplacement) en comporte plusieurs et qui plus est, rendant la lisibilité du code assez difficile :
sed 's//home/jp/Docs/CCM/SED//mnt/serveur/docs/' fichier
voire même impossible lorsque le motif (ou la chaîne de remplacement) est une variable devant être interprétée :
var="/home/jp/Documents/CCM/SED/" sed 's/'$var'//mnt/serveur/docs/' fichier
ou (expression entre double quotes)
sed "s/$var//mnt/serveur/docs/" fichier
Fort heureusement, Sed permet de remplacer le délimiteur par défaut par le caractère de son choix (#,|,!,§,etc.) à partir du moment où il ne se trouve pas dans la composition du motif (ou la chaîne de remplacement) :
sed 's#/home/jp/Docs/CCM/SED#/mnt/serveur/docs#' fichier
Ce caractère peut tout aussi bien être une lettre quelconque si cette lettre ne fait pas partie du motif (ou la chaîne de remplacement) :
echo "bonjour" | sed 'sZbZBZ'
Notez que si vous utilisez le caractère "!" (point d'exclamation) comme séparateur, veillez à entourer l'expression par des quotes simples afin de prévenir toute interprétation par le shell du caractère "!" (employé normalement pour gérer l'historique des commandes).
Délimiteur de motif
Comme nous l'avons vu, Sed utilise des motifs, encadrés par le caractère "/" (slash), pour rechercher (mettre en correspondance) certaines lignes d'un document. Le slash utilisé par convention peut cependant être modifié lui aussi au profit d'un autre caractère tout simplement en faisant précéder la 1ère occurrence de ce caractère par un "\" (backslash).
Prenons toujours l'exemple d'un chemin comme critère de recherche. Sous cette forme, avouez que ce n'est pas trop lisible :
sed -n '//home/jp/Docs/CCM/SED/p' fichier
Alors qu'en choisissant commme caractère délimiteur "#" (dièse) par exemple, ça donnerait :
sed -n '#/home/jp/Docs/CCM/SED#p' fichier
Le métacaractère &
Bien souvent le mécanisme de substitution se limite à chercher un motif afin de le substituer à lui-même en lui ajoutant une succincte partie comme, par exemple, rechercher la chaîne "Sed the Stream EDitor" dans un document et vouloir lui ajouter systèmatiquement "Sed the Stream EDitor (Éditeur de flux)".
Nous pourrions écrire alors :
sed 's/Sed the Stream EDitor/Sed the Stream EDitor (Éditeur de flux)/g' fichier
Le métacaractère "&" (esperluette) va nous permettre de remplacer toutes chaînes de caractères mises en correspondance par le motif (ou l'expression régulière) fourni en 1er argument.
Ici la notion de 1er argument n'est pas très explicite et peu loquace, mais elle prendra toute son importante avec les expressions régulières et lors du chapitre suivant sur les "sous-expressions".
Donc notre commande s'écrira plutôt de cette façon :
sed 's/Sed the Stream EDitor/& (Éditeur de flux)/g' fichier
Imaginons que nous ayions à rechercher toutes chaînes numériques (1 ou plusieurs chiffres consécutifs) dans un fichier et que nous voulions faire précéder chacune de ces chaînes par "n° " (notez l'espace après le "°"). La commande ressemblerait à :
sed 's/[0-9][0-9]*/n° &/g' fichier
Il faut impérativement utiliser l'expression "\&" pour obtenir un "&" littéral dans une chaîne de remplacement sous peine de générer des erreurs incompréhensibles parfois.
Les sous-expressions et références arrières
Les sous-expressions
\(...\)
Une sous-expression est une partie d'une expression régulière, encadrée par des parenthèses, que l'on souhaite réutiliser dans la chaîne de remplacement. Les parenthèses doivent être elles-mêmes protégées par des backslashes, à moins que l'option "-r" ait été employée.
Les références arrières
\1 \2 \5
Pour faire référence à chaque bloc mis en correspondance dans la chaîne de remplacement, on le désigne par un numéro correpondant à son ordre d'apparition dans l'expression régulière. Ce numéro doit être également protégé par un backslash. On ne peut faire référence qu'à 9 sous-expressions numérotées de \1 à \9. Ces références sont aussi appelées "références arrières".
Voici quelques exemples avec des noms de villes et leur code postal associé :
Dans cet exemple, la sous-expression "\([0-9]*\)" est mise en correspondance avec toute chaîne exclusivement numérique et est référencée par la référence arrière "\1" :
$ sed 's/([0-9]*).*/\\1/' plop 31000 34000 66000
Cette fois-ci, nous mettons en correspondance 2 sous-expressions, une exclusivement numérique et l'autre comprenant le reste de la ligne sans toutefois englober le caractère de tabulation qui sépare le code postal du nom de la ville. Nous nous servons ensuite des références arrières "\1" (code postal) et "\2" (nom de ville) pour afficher le résultat sous la forme : nom de ville > code postal
Dans ce 3ème et dernier exemple, nous ferons correspondre une sous-expression à chaque partie de la ligne, à savoir le code postal (\1), la tabulation (\2) et le nom de la ville (\3)
$ sed 's/([0-9]*)(t)(.*)/321/' plop Toulouse 31000 Montpellier 34000 Perpignan 66000
Une référence arrière peut faire appel à une sous-expression autant de fois que l'on veut dans la chaîne de remplacement. Reprenant le dernier exemple, en voici la démonstration avec la répétition de la tabulation à divers endroits :
$ sed 's/([0-9]*)(t)(.*)/23221/' plop Toulouse 31000 Montpellier 34000 Perpignan 66000
Expression régulière précédente
Lors de la mise en corrrespondance d'une chaîne avec une expression régulière, Sed met dans sa mémoire tampon ladite chaîne et de ce fait, il est alors possible de se référer à cette chaîne dans la 1ère partie de la commande de substitution "s" (LHS) sans en faire mention littéralement. Autrement dit, une commande du genre 's//chaîne_de_remplacement/' substituera la dernière expression régulière mise en correspondance par Sed par la chaîne_de_remplacement.
Pour illustrer cet état de fait, reprenons notre fichier avec les villes et les codes postaux.
Nous allons chercher la (les) ligne(s) contenant le motif "Montpellier", les autres seront effacées (d) et nous substituerons "Montpellier" par "Béziers" :
$ sed '/Montpellier/!d; s//Béziers/' plop 34000 Béziers
Pour faire le tour de la question concernant les sous-expressions, références arrières et expression régulière précédente, voilà toujours selon l'exemple précédent une autre facette des possibilités offertes par Sed. Si le motif recherché est encadré par des parenthèses, il devient de ce fait une sous-expression qui peut être appelée dans la partie droite de la commande "s" :
$ sed '/(Montpellier)/!d;s//Béziers-1/' plop 34000 Béziers-Montpellier
$ sed '/(Mon)tpellier/!d;s//Béziers-1blanc/' plop 34000 Béziers-Monblanc
La négation
Il peut s'avérer parfois utile d'exclure une ligne matchant un motif (ou intervalle de ligne) avant d'effectuer un traitement. Pour ce faire, Sed a recours au caractère "!" (point d'exclamation), qui, comme dans la plupart des outils issus du monde Unix, évoque la "négation", exactement comme le fait la commande "grep -v".
Il suffit pour cela de faire suivre le motif (ou le numéro de ligne ou encore l'intervalle de ligne) du caractère "!" comme suit :
sed -n '3 !p' fich.txt sed -n '3,8 !p' fich.txt sed -n '/indice/! p' fich3.txt
On rencontre souvent dans les scripts Sed, l'expression "$!" qui peut se traduire par "tant que la dernière ligne n'est pas atteinte" et qui permet d'effectuer une ou plusieurs commande(s) tant que cette condition est vraie.
Il peut être amusant de faire la comparaison entre les différentes façons d'écrire la syntaxe d'une commande pour un résultat identique.
echo -e 'anbnncndnennfng' | sed '/./! d' echo -e 'anbnncndnennfng' | sed '/^$/ d' echo -e 'anbnncndnennfng' | sed -n '/^$/! p' echo -e 'anbnncndnennfng' | sed -n '/./ p'
Le regroupement de commandes
/adresse/{...}
(intervalle d'adresse autorisée)
Les accolades permettent de regrouper certaines commandes à effectuer sur une adresse ou une plage d'adresses. On peut trouver au sein de ces commandes regroupées d'autres sélections d'adresses ainsi que d'autres commandes regroupées, entre accolades elles aussi.
C'est bien là leur principale fonction, cibler une ligne (ou plusieurs) et appliquer successivement une ou plusieurs commande(s) bien spécifique(s). Notons que le traitement agit sur le contenu de la mémoire tampon et non sur la ligne originale et que de ce fait, les changements apportés peuvent conditionnés les critères de sélection ultérieurs.
sed ' /a/{ # seule la ligne contenant "a" s/a/c/g # remplacer tous les "a" par "c" /c/{ # seule la ligne contenant "c" de la ligne matchée s/c/A/g # remplacer tous les "c" par "A" } } ' < <(echo -e "aaanbbbncccnddd")
AAA bbb ccc ddd
$ echo -e "aaanbbbncccnddd" | sed '/a/{s/a/c/g;/c/{s/c/A/g}}'
AAA bbb ccc ddd
Dans un regroupement de commandes (dans un script), chaque commande doit débuter sur sa propre ligne, les accolades et l'ensemble des commandes doivent être sur des lignes séparées. L'accolade ouvrante doit se trouver en fin de ligne, alors que l'accolade fermante doit impérativement se trouver seule sur une ligne. Attention, aucun espace ne doit figurer après les accolades.
Le remplacement de variables
Il peut arriver qu'à l'intérieur d'un script Sed on ait besoin de passer une variable comme paramètre, que ce soit comme motif ou encore dans l'une ou l'autre des parties (LHS ou RHS) lors d'une substitution. Comme je vous en ai parlé précédemment, il faudra faire très attention aux caractères présents dans la variable afin d'adapter les quotes à utiliser.
En effet, Sed, par défaut, utilise des quotes simples pour entourer ses expressions, or ce mécanisme en shell bloque justement l'expansion des variables ; de ce fait, l'emploi de quotes simples empêchera tout bonnement l'interprétation de la variable.
var=A; echo 'azerty' | sed 's/a/$var/' $varzerty
Dans un premier temps, il est tout à fait possible de remplacer ces quotes simples par des quotes doubles, ce qui, dans la plupart des cas, suffira amplement à permettre l'interprétation de la variable comme il se doit.
var=A; echo 'azerty' | sed "s/a/$var/" Azerty
Mais il peut s'avérer judicieux d'employer plutôt cette syntaxe :
var=A; echo 'azerty' | sed 's/a/'"$var"'/' Azerty
Dans ce cas-là, il n'est pas très aisé de comprendre pourquoi il est préférable d'utiliser un mélange de quotes simples et doubles. En fait, le mot "mélange" n'est pas le terme approprié, il aurait été plus juste d'employer le mot "exclure", car, en effet, par cette syntaxe, nous excluons la variable de l'expression, ce qui permet son interprétation par le shell, mais protège au sein de l'expression elle-même l'interprétation d'éventuels caractères propres au shell. Pour mieux comprendre cette nuance, prenons l'exemple suivant :
L'affichage par le shell de 6 lettres de l'alphabet, chacune sur une ligne et dont la lettre "A" est répétée deux fois. Après avoir affecté cette lettre (A) à une variable ($var), nous allons demander à Sed de ne pas afficher les lignes contenant cette variable, donc en employant la synatxe évoquant la négation, autrement dit le point d'exclamation (!).
Tout d'abord, écrivons l'expression avec des quotes simples :
var=A; echo -e "AnBnCnAnDnE" | sed -n '/$var/!p' A B C A D E
Nous constatons que toutes les lettres sont affichées et c'est normal vu que la variable n'a pas été interprétée par le shell à cause des quotes simples.
Maintenant, entourons l'expression avec des quotes doubles :
var=A; echo -e "AnBnCnAnDnE" | sed -n "/$var/!p" -l: !p": event not found
Le shell nous renvoie un message d'erreur ! Effectivement, le "!" est un caractère réservé du shell qui sert notamment pour l'historique des commandes et qui n'a pu être interprété tel quel.
Dissocions donc la variable de l'expression propre à Sed en refermant l'expression juste avant la variable et en la rouvrant juste après à l'aide des quotes simples (notez que les quotes doubles autour de la variable sont facultatives, mais qu'il est préférable de les laisser, parce que c'est une bonne habitude à prendre et pour se prémunir d'éventuelles erreurs dues à des espaces au sein de la variable) :
$ var=A; echo -e "AnBnCnAnDnE" | sed -n '/'"$var"'/!p' B C D E
Les expressions régulières
La connaissance des expressions régulières (regex en abrégé) est un petit plus non négligeable dans la pratique de Sed (et de bien d'autres langages).
Une expression régulière est un motif (pattern en anglais) qui entre en correspondance, de la gauche vers la droite, avec une chaîne de caractères.
Les expressions régulières tirent leur puissance de leurs capacités d'inclure des alternatives et des répétitions dans l'élaboration du modèle constituant le motif. Ces spécificités sont élaborées à l'aide de caractères spéciaux, qui ne sont pas interprétés au sens littéral du terme, mais d'une façon spécifique.
Voici une brève description de la syntaxe des expressions régulières utilisée dans Sed.
caractère (un caractère quelqconque)
Correspondance avec un "caractère" unique
*
Correspond à une séquence de zéro, une ou plusieurs occurrence(s) de l'expression précédente, qui peut être un caractère ordinaire, un caractère spécial protégé par un \, un point (.), un groupe d'expression régulière ou une sous-expression
\+
Identique à *, à part qu'il correspond à une ou plusieurs occurence(s) de l'expression précédente
\?
Identique à *, à part qu'il correspond à zéro ou une occurence de l'expression précédente
\{i\}
Identique à *, à part qu'il correspond à exactement i séquence de l'occurence de l'expression précédente (i représente un entier)
\{i,j\}
Correspond à une séquence inclusive comprise entre i et j
\{i,\}
Correspond à une séquence plus grande ou égale à i
\(regexp\)
Correspond à un ensemble d'expression régulière, appelé aussi sous-expression et pouvant être adressé par référence arrière (back reference)
. un point
N'importe quel caractère, excepté une nouvelle ligne
^
Correspond à une chaîne nulle en début de ligne, autrement dit ce qui se trouve après l'accent circonflexe doit apparaître en début de ligne ou au début d'une sous-expression
$
Idem que ^ mais la correspondance se fait en fin de ligne ou de sous-expression
[liste]
Correspond à n'importe quel caractère de la liste. Une liste peut être constituée d'une séquence comme [a-z] ce qui équivaudra à une mise en correspondance avec n'importe quel caractère compris entre a et z inclus. Pour inclure un ] faites-le figurer en première position dans la liste. Pour inclure un - mettez-le en première ou dernière position dans la liste. Pour inclure un ^ mettez-le après le premier caractère de la liste.
Les caractères $, *, ., [, et \ ne sont pas normalement considérés comme des caractères spéciaux à l'intérieur d'une liste. Ainsi l'expression [\*] correspondra autant au caractère \ qu'au caractère *, le \ n'étant pas vu comme un caractère d'échappement servant à protéger le caractère *.
[^liste]
A l'inverse, un ^ en début de liste, fera correspondre n'importe quel caractère excepté ceux de la liste. Pour inclure un ] faites-le figurer en première position dans la liste juste après le ^.
regexp1\|regexp2
Correspondance avec regexp1 OU regexp2. Le processus de correspondance essaye chaque alternative à son tour, de gauche à droite et la première qui réussit est utilisée. Notez le caractère d'échappement (\) pour protéger le caractère "pipe" (|).
\nombre
Correspond à la énième sous-expression \(...\) utilisée dans l'expression régulière. Les sous-expressions, appelées aussi "références arrières", sont implicitement numérotées de gauche à droite en comptant le nombre d'occurrences de "\(", avec un maximum de 9.
\n
Correspond au caractère nouvelle ligne (LF)
\métacaractère
Correspond à un métacaractère parmi $, *, ., [, \, ou ^, devant être protégé pour un interprétation littérale.
Note :
Attention, les expressions régulières sont très gourmandes. Lors d'une mise en correpondance, celle-ci est effectuée de la gauche vers la droite, et si deux (ou plus) expressions ont le même caractère de départ, la correspondance sera faite sur l'expression la plus longue.
Les caractères d'échappement
\a
alerte (cloche bip) (BEL, Ctrl-G, 0x07)
\b
effacement arrière (BS, Ctrl-H, 0x08)
\f
fin de page (FF, Ctrl-L, 0x0C)
\n
fin de ligne (LF, Ctrl-J, 0x0A)
\r
retour chariot (CR, Ctrl-M, 0x0D)
\t
tabulation horizontale (HT, Ctrl-I, 0x09)
\v
tabulation verticale (VT, Ctrl-K, 0x0B)
\o000
le caractère dont la valeur en octal est 000 (un à trois chiffres) [0-7]
\dDDD
le caractère dont la valeur en décimal est DDD (un à trois chiffres) [0-9]
\xHH
le caractère dont la valeur en hexadécimal est HH [0-9A-F]
Les extras
\'
correspond à une chaîne nulle en début de ligne (identique à ^)
'
correspond à une chaîne nulle en fin de ligne (identique à $)
\b
correspond à une chaîne vide à l'extrémité d'un mot. Limite entre un mot et un caractère autre qu'un mot
\B
correspond à une chaîne vide ne se trouvant pas à une extrémité de mot. Limite entre un caractère autre qu'un mot et un mot
\w
n'importe quel mot de la classe : [A-Za-z0-9_] (underscore _ compris)
\W
n'importe quel mot en dehors de la classe : [^A-Za-z0-9_] (underscore _ compris)
\s
n'importe quel caractère d'espacement : espace, tabulation horizontale ou verticale
\S
un ou plusieurs caractères d'espacement
\<
correspond à une chaîne vide en début de mot
\>
correspond à une chaîne vide en fin de mot
\e
fin de conversion de casse
\l
conversion du prochain caractère en minuscule
\L
conversion des caractères restant en minuscule
\u
conversion du prochain caractère en majuscule
\U
conversion des caractères restant en majuscule
Les classes de caractères
[:alnum:]
caractères alphanumériques [A-Za-z0-9]
[:alpha:]
caractères alphabétiques [A-Za-z]
[:digit:]
chiffres [0-9]
[:lower:]
caractères minuscules [a-z]
[:upper:]
caractères majuscules [A-Z]
[:print:]
caractères imprimables [ -~]
[:punct:]
caractères de ponctuation [!-/:-@[-'{-~]
[:space:]
espaces, tabulations et tout caractère vide [ \t\v\f]
[:blank:]
espace et tabulation [ \x09]
[:graph:]
n'importe quel caractère imprimable [!-~] (excepté les espaces vides)
La version exécutable pour MS Windows 95 / 98 / ME / NT / 2000 et XP
Debuggers
Voilà 2 debuggers qui vous permettront de mieux comprendre le fonctionnement de Sed et, dans quelques cas particuliers, vous économiseront de nombreuses heures à vous arracher les cheveux en essayant de trouver où se situait le grain de sable qui obstruait votre joli filtre devenu tout à coup imperméable...
sedsed est écrit en Python (qui doit donc être installé sur votre système) et vous permet de visualiser l'état des tampons et les commandes interprétées au fur et à mesure.
-f, --file lecture des commandes depuis le fichier désigné -e, --expression permet d'enchaîner plusieurs commandes à la suite -n, --quiet demande implicite de ne pas afficher l'état de la mémoire principale --silent alias pour --quiet
-d, --debug active le mode debugage --hide cache certaines options de débogage (options : PATT,HOLD,COMM) --color active la sortie du débogage colorée (activée par défaut) --nocolor désactive la sortie du débogage colorée --dump-debug listage du débogage à l'écran
-i, --indent indentation du script, une commande par ligne --prefix indentation préfixée par des espaces ou des tabulations (4 espaces par défaut)
-t, --tokenize mode verbeux, affiche chaque commande avec plus d'informations -H, --htmlize convertit un script sed en une jolie page HTML colorée
-V, --version affiche la version du programme et quitte -h, --help affiche une page d'aide et quitte
Signification en sortie : PATT : Affiche le contenu de l'espace de travail (mémoire principale)
HOLD : Affiche le contenu de l'espace annexe (mémoire secondaire)
COMM : La commande SED devant être exécutée
$ Délimite le contenu de PATT et HOLD
La syntaxe la plus courante reste le mode débogage simple (-d) :
Pour certaines tâches dont "awk" et "perl" s'acquittent de façon plus simple et plus rapide, comme par exemple :
Compter des champs et des caractères
Compter des lignes d'un bloc ou des objets d'un fichier
Opérations mathématiques
Calculer la longueur d'une chaîne
Manipuler des données binaires
Boucles sur tableaux ou listes
etc.
Limites connues des différentes versions
Voici quelques limites connues sur les versions distribuées de Sed, dépendantes bien entendu de son matériel, de sa mémoire, de son système d'exploitation et des bibliothèques C utilisées lors de la compilation de Sed.
Longueur maximale d'une ligne
GNU sed : sans limitation
ssed : sans limitation
Taille maximale des mémoires tampons (principale + secondaire)
GNU sed : sans limitation
ssed : sans limitation
Nombre maximal de fichier pouvant être lu par la commande "r"
GNU sed v3+ : sans limitation
ssed : sans limitation
GNU sed v2.05 : le total des lectures (r) et écritures (w) ne doit pas excéder 32
Nombre maximal de fichiers pouvant être écrits par la commande "w"
GNU sed v3+ : sans limitation
ssed : sans limitation
GNU sed v2.05 : le total des lectures (r) et écritures (w) ne doit pas excéder 32
Taille limite d'un nom d'étiquette
GNU sed : sans limitation
ssed : sans limitation
BSD sed : 8 caractères
Taille limite du nom de fichier en écriture
GNU sed : sans limitation
ssed : sans limitation
BSD sed : 8 caractères
Nombre limite de branchements
GNU sed : sans limitation
ssed : sans limitation
Les références
Vous trouverez ci-dessous les ouvrages ainsi que les sites qui m'ont servi à élaborer ce document.
Notez que si vous utilisez le caractère "!" (point d'exclamation) comme séparateur, veillez à entourer l'expression par des quotes simples afin de prévenir toute interprétation par le shell du caractère "!" (employé normalement pour gérer l'historique des commandes).
