http://www.commentcamarche.com/faq/9536-sed-introduction-a-sed-part-i
https://likegeeks.com/sed-linux/#Understand-sed-Linux-Command

TOC

SYNOPSIS

^

sed [OPTION]... {script-only-if-no-other-script} [input-file]...

sed [-options] [commande] [] sed [-n [-e commande] [-f script] [-i[.extension]] [l [cesure]] rsu] [] []

[adresse[,adresse]][!]commande[arguments]

[adresse[,adresse]]{
 commande1
 commande2;commande3
}

OPTIONS

^

-n, --quiet, --silent # suppress automatic printing of pattern space
-e script, --expression=script # add the script to the commands to be executed
-f script-file, --file=script-file # add the contents of script-file to the commands to be executed
--follow-symlinks # follow symlinks when processing in place
-i[SUFFIX], --in-place[=SUFFIX] # edit files in place (makes backup if SUFFIX supplied)
-l N, --line-length=N # specify the desired line-wrap length for the `l' command
--posix # disable all GNU extensions
-E, -r, --regexp-extended # use extended regular expressions in the script (for portability use POSIX -E)
-s, --separate # consider files as separate rather than as a single, continuous long stream
--sandbox # operate in sandbox mode
-u, --unbuffered # load minimal amounts of data from the input files and flush the output buffers more often
-z, --null-data # separate lines by NUL characters
--help # display this help and exit
--version # output version information and exit

SUBSTITUTION

^

's/modèle/remplacement/drapeau(x)'

Autant la partie gauche (recherche) accepte la syntaxe des BRE (Basic Regular Expression, expressions régulières basiques), la partie droite (remplacement) quant à elle n'accepte que trois valeurs pouvant être interpolées :

• le caractère & (esperluette)
• les références arrières \1 (de 1 à 9)
• les options \U,\u,\L,\l et \E

les options de correspondance de l' extended regular expressions

\w # word
\W # non-word
\s # whitespace
\S # non-whitespace

les options de remplacement \d or \D are not supported

\u # upper next character of match
\l # lower next character of match
\U # upper all characters of match
\L # lower all characters of match

g # global - effectue le remplacement de toutes les occurrences mises en correspondance par le motif ou l'expression régulière

N # occurrence - remplace uniquement la nième occurrence mise en correspondance par le motif ou l'expression régulière

p # affichage - si une substitution a eu lieu, alors afficher l'enregistrement courant. Nécessite la présence de l'option "-n"

w # Si une substitution a eu lieu, écrit l'enregistrement courant dans le fichier spécifié. Un seul espace est accepté entre l'attribut "w" et le nom du fichier

e # evaluate - permet de faire exécuter une commande par le shell et d'en substituer le résultat avec le motif mis en correspondance, uniquement si une correspondance a été établie

I # case-Insensitive - ignore la casse lors de la mise en correspondance du motif

M # En tant normal l'espace de travail contient une ligne lue en entrée. D'autres lignes peuvent être ajoutées à l'espace de travail à travers l'emploi des commandes comme N, G, x, etc. Toutes ces lignes dans l'espace de travail sont séparées par le caractère de fin de ligne "\n" mais sont vues par Sed comme une seule et même ligne dont le début commence avant la 1ère ligne et se terminant à la fin de la dernière ligne. Avec le flag "M" chaque caractère représentant le début (^) et la fin ($) de ligne reprend si on peut dire ainsi, son sens initial et fait correspondre le début et la fin de ligne à chaque ligne se trouvant dans l'espace de travail

BASIC

^

'#' # commentaires, si les premiers caractères du script sont "#n", l'option "-n" (no-autoprint) est forcé

q # quit, quitte sed sans procéder à aucune autre commande ni évaluer une autre entrée. La ligne courante contenue dans la mémoire principale est affichée à moins que l'option "-n" ait été employée

d # delete, efface l'enregistrement courant et démarre un nouveau cycle

p # print, affiche à l'écran l'enregistrement courant (l'espace de travail). Elle n'efface pas l'espace de travail et ne modifie pas non plus le déroulement du script. Cette commande est toujours employée conjointement avec l'option "-n", sans quoi l'affichage de la ligne est dupliquée

n # nextline, remplace l'enregistrement courant dans l'espace de travail par la ligne suivante sans entamer un nouveau cycle. La ligne remplacée quant à elle est envoyé sur la sortie standard

{ ... } # les accolades permettent de regrouper certaines commandes à effectuer sur une adresse ou une plage d'adresses. (inutile de les protéger par un \)

PRE-COMMAND

^

y # La commande "y" permet de convertir n'importe quel caractère énuméré dans la chaîne caractère-source par son homologue, en lieu et place, se trouvant dans la chaîne caractère-destination

a\ # ajoute le texte après la ligne mise en correspondance par son numéro de ligne, motif ou expression régulière, et avant la lecture de la ligne suivante. "text" correspond à une seule ligne de texte, qui peut néanmoins contenir des sauts de lignes précédés par des "\" (backslash)

i\ # insère le texte "text" avant la ligne mise en correspondance par son numéro de ligne, motif ou expression régulière. "text" correspond à une seule ligne de texte, qui peut néanmoins contenir des sauts de lignes précédés par des "\" (backslash)

c\ # échange la ligne mise en correspondance par le numéro de ligne, motif ou expression régulière par "text". "text" correspond à une seule ligne de texte, qui peut néanmoins contenir des sauts de lignes précédés par des "\" (backslash)

r # lit le contenu de "fichier" dans l'espace de travail à la suite de l'adresse spécifiée. Il ne doit y avoir qu'un seul espace entre la commande et le nom du fichier. Tout ce qui suit cet espace, et ce jusqu'à la fin de la ligne, est considéré comme étant le nom dudit fichier. De ce fait tout espace (tabulation comprise) sera considéré comme faisant partie intégrante du nom. Si le fichier n'existe pas, aucun message d'avertissement ne sera émis ni sur la sortie standard ni ailleurs. Si le fichier ne se trouve pas dans le même répertoire d'où est lancée la commande, veillez à spécifier le chemin complet vers le fichier

w # écrit la ligne en cours de traitement dans le fichier spécifié à la suite de la commande "w". Tout comme la commande "r" (lecture), il ne doit y avoir qu'un seul espace entre la commande et le nom du fichier. Tout ce qui suit cet espace, et ce jusqu'à la fin de la ligne, est considéré comme étant le nom dudit fichier. De ce fait tout espace (tabulation comprise) sera considéré comme faisant partie intégrante du nom. Si un fichier du même nom existe déjà, il sera écrasé sans avertissement ni confirmation et ce à chaque invocation du scriipt. En revanche, si plusieurs instructions de la commande "w" sont appelées à écrire dans un même fichier depuis un script, chaque écriture est ajoutée à la fin du fichier

= # affiche le numéro de la ligne courante
l [N] # affichage des caractères non imprimable - N permet de spécifier la longueur de coupure de ligne désirée

ADVANCED

^

• multi-lignes (N,D,P)
• utilisant la mémoire annexe (h,H,g,G,x)
• tests faisant appel à des étiquettes (:,b,t,T)

Multi-lines

N # Next, positionne le caractère "nouvelle ligne" (\n) à la fin du contenu de l'espace de travail et ajoute la ligne suivante du flux d'entrée à l'espace de travail. Si la fin du fichier d'entrée est atteinte, sed termine son exécution sans procéder au traitement d'une nouvelle commande. Le caractère "nouvelle ligne" incorporé dans l'espace de travail peut être matché par la séquence d'échappement "\n". Dans un espace de travail "multilignes", les méta-caractères "^" et "$" matchent respectivement le début et la fin de cet espace de travail et non pas les débuts et fins de lignes précédents ou suivants le caractère nouvelle ligne incorporé

D # Delete, efface le contenu de l'espace de travail jusqu'au 1er caractère délimitant une nouvelle ligne (\n). S'il reste encore des données dans l'espace de travail , un nouveau cycle est redémarré avec ce contenu (sans lire une nouvelle ligne en entrée), sinon un nouveau cycle est démarré avec la ligne suivante

P # Print, affiche le contenu de l'espace de travail jusqu'au 1er caractère délimitant une nouvelle ligne (\n). Quand la dernière commande du script est atteinte, le contenu de l'espace de travail est automatiquement affiché sur la sortie standard (à moins que l'option "-n" ou "#n" n'ait été employée)

Mémoires tampons

• h > Copie l'espace de travail dans la mémoire annexe
• H >> Ajoute l'espace de travail dans la mémoire annexe
• g Échange le contenu des 2 mémoires

h hold pattern space # copie le contenu du motif courant (pattern space) dans la mémoire secondaire, écrasant le contenu précédemment copié si présent. Le tampon courant reste inchangé

H Hold pattern space # ajoute le contenu du motif courant (pattern space) au contenu de la mémoire secondaire. L'ancien contenu et le nouveau sont séparés par une nouvelle ligne matérialisée par le caractère "\n". Le tampon courant reste inchangé. Une nouvelle ligne (\n) est ajoutée à l'espace de travail même si celui-ci est vide

g get contents # copie le contenu de la mémoire secondaire vers le motif courant, écrasant le contenu de celui-ci

G Get contents # ajoute le contenu de la mémoire secondaire au motif courant. L'ancien contenu et le nouveau sont séparés par une nouvelle ligne matérialisée par le caractère "\n"

x eXchange # échange le contenu des deux mémoires tampons (principale et secondaire). Il faut savoir que la mémoire secondaire démarre son cycle avec une ligne vide. Si vous appliquez la commande "x" à la 1ère ligne d'un fichier, cette ligne est donc placée dans la mémoire annexe et est remplacée par le contenu de cette mémoire annexe, autrement dit une ligne vide. Sachez encore que suivant ce principe, la dernière ligne d'un fichier est placée dans la mémoire annexe mais n'est jamais restituée dans l'espace de travail et de ce fait ne sera jamais affichée à moins d'en faire une demande implicite

Etiquettes

:etiquette # définition d'une étiquette

b branch # permet de transférer inconditionnellement l'exécution du script à l'emplacement indiqué par l'étiquette fournie en argument. Si aucun argument n'est fourni, la commande renvoie à la fin du script. La commande en cours de traitement est alors affichée sauf si l'option "-n" était active et le script reprend son exécution avec la prochaine ligne du flux d'entrée

t test # permet de transférer conditionnellement l'exécution du script à l'emplacement indiqué par l'étiquette fournie en argument si une commande de substitution a réussi sur la ligne en cours de traitement ou sur le dernier branchement conditionnel. Si aucun argument n'est fourni, la commande renvoie à la fin du script

T test # permet de transférer conditionnellement l'exécution du script à l'emplacement indiqué par l'étiquette fournie en argument si une commande de substitution a échoué sur la ligne en cours de traitement ou sur le dernier branchement conditionnel. Si aucun argument n'est fourni, la commande renvoie à la fin du script

examples

sed '/^#\?relayhost/h $!d x' # Print the last matched line
sed '/^#\?relayhost/h $!d x s|=.*|= toto|' # Print the last matched line modifed
sed -n '\|str|p' # replace limiters with | & print line matching with str
sed '=' # insert line numbers before lines

sed -r 's/\w+/\u&/g' <<< "Now is the time for all good men..." # Now Is The Time For All Good Men...
sed "a\\$str" # append after each line a line with $str
sed "5i\\$str" # insert before th 5rd lines the line contains $str
sed "5,$i\str" # insert between 5rd lines and end of file, the line contains $str
sed "5,/$pat/$i\\$str" # insert between 5rd lines and line matched by $pat, the line contains $str
sed '/$pat/!c\str' # replace line not macthed $pat with $str

sed 'y/$str1/$str2/' # replace str1 with str2, length of $str1 & $str2 have to be the same

sed 's/^.\{10\}//' # remove the first 10 characters
sed 's/.\{10\}$//' # remove the last 10 characters
sed 's/.//5g' <<< "defn-test" # remove all characters after 5rd
sed 's/.*0//' # remove all characters until 0
sed 's/0.*//' # remove all charcaters after 0
sed -e 's/^\(.\{12\}\).*/\1/' # keep the 10 first characters
cut -c 1-12 # keep the 10 first characters

sed -n "/$pat/ {p;q}" # print only the first matched line with $pat
sed -e '/^$/d;/^#$/d' # delete empty lines & lines started with a single #
sed -n 3p # print line 3
sed -n '3p;6p' # print line 3 & 6
sed '6,$d' # delete lines from 6 to end
sed 1~3d # delete 1 line per 3

sed "\|$pat|d" # delete only matched line with $pat

sed -n '/str1/,/str2/p'# print lines between lines matched by str1 & str2. if str2 is before str1 or str2 don't found, then lines are printed from matched str1 to end of file, if str1 are matched few times, the position of last matched is taken for positioning the 10th

sed -n '/str1/,10p' # print lines between lines matched by str1 & 10th line. if 10th line don't exists or are before line matched with str1, then lines are printed from matched str1 to the end of file, if str1 are matched few times, the position of last matched is taken for positioning the 10th

sed '3q' # print lines from begining to th 3th
sed -n '0-3p' # print lines from begining to th 3th

sed -n '3{p;q}' # print the 3th line & quit : Not read the lines after, more speed for long file
echo -e "AAA\nBBB\nCCC\nDDD" | sed -n '/BBB/ {n;p;q}' # print the next line after matched line & quit
echo -e "AAA\nBBB\nCCC\nDDD" | sed -n '/BBB/ {n;s/C/Z/2p}' # print the next line after matched line with the 2nd character C replaced by Z

# line number
sed -n '/$pat/=' # show only line numbers of matched lines
sed -n '/$pat1/,/$pat2/{=;p}' # print line numbers and lines for a rgane of lines : begining with $pat1 & ending with $pat2
sed -n $= $file # print the total line numbers in $file

# read
sed '/test/r newfile' file # append newfile in file in line 
sed '/$pat/ {r newfile;d}' file # replace line matched with $pat by newfile

advanced examples

echo "AAAAA" | sed 's/A/B/' -> BAAAA
echo "AAAAA" | sed 's/A/B/g' -> BBBBB
echo "AAAAA" | sed 's/A/B/3' -> AABAA

var="ligne1\nligne2\nligne3"
echo -e $var
ligne1
ligne2
ligne3

sed '2 s/e2/e n° 2/' # replace in the 2nd line character 'e2' by 'e n° 2'
ligne1
ligne n° 2
ligne4

sed '2 s/e2/e n° 2/p' # duplicate the 2nd line & replace in the 2nd line character 'e2' by 'e n° 2'
ligne1
ligne n° 2
ligne n° 2
ligne3

sed -n '2 s/e2/e n° 2/p' # print only the 2nd line with character 'e2' by 'e n° 2'
ligne n° 2

a="Bonjour"
sed 's/.*2/echo '$a'/e' # replace th 2nd line with the result of command 'echo $a'
ligne1
Bonjour
ligne3

a="Bonjour"
sed '2 s/.\{5\}/echo '$a'/e' # for the 2nd line replace the 5rd first characters with the result of command 'echo $a'

echo "BonJouR" | sed 's/bONjOUr/Salut/' -> BonJouR
echo "BonJouR" | sed 's/bONjOUr/Salut/I' -> Salut

echo -e "foo\nbar" | sed 'N;s/^.*$//'
echo -e "foo\nbar" | sed 'N;s/^.*$//M'
bar

echo -e "foo\nbar\nfoobar\nbarfoo" | sed -e ':boucle; N; $! b boucle; s/^.*$//M3'
foo
bar

barfoo
$

echo -e "foo\nfoo\nfoo\nbar\nfoo" | sed 'N;/bar$/s/^/>/Mg;P;D'
foo
foo
>foo
>bar
foo
$

$ echo -e "foo\nfoo" | sed 'N;s/^/>/;s/\n/\n>/g'
>foo
>foo
$

echo -e "foo\nfoo" | sed 'N;s/^/>/Mg'
>foo
>foo
$

sed '
y/àâéèêëîïôöùûü/aaeeeeiioouuu/
y/ÀÂÉÈÊËÎÏÔÖÙÛÜ/AAEEEEIIOOUUU/
' fichier.txt - part I

sed '/Ligne n° 5/ a\
Bonjour
' fich.txt

sed '/Ligne n° 4/ i\
Bonjour
' fich.txt

sed '/Ligne n° 2/,/Ligne n° 6/ c\
Annulé\
Pour cause\
de travaux
' fich.txt

sed -s '$ r signature.txt' fich*.txt

sed -f foo.sed 

PATTERN-SPACE

^

sed '/^a test$/{
    $!{ N    # append the next line when not on the last line
     s/^a test\nPlease do not$/not a test\nBe/
          # now test for a successful substitution, otherwise
          #+ unpaired "a test" lines would be mis-handled
     t sub-yes # branch_on_substitute (goto label :sub-yes)
     :sub-not  # a label (not essential; here to self document)
          # if no substituion, print only the first line
     P     # pattern_first_line_printaffichage des caractères non imprimable - N permet de spécifier la longueur de coupure de ligne désirée
     D     # pattern_ltrunc(line+nl)_top/cycle
     :sub-yes  # a label (the goto target of the 't' branch)
          # fall through to final auto-pattern_print (2 lines)
    }
   }' alpha.txt 

Here it is the same script, condensed into what is obviously harder to read and work with, but some would dubiously call a one-liner

sed '/^a test$/{$!{N;s/^a test\nPlease do not$/not a test\nBe/;ty;P;D;:y}}' alpha.txt

Here is my command "cheat-sheet"

: # label
= # line_number
a # append_text_to_stdout_after_flush
b # branch_unconditional
c # range_change
d # pattern_delete_top/cycle
D # pattern_ltrunc(line+nl)_top/cycle 
g # pattern=hold
G # pattern+=nl+hold
h # hold=pattern
H # hold+=nl+pattern
i # insert_text_to_stdout_now
l # pattern_list
n # pattern_flush=nextline_continue
N # pattern+=nl+nextline
p # pattern_print
P # pattern_first_line_print
q # flush_quit
r # append_file_to_stdout_after_flush 
s # substitute
t # branch_on_substitute
w # append_pattern_to_file_now
x # swap_pattern_and_hold
y # transform_chars

LOOP

^

sed ':a;N;$!ba;s/\n/ /g' file

This will read the whole file in a loop, then replaces the newline(s) with a space
:a # create a label a
N # append the current and next line to the pattern space
$!ba # If we are before the last line, branch to the created label $!ba ($! means not to do it on the last line as there should be one final newline)
s/\n/ /g # finally the substitution replaces every newline with a space on the pattern space (which is the whole file)