sed.txt

       
   SED  
       

sed 'COMMANDE' [FILE]...#Exécute une 'COMMANDE' de manipulation de texte, ligne
                        #par ligne, dans [FILE]...
                        #[FILE]... par défaut est stdin : on peut donc rediriger
                        #son input
sed -e 'COMMANDE' -e
'COMMANDE'... [FILE]...
sed 'COMMANDE;COMMANDE;
COMMANDE...' [FILE]...
sed '                   #Trois syntaxes pour exécuter plusieurs 'COMMANDES' en
    COMMANDE            #même temps pour chaque ligne de [FILE]... La dernière
    COMMANDE...         #est mal adaptée à la console, et est la meilleure dans
'                       #un script bash

sed -f "SCRIPT1"
[FILE]...               #Deux syntaxtes pour exécuter un script .sed sur
"SCRIPT2" [FILE]        #[FILE]... La première contraint à ajouter un shebang

sed 'COMMANDE' <FILE    #Façon plus correcte de cibler [FILE]

'COMMANDE' =
'[RANGE] INSTRUCTION'   #Voici ce que désigne 'COMMANDE'

UTILISER D'ABORD DES    #Pour des opérations de substition simples, les
COMMANDES BASH          #opérateurs bash sont 100 fois plus rapides : ${VAR#...
BUILTINS ==>            #${VAR... ${VAR%... ${VAR%%... ${VAR/... ${VAR//...
                        #${VAR/#... ${VAR/%... ${VAR^... ${VAR^^... ${VAR,...
                        #${VAR,,... le tout entre guillemets bien sûr

                               LES SCRIPTS .SED

#!/bin/sed -f  ==>      #Si la forme "SCRIPT2" [FILE]... est utilisée, il faut
                        #rajouter #!/bin/sed -f en première ligne
                        #!/bin/sed -nf est la seul syntaxe possible pour
                        #mettre l'option -n dans un script

SCRIPTS .SED  =>        #Chaque ligne désigne une COMMANDE, sans simples
                        #guillemets nécessaires
                        #L'ensemble du script est l'ENSEMBLE DES 'COMMANDE' qui
                        #sera exécuté sur [FILE]... (pas besoin d'arguments
                        #positionnels)

#Commentaire            #Commentaire

                               PROCESSUS GENERAL

ENSEMBLE DES 'COMMANDE' #Terminologie : l'ENSEMBLE DES 'COMMANDE' désigne
            ==>         #toutes les commandes lancées par un seul sed. Il
                        #s'agit donc d'une seule 'COMMANDE' (s'il n'y en a
                        #qu'une), ou de plusieurs liées avec -e, ; ou encore \n
                        #dans un SCRIPT)
                        #
PROCESSUS  ==>          #1) Chaque ligne de la concaténation de [FILE]... (=
                        #input) est à tour de role le pattern space de
                        #l'ENSEMBLE DES 'COMMANDE' (sans le newline)
                        #2) Le pattern space est modifié ou non par l'ENSEMBLE
                        #DES 'COMMANDE', qui peuvent aussi créer des outputs.
                        #3) Enfin, le pattern space est renvoyé en output
                        #final, suivi d'une newline (sauf si -n)
                        #4) Le pattern space est ensuite vidé (sauf N), et une
                        #nouvelle ligne entre en input dans le pattern space.
                        #5) Pendant tout le processus, le Hold Buffer peut être
                        #modifié par h, H et x. Il n'est pas réinitialisé à
                        #chaque input. Sa valeur de départ est null.

                                QUOTES et "$VAR"

'COMMANDE'  ==>         #Une 'COMMANDE' doit toujours être quotée avec des
                        #simples guillemets (ou double guillemets si COMMANDE
                        #contient des simples guillemets).
"$VAR"   ==>            #Il est possible d'insérer des $VAR (dont arguments
                        #positionnels) dans 'COMMANDE', mais ceux-ci doivent
                        #etre quotés avec " " et interrompre momentanément les
                        #simples quotes. Exemple : 's/old/'"$VAR"'/g'
                        #Cependant, meme quoté avec " ", une $VAR comprenant
                        #un / \ . * [ ] ^ ou $ fait buguer sed. Il faut donc
                        #ajouter des backslash avant soi-même ou, si la
                        #variable est tapée par l'utilisateur, avec une
                        #commande telle que :
                        #arg=$(echo "$1" | sed 's:[]\[\^\$\.\*\/]:\\\\&:g')

                                    REGEXPS

REGEXPS  ==>            #Les regexps utilisées sont des regexps étendues, et
                        #peuvent être utilisées quasiment partout.

                       SEQUENCES D'ECHAPPEMENT BACKSLASH

SEQUENCES D'ECHAPPEMENT #Dans s///, y///, a, c, i et RANGE, les sequences
BACKSLASH   ==>         #d'escapes avec backslash étendues sont possibles (pas
                        #besoin d'être échappé autrement qu'avec les simples
                        #guillemets de sed ' ')
                        #Null est donc reconnu grâce à \x00.
                        #Exception : \NNN, \b et \e ne sont pas reconnus, mais
                        #il est possible de les inclure en interrompant les
                        #simples guillemets et en faisant $' '
                        #De plus, il est impossible d'inclure \c \n ou leur
                        #valeur octale ou hexadécimale dans la première partie
                        #de s/// et de y/// ou dans un RANGE.
                        #Utiliser P, D et N pour manipuler les newlines

UTILISATION OBLIGATOIRE #L'argument de plusieurs commandes, à savoir :
DE NEWLINES ==>         #  - e COMMANDE
                        #  - r, R, w et W FILE
                        #  - i, c, a TEXTE
                        #ne s'achève pas après un ;. Les seuls moyen d'arrêter
                        #l'argument est de :
                        #  - faire un newline (non trailing newline). En
                        #    console, faire une vraie newline (possible car des
                        #    double guillemets sont ouvertes).
                        #  - ou fermer les guillemets, et refaire une nouvelle
                        #    commande via un nouveau -e

                                    OPTIONS

-n                      #Désactive l'output automatique du pattern space à la
--quiet                 #fin de chaque ENSEMBLE DES 'COMMANDE'
--silent                #Cependant, les INSTRUCTIONS qui output le pattern space
                        #ou autre chose (un FILE ou une substitution de
                        #commandes)manuellement, lorsqu'elles sont exécutées
                        #par un input, renvoie bien un output. Cela concerne :
                        #s///p s///w
                        #e
                        #p P l
                        #a i c
                        #r R
                        #w W
                        #=
                        #L'intérêt avec la plupart d'entre elles, est de ne
                        #renvoyer donc un output que lorsque l'INSTRUCTION est
                        #exécutée.
                        #Exemple de grep-like : sed -n '/PATTERN/ p'

-e COMM -e COMM...
--expression=COMM
--expression=COMM ...   #Envoie plusieurs commandes au même sed

-f "SCRIPT1"
--file="SCRIPT1"        #Utilise le script .sed comme ENSEMBLE DES 'COMMANDE'

-i[PREFIX]              #Plutôt que de renvoyer le résultat de sed, modifie le
--in-place[=PREFIX]     #fichier. Cela permet également de modifier le script
                        #lançant sed lui-même. Si [PREFIX], crée un backup
                        #utilisant ce [PREFIX]

-s                      #Si plusieurs [FILE]... ne concatène pas [FILE]... mais
--separate              #les traite séparément un par un. Cela lance donc un sed
                        #pour chaque fichier. Concrètement les différences
                        #sont :
                        #  - le numéro de ligne s'initialise à chaque fichier
                        #  - le hold buffer s'initialise à chaque fichier
                        #  - N ne franchit pas la frontière entre deux fichiers

-l [NOMBRE]
--line-length[=NOMBRE]  #dimension par défaut du wrap avec la commande l

-r
--regex-extended        #Utilise les regexps étendues (mais déja le cas?..)

--follow-symlinks       #Suit les liens pointés par les FILE s'ils s'agit de
                        #symlinks (mais déja le cas?..)

-u                      #Est unbuffered plutôt que line-buffered (cf doc sur les
--unbuffered            #buffers)

                                     RANGE

RANGE   ==>             #Une INSTRUCTION n'a lieu que si elle fait partie du
                        #RANGE qui lui est attribué
                        #RANGE par défaut est égal à 1,$

                        #Voici les valeurs possibles de RANGE_PRIM :

NUMBER                  #Ligne NUMBER. $ Désigne la dernière ligne.
                        #La numérotation des lignes est cumulative si plusieurs
                        #fichiers sont ciblés (elle ne s'initialise pas a
                        #chaque fichier)
NUMBER~STEP             #From ligne NUMBER to every STEP lines after
/PATTERN/               #Toute ligne contenant le PATTERN
/PATTERN/I              #Même chose mais case-insensitive

                        #Voici les valeurs possibles de RANGE :

RANGE_PRIM              #Un RANGE simples
RANGE_PRIM1,RANGE_PRIM2 #Toute ligne comprise entre la première occurence de
                        #RANGE_PRIM1 et la première occurence de RANGE_PRIM2
RANGE_PRIM,+NOMBRE      #Toute ligne comprise entre la première occurence de
                        #RANGE_PRIM et la ligne RANGE_PRIM+NOMBRE
RANGE_PRIM,~MULTIPLE    #RANGE_PRIM et toutes les lignes suivantes jusqu'à une
                        #ligne multiple dont le numéro est multiple de MULTIPLE
                        #(incluse)

RANGE!                  #Inverse le contenu de RANGE

RANGE {
    INSTRUCTION
    INSTRUCTION...      #Cette syntaxe permet à toutes les INSTRUCTION... d'être
}                       #définis sur RANGE. Ici la syntaxe dans un script .sed
RANGE { INSTRUCTION;
INSTRUCTION... }        #La même chose, avec la syntaxe en console
sed '
    RANGE {
        INSTRUCTION
        INSTRUCTION...  #La même chose, dans un script bash. La présentation
    }                   #peut être autre, l'important étant de séparer les
'                       #INSTRUCTION par des newlines ou ;

RANGE {
    RANGE {
        ...
    }                   #Cette syntaxe inclut un RANGE dans un RANGE, ce qui
}                       #imite un RANGE && RANGE

'RANGE INSTRUCTION'     #Toujours séparer RANGE et INSTRUCTION par un espace
"$VAR" 'INSTRUCTION'
        ERREUR ==>      #Erreur, il faut écrire "$VAR "'INSTRUCTION'

'RANGE INSTRUCTION1'
'RANGE! INSTRUCTION2'   #Est un if-then-else-like

                                     FLAGS

FLAGS ==>               #Les FLAGS peuvent être ajoutés à la fin de s///.
                        #Voici la liste :

g                       #substitue toutes les occurences de OLD dans le pattern
                        #space par NEW, et non seulement la première
[NOMBRE]                #substitue uniquement la ènieme occurence
                        #Peut être un moyen de cibler une colonne.
                        #Ex : s/./whatever/25
                        #Ne peut être présent qu'une fois par s///
[NOMBRE]g               #substitue uniquement la ènieme occurence et celles qui
                        #suivent.
                        #Peut être un moyen de cibler une colonne et celles qui
                        #suivent.
                        #Ex : s/./whatever/25g

I
i                       #case insensitive

p                       #imprime le pattern space, tel que modifié par s///
                        #Or par défaut il l'est à la fin de l'ENSEMBLE DES
                        #'COMMANDE', donc cela le double, mais avec -n cela
                        #n'imprimera que les pattern spaces modifiés, et une
                        #seule fois. (par défaut toute ligne est imprimée, donc
                        #cela les double, sauf avec -n, ou cela n'imprime donc
                        #que les lignes modifiees)
e                       #apres la substition, et seulement si une substition a
                        #lieu, remplace le pattern space par $(pattern space)
                        #ou pattern space doit donc etre une commande valide,
                        #sinon remplace par null
w FILE                  #Imprime une newline puis le pattern space modifié par
                        #s/// à la fin de FILE (toute première invocation dans
                        #l'ensemble de la commande sed, meme si le pattern
                        #space est vide, écrase FILE) plutot que vers stdout"

                                  INSTRUCTION

INSTRUCTIONS  ==>       #Certains espaces ne sont parfois pas obligatoires entre
                        #la lettre de l'INSTRUCTION et son argument. Il existe
                        #six catégories d'INSTRUCTIONS :

                           MODIFIANT LE PATTERN SPACE

MODIFIANT LE PATTERN    #Modifier le pattern space le modifie pour l'ENSEMBLE
SPACE  ==>              #DES 'COMMANDE' qui suivent
                        #Il est imprimé par défaut à la fin de l'ENSEMBLE DES
                        #'COMMANDE', suivi d'une newline (sauf si -n).

s/OLD/NEW/[FLAG]...     #Substitue la première occurences de OLD dans le
                        #pattern space par NEW. Les [FLAG]... peuvent être
                        #utilisés pour moduler la substitution. Les caractères
                        #\1 à \9 dans NEW renvoient aux blocs entre parenthèses
                        #numéro 1 à 9 dans OLD. & dans NEW fait référence à OLD.
y/CHAR.../NEWCHAR.../   #Remplace tout CHAR dans le pattern space par NEWCHAR.
                        #Chaque CHAR et NEWCHAR doit etre un seul symbole.
                        #Utile pour conversion de casse par exemple.

z                       #Supprime le pattern space

e [COMMANDE]            #(COMMANDE est une commande au sens classique du terme)
                        #Remplace le contenu du pattern space par $(COMMANDE),
                        #par $(pattern space) si [COMMANDE] est omise, ou par
                        #null si [COMMANDE] est erronée. Chaque ligne du
                        #nouveau pattern space sera traitée l'une après l'autre
                        #par l'ENSEMBLE DES COMMANDE suivantes (et non
                        #précédentes) avant de passer au prochain input.

                               MODIFIANT L'OUTPUT

MODIFIANT L'OUTPUT ==>  #Par défaut, il y a un output du pattern space à la fin
                        #de l'ENSEMBLE DES 'COMMANDE', suivi d'une newline
                        #(sauf si -n). Ces INSTRUCTION produisent d'autres
                        #outputs auparavant ou après, toujours suivis d'une
                        #newline.

p                       #Imprime le pattern space. Or par défaut il l'est à la
                        #fin de l'ENSEMBLE DES 'COMMANDE', donc cela le double,
                        #mais avec -n cela n'imprimera que les pattern spaces
                        #modifiés, et une seule fois. Grep-like : sed -n '/
                        #PATTERN/ p'
P                       #Même chose mais n'imprime que la première ligne du
                        #pattern space.
l [NOMBRE]              #Imprime le pattern space. Un $ est ajouté à la fin de
                        #chaque ligne, et les lignes dont le nombre de
                        #caractères excède [NOMBRE] sont wrapés avec un
                        #trailing newline.

a TEXTE                 #Imprime TEXTE apres l'output du pattern space. Si a
                        #n'est pas la dernière commande, il faut mettre a suivi
                        #d'un trailing backslash, ou refaire un -e "" après lui.
i TEXTE                 #Imprime TEXTE (mêmes remarques)
c TEXTE                 #Remplace le pattern space par TEXTE (mêmes remarques)

r FILE                  #Imprime le contenu de FILE après l'output du pattern
                        #space
R FILE                  #Meme chose mais n'imprime qu'une ligne de FILE à la
                        #fois a chaque invocation

w FILE                  #Imprime une newline puis le pattern space à la fin de
                        #FILE (toute première invocation dans l'ensemble de la
                        #commande sed, meme si le pattern space est vide,
                        #écrase FILE) plutot que vers stdout"
W FILE                  #Meme chose mais n'imprime que la premiere ligne du
                        #pattern space

q [EXITCODE]            #Imprime le pattern space (sauf si -n), puis stoppe
                        #l'ENSEMBLE DES COMMANDES et l'ensemble de la commande
                        #sed elle-même. Renvoie [EXITCODE].
Q [EXITCODE]            #Meme chose mais n'imprime pas le pattern space

=                       #Imprime le numéro de ligne de l'input, puis une
                        #newline. sed -n '$=' FILE imprime donc le nombre de
                        #lignes de FILE

                         MODIFIANT L'INPUT ET L'OUTPUT

MODIFIANT L'INPUT ET    #Ces INSTRUCTIONS modifie l'output, mais aussi l'input
L'OUTPUT  ==>           #courant (recommence un nouveau cycle)

d                       #Supprime le pattern space, ne renvoie pas de newline
                        #et annule tout ENSEMBLE DES 'COMMANDE' ultérieures
                        #pour l'input courant.
D                       #Agit comme d si le pattern space ne contient qu'une
                        #ligne. Sinon, ne supprime que la première ligne du
                        #pattern space, ne renvoie pas de newline, et annule
                        #tout ENSEMBLE DES 'COMMANDE' ultérieures pour l'input
                        #courant : cependant, ne passe pas au prochain input
                        #mais redémarre un ENSEMBLE DES 'COMMANDE' en gardant
                        #le nouveau pattern space.

n                       #Imprime le pattern space et une newline (sauf si -n)
                        #et passe au prochain input (tout en continuant
                        #l'ENSEMBLE DES 'COMMANDE') qui devient donc le pattern
                        #space.
N                       #Passe au prochain input (tout en continuant l'ENSEMBLE
                        #DES COMMANDE) en ajoutant une newline puis le prochain
                        #input au pattern space. Ceci permet de rechercher les
                        #\n par exemple et donc de faire des recherches multi-
                        #lignes. La séquence N;P;D permet d'avancer
                        #d'incrémenter un pattern space multi-ligne d'un input
                        #tout en imprimant et enlevant la premiere ligne de
                        #celui-ci.

                            MODIFIANT LE HOLD BUFFER

MODIFIANT LE HOLD       #Le Hold Buffer est une sorte de presse-papier ou
BUFFER  ==>             #registre qui permet de sauvegarder des valeurs et les
                        #renvoyer. Sa valeur de départ à chaque commande sed
                        #est null.

x                       #Echange les valeurs du pattern space et du hold buffer

h                       #Remplace le hold buffer par le pattern space sans
                        #modifier ce dernier
H                       #Rajoute une newline puis le pattern space à la fin du
                        #hold buffer

g                       #Remplace le pattern space par le hold buffer sans
                        #modifier ce dernier
G                       #Rajoute une newline puis le hold buffer à la fin du
                        #pattern space

                                     LABELS

: LABEL                 #Crée un LABEL. S'il y a un RANGE, la commande doit être
                        #dans un bloc { }

b                       #Annule tout ENSEMBLE DES 'COMMANDE' ultérieures pour
                        #l'input courant.
b LABEL                 #Goto LABEL. RANGE b LABEL peut servir de if-like en
                        #fonction de la condition RANGE

t LABEL                 #Comme b LABEL, mais n'execute le goto que s'il y a eu
                        #un s precedemment (depuis le dernier t LABEL s'il y en
                        #a un avant) et que celui-ci a réussi. Sinon, ne fait
                        #rien. Cela permet par exemple d'exécuter en boucle un s
                        #jusqu'à ce qu'il n'ait plus rien à substituer.
T LABEL                 #Comme t LABEL, mais n'execute goto que si le s a échoué

                                     AUTRES

v [VERSION]             #Fail si la version VERSION de GNU Sed n'est pas
                        #présente (défaut : 4.0)

                                   DELIMITERS

s:OLD:NEW:[FLAG]        #Il est possible de changer les délimiteurs / de s///
                        #et y///. Il suffit de mettre d'autres délimiteurs,
                        #comme : _ | - . Cela permet plus de lisibilité s'il y
                        #a beaucoup de slash dans OLD ou NEW (par exemple un
                        #path), qu'il faut donc échapper si le délimiteur est /
\:PATTERN:              #Il en va de même pour les délimiteurs de /PATTERN/,
                        #que l'on peut changer de la même manière, mais en
                        #ajoutant également un \ au début

                 INSTRUCTION SUR SEULEMENT UNE PARTIE DE LIGNE

INSTRUCTION SUR         #Pour appliquer une INSTRUCTION sur seulement une
SEULEMENT UNE PARTIE    #partie d'une ligne, bordée par un délimiteur, on peut
DE LIGNE  =>            #faire :
                        #h, INSTRUCTION, G, supprimer avec s tout ce qui a
                        #entre le délimiteur et sa copie (dont la copie elle-
                        #même).
                        #Rajouter un x entre INSTRUCTION et g si la partie à
                        #traiter est à la fin de la ligne