mercredi 14 décembre 2016

Open CPN : navigation opensource

OpenCPN est un projet de logiciel libre (GPLv2) pour créer un traceur de cartes et un logiciel de navigation concis, en cours d'utilisation ou en tant qu'outil de planification. OpenCPN est développé par une équipe de navigateurs actifs en utilisant les conditions du monde réel pour les tests de programme.

Site du projet : http://opencpn.org
Page de téléchargement : http://opencpn.org/ocpn/download

grep - awk - sed

Le contenu de ce post n'est pas issu de ma prose personnelle mais du site : http://www.corporesano.org/doc-site/grepawksed.html.
Je l'ai copié ici avec quelques mises en forme afin de partager ce mémo très utile au quotidien.

SOMMAIRE

1- Numéroter - compter - additionner - cumuler 
2- opérations sur les champs : NF 
3- opérations sur les lignes : NR - occurrences 
4- pattern 
5- Remplacer des lignes des chiffres ou des lettres 
6- Supprimer ou insérer des lignes blanches, espaces, tabulations 
7- Insérer 
8- divers

L’exécution du script peut dépendre de la version de Linux installée. Il s’exécute parfois dans un "sous shell" (en tapant 'sh') (taper 'exit' pour sortir)

#1-Numéroter - compter - additionner - cumuler

  • Affiche le nombre de lignes (avec les lignes vides)
    sed -n -e '$=' in.txt
    awk 'END{print NR}' in.txt
    awk '{n++} END{print n}' in.txt
  • Affiche le nombre de lignes (sans les lignes vides)
    awk '/./ {print}' in.txt | wc -l
    grep "." in.txt | wc -l
  • Somme avec cumul de la colonne 1
    awk '{print (total +=$1)}' in.txt
  • Print le nombre de mots
    awk '{x=x+NF}END{print x}' in.txt
  • Compte nombre de lignes contenant le pattern 'titi'
    awk '/titi/{x+=1}END{print x}' in.txt
  • Print le numero de chaque ligne
    awk '{print NR,$0}' in.txt
    c=0; while read line; do ((c+=1)); echo $c $line; done < in.txt
  • Compteur vertical
    for i in `seq 1 15`;do echo "$i";done
  • Compte le nombre de lignes vides d'un fichier
    awk '/^$/ {x += 1};END {print x }' in.txt
  • Compter le nombre de mots d'un fichier
    cat in.txt | wc -w
  • Compter le nombre de lignes et de mots
    awk 'BEGIN{nl=0;nw=0} {nl++;nw+=NF} END {print "lines:",nl, "words:",nw}' in.txt
  • Compter un caractere (ici: i)
    var=`cat in.txt` ; var="${var//[^i]/}" ; echo ${#var}
  • affiche le numero de ligne du pattern
    grep -n "pattern" in.txt
  • Compter le nombre d'occurrences de 'pattern'
    grep -c "pattern" in.txt
    awk '/pattern/ {n++} END {print n}' in.txt
  • Numeroter toutes les lignes contenant 'pattern' (affiche 1 numero par ligne)
    sed -n '/pattern/=' in.txt
  • Numeroter toutes les lignes entre 2 patterns (affiche 1 numero par ligne)
    sed -n '/pattern1/,/pattern2/{=;d;}' in.txt
  • Numeroter les lignes sans les lignes blanches
    nl in.txt
  • Numeroter les lignes avec les lignes blanches
    cat -n in.txt
    sed = in.txt | sed 'N; s/\n/\t/'
  • Numeroter les lignes
    awk '{print NR,$0}' in.txt
    while read line; do N=$((N+1)); echo "Line $N = $line"; done < in.txt
  • Ecrire le nom du fichier devant chaque ligne
    grep -H "pattern" in.txt
  • Somme et cumul d'une colonne ($2) , en utilisant 1 colonne clef ($1)
    awk '{arr[$1]+=$2} END {for(i in arr) {print i, arr[i]}}' in.txt | sort

    #2-Operations sur les champs : NF

  • Compter le nombre de champs de chaque ligne (separateur = ",")
    awk '{cnt=0 ; for(i=1; i<=NF; i++) {if($i != "") {cnt++}} {print NR " : "cnt" fields"}}' FS="," in.txt
  • Printer les 5 premiers caractères de toutes les lignes d'un fichier
    while read line;do echo ${line::5};done < in.txt
    while read line ; do echo $line | cut -c1-5 ; done < in.txt
  • Deleter les 5 premiers caracteres de toutes les lignes d'un fichier
    colrm 1 5 < in.txt
    awk 'sub("^.....", "")' in.txt
    while read line ; do echo $line | cut -c6- ; done < in.txt
  • Printer les 5 derniers caracteres de toutes les lignes
    sed 's/^.*\(.....\)$/\1/' in.txt
    sed 's/\(.*\)\(.\{5\}\)/\2/' in.txt
    while read line;do echo ${line: -5};done < in.txt
    awk '{print substr($0, length($0) - 4, length($0) ) }' in.txt
  • Deleter les 5 derniers caracteres de toutes les lignes
    awk 'sub(".....$", "")' in.txt
  • Supprimer un champ
    echo "data1 line1" | sed 's/.* //'
    echo "data1 line1" | sed -n 's/.* //;p'
    resultat: line1
  • Supprimer le dernier champ
    awk '{$NF=""; print $0}' in.txt
  • Champ tampon 'elapse' pour operations intermediaires
    awk '{elapse = $1/3600; if(elapse<8) print int($1/3600)}' in.txt
  • Dans champ 1, a la position 2, printer 3 caracteres
    awk '{print substr($1,2,3)}' in.txt
  • Print l'avant dernier champ ($NF-1) de chaque ligne
    awk '{print $(NF-1)}' in.txt
  • Print le nombre de champs uniquement
    awk '{print NF}' in.txt
  • Print le nombre maximum de champs
    awk '{print NF}' in.txt | sort -n | sed -n '$p'
  • Print le nombre minimum de champs
    awk '{print NF}' in.txt | sort -n | sed -n '1p'
  • Printer 2 colonnes en precisant le separateur
    awk -F'[ ]' '{print $2,$3}' in.txt
    cut -d ' ' -f2,3 in.txt
  • Printer du 5eme caractere au dernier (inclus) sur toutes les lignes d'un fichier
    cat in.txt | cut -c '5-'
  • Printer du 1er au 5eme caractere (inclus) sur toutes les lignes d'un fichier
    cat in.txt | cut -c '-5'
  • Printer du 3eme au 5eme caractere (inclus) et du 7eme au 9eme (inclus) sur toutes les lignes d'un fichier
    cat in.txt | cut -c '3-5,7-9'
  • Printer les lignes dont le nombre de champs est inferieur a 3
    awk 'NF<3' in.txt
  • Printer les lignes n'ayant qu'un seul champ
    awk '{if(NF == 1) {print}}' in.txt
  • Tri de la 1ère colonne au 22eme caractere
    sort -k1.22
  • Print si longueur de 'colonne 1' >3 "ET" ou "OU" longueur de 'colonne 2' <5
    awk 'length($1)>3 && length($2)<5 {print}' in.txt ........... #ET
    awk 'length($1)>3 || length($2)<5 {print}' in.txt ........... #OU
  • Condition de print sur la longueur de colonne
    awk '{if(length($1)<2 && $1~/2/) {print $2} else {print $1}}' in.txt

    #3-operations sur les lignes : occurrences - digits - suppression - doubles - printer

  • Occurrences
    Capturer la premiere occurrence d'une serie de lignes ayant meme pattern
    cat in.txt | sort -k1 | awk 'x !~ $1 ; {x = $1}'
    cat in.txt | sort -k1 | awk '!d[$1] {print} {d[$1]=1}'
    cat in.txt | sort -k1 | awk 'x[$1]++ {next} {print}'
    cat in.txt | sort -k1 | awk '!_[$1]++ {print $0 ; next} {next}'
  • Occurrences
    Compter et marquer a la fin de la ligne les occurrences d'un unique pattern
    awk '/pattern/ {i=i+1} {print $0,i}' in.txt | awk '!a[NF]++ {print $0 ; next} {sub($NF,"") ; print}'
  • Occurrences
    Compter les occurrences d'un pattern (total cumule)
    awk '/pattern/ {n++} END {print "pattern ecrit" n "fois"}' in.txt
  • Occurrences
    Compter les occurrences d'un pattern (pour chaque ligne)
    awk -F "pattern" '{print NF-1}' in.txt
  • Occurrences
    Remplace sur chaque ligne la 1ère occurrence de 't' par 'b'
    sed -e '1,$ s/t/b/1' in.txt
    while read line; do echo ${line/t/b}; done < in.txt
  • Occurrences
    Remplacer la 2ème occurrence d'un pattern de la premiere ligne
    sed '0,/old/ s//new/2' in.txt
  • Occurrences
    Remplacer la 2ème occurrence d'un pattern pour chaque ligne
    sed 's/old/new/2' in.txt
    sed '/old/ s//new/2' in.txt
    awk '{print gensub(/old/, "new", 2)}' in.txt
  • Occurrences
    Print la 1ère occurrence d'un "pattern"
    grep -m1 "pattern" in.txt
    sed -n '/pattern/{p;q;}' in.txt
  • Occurrences
    Printer les lignes dont les elements de la colonne 2 ont plus d'une occurrence
    awk 'FNR==NR && a[$2]++ {b[$2] ; next} $2 in b' in.txt in.txt
  • Digits
    Printer les 4 premiers digits de chaque ligne
    cat in.txt | cut -c1-4
    for line in $(cat in.txt); do echo `expr "$line" : '\(....\)'`; done
    while read line; do echo `expr "$line" : '\(....\)'`; done < in.txt
  • Digits
    Printer les 4 derniers digits de chaque ligne
    awk '{print substr($0, length($0)-3, length($0))}' in.txt
  • Digits
    Deleter les 3 derniers digits de chaque ligne
    sed -n '1,$ s/...$//p' in.txt
  • Digits
    Printer du 5ème digit au dernier de la ligne pour toutes les lignes
    while read line; do echo "substr($line,4)" | m4; done < in.txt
  • Digits
    Printer 6 digits à partir du 2ème digit
    while read line; do echo `expr substr "$line" 2 6`; done < in.txt
  • Suppression de lignes
    Supprime de la ligne 4 a 7 (inclus) du fichier
    sed '4,7d' in.txt
  • Suppression de lignes
    Supprime les lignes contenant 'toto'
    sed '/toto/d' in.txt
    grep -v "toto" in.txt
  • Suppression de lignes
    Supprime 'toto' de la ligne 2 a 6
    sed -e '2,6 s/toto//g' in.txt
  • Suppression de lignes
    Supprime les lignes debutant par un chiffre (1 a 9)
    awk '$1 ~ /^[1-9]/ {next} {print}' in.txt
  • Suppression de lignes
    Supprime la ligne debutant par '@' et les 2 suivantes
    sed '/^@/ {N;N;d;}' in.txt
  • Suppression de lignes
    Supprimer la 1ere ligne , la derniere ligne ...
    sed '1d' in.txt ........... #supprime la premiere ligne
    sed '3d' in.txt ........... #supprime la ligne 3
    sed '$d' in.txt ........... #supprime la derniere ligne
  • Suppression de lignes
    Supprimer les lignes 1, 4, 7, 10.....
    sed -e '1~3d' in.txt
  • Suppression de lignes
    Supprimer 1 ligne toutes les 3 lignes
    sed '0~3d' in.txt
    sed 'n;n;d;' in.txt
  • Suppression de lignes
    Deleter les 2 dernieres lignes
    sed 'N;$!P;$!D;$d' in.txt
  • Suppression de lignes
    Deleter les 10 dernieres lignes
    sed -e :a -e '$d;N;2,10ba' -e 'P;D'
    sed -n -e :a -e '1,10!{P;N;D;};N;ba'
  • Lignes doubles
    Printer les lignes uniques sans les doubles
    sort -u in.txt
    sort in.txt | uniq
    awk '!x[$0]++' in.txt
    awk '{ a[$1]++ } END {for (i in a) print i}' in.txt | sort
    sed '$!N; /^\(.*\)\n\1$/!P; D' in.txt .........consecutive lines
  • Lignes doubles
    Printer les lignes doubles , deleter le reste
    awk 'x[$0]++' in.txt
    cat in.txt | uniq -d
    sed '$!N; s/^\(.*\)\n\1$/\1/; t; D' in.txt
  • Lignes doubles
    Printer les lignes doubles (ou triples ...)
    awk 'FNR==NR && a[$0]++ {b[$0] ; next} $0 in b' in.txt in.txt
  • Printer des lignes
    Printer uniquement la ligne 10
    sed '10q;d' in.txt
    sed '10!d' in.txt
    sed -n '10p' in.txt
    awk '{f[NR]=$0} END {print f[10]}' in.txt
    awk 'NR == 10 {print}' in.txt
  • Printer des lignes
    Printer de la ligne 1 a 10
    sed 10q in.txt
    awk 'NR <=10{print}' in.txt
  • Printer des lignes
    Printer de la ligne 3 a 5
    sed '3,5!d' in.txt
    sed -n '3,5p' in.txt
    awk 'NR >= 3 && NR <= 5' in.txt
    head -5 in.txt | tail -3
    sed -n '3{:a;N;5!ba;p}' in.txt
  • Printer des lignes
    Printer la ligne 5 et 10 d'une serie de fichiers
    for i in fichiers*;do awk 'NR == 5;NR == 10 {print $0}' $i;done
  • Printer des lignes
    Printer de la ligne 5 a 10 en numerotant
    awk 'NR == 5,NR == 10 {print NR" " $0}' in.txt
  • Printer des lignes
    Printer la 1ere ligne à la place de la 3eme ligne
    sed -n -e '1h; 1!p; 3{g;p}' in.txt
  • Printer des lignes
    Printer la 1ere ligne
    sed q in.txt
  • Printer des lignes
    Printer la dernière ligne
    sed -n '$p' in.txt
    sed '$!d' in.txt
  • Printer des lignes
    Printer les 2 dernieres lignes
    sed '$!N;$!D' in.txt
  • Printer des lignes
    Printer les 10 dernieres lignes
    sed -e :a -e '$q;N;11,$D;ba' in.txt
  • Printer des lignes
    Printer la 1ere et derniere ligne
    head -1 in.txt ; tail -1 in.txt
    sed -n '1p ; $p' in.txt
    awk 'NR==1 ; END {print}' in.txt
    sed q in.txt;sed '$!d' in.txt
    sed q in.txt;sed '$\!d' in.txt ..........#selon version de Linux
    IFS=$'\n';array=($(cat in.txt)); echo ${array[0]};sed '$!d' in.txt ........#en sous shell
  • Printer des lignes
    Printer les lignes ayant moins de 6 caracteres
    sed '/^.\{6,\}/d' in.txt
  • Printer des lignes
    Printer les lignes de 6 caracteres ou plus
    sed -n '/^.\{6\}/p' in.txt
  • Indexage du premier 't' lu pour chaque ligne
    while read line; do echo `expr index "$line" t`; done < in.txt
  • Longueur de chaque ligne (en nombre de digits) - voir si la version de Linux supporte : ' m4 '
    while read line; do echo "len($line)" | m4; done < in.txt
    while read line; do echo `expr length "$line"`; done < in.txt
  • Formater sur une meme ligne : une ligne paire a droite d'une ligne impaire
    cat in.txt | sed "N;s/\(.*\)\n\(.*\)/\1 \2/"
    cat in.txt | sed "N;s/\n/ /"
    cat in.txt | sed '$ !N; s/\n/ /'
  • Formater sur une meme ligne : une ligne impaire a droite d'une ligne paire
    cat in.txt | sed "N;s/\(.*\)\n\(.*\)/\2 \1/"
  • Affiche 1 ligne sur 2 (lignes 1, 3, 5...)
    sed 'n;d' in.txt
    sed -n 'p;n' in.txt
    sed -n '1,${p;n;}' in.txt
    sed '2~2d' in.txt
    awk 'FNR % 2' in.txt
    awk 'NR%2 {print}' in.txt
    awk 'NR%2 == 1' in.txt
  • Affiche 1 ligne sur 2 (lignes 2, 4, 6...)
    sed -n 'n;p' in.txt
    sed -n '1,${n;p;}' in.txt
    sed '1~2d' in.txt
    awk '!(FNR % 2)' in.txt
    awk '(NR+1)%2 {print}' in.txt
    awk 'NR%2 == 0' in.txt
  • Affiche 1 ligne sur 5 a partir de la ligne 3
    sed -n '3,${p;n;n;n;n;}' in.txt
  • Recherche de la ligne la plus longue
    awk '{ if ( length > L ) { L=length ; s=$0 } } END { print L,"\""s"\""}' in.txt

    #4-pattern

  • Capture d'un pattern dans 1 fichier
    grep 'pattern' in.txt
    grep -w 'pattern' in.txt
    awk '/pattern/' in.txt
    awk '$0 ~ /\ypattern\y/ {print}' in.txt
    sed -n '/pattern/p' in.txt
    sed '/pattern/ !d' in.txt
    grep '\<pattern\>' in.txt
  • Printer les lignes ne contenant que des chiffres
    sed -n '/^[[:digit:]]*$/p' in.txt
  • Printer les lignes ne contenant que des lettres
    sed -n '/^[[:alpha:]]*$/p' in.txt
  • Capture d'un pattern dans plusieurs fichiers
    grep "pattern" in*.txt
    for i in in*.txt;do seq=`ls $i`;awk '/pattern/ {print seq,$0}' seq=${seq} $i;done
  • Printer un paragraphe separe par des lignes blanches , contenant un pattern
    sed -e '/./{H;$!d;}' -e 'x;/pattern/!d;' in.txt
  • Printer un paragraphe separe par des lignes blanches , contenant pattern1 'et' pattern2
    sed -e '/./{H;$!d;}' -e 'x;/pattern1/!d;/pattern2/!d' in.txt
  • Printer un paragraphe separe par des lignes blanches , contenant pattern1 'ou' pattern2
    sed -e '/./{H;$!d;}' -e 'x;/pattern1/b' -e '/pattern2/b' -e d in.txt
  • Capturer dans la colonne 1 le pattern '2' et printer la colonne 3
    awk '$1 ~ /2/ {print $3}' in.txt
    awk '$1 == "2" {print $3}' in.txt
    awk '{if($1 ~ /t/){gsub(/t/, "z",$1);print $0}}' in.txt
    awk '$1 !~ /2/ {print $3}' in.txt ........... #syntaxe inverse
    awk '$1 \!~ /2/ {print $3}' in.txt ...........#syntaxe inverse (selon version Linux)
  • Supprimer les lignes contenant des patterns
    awk '$1 !~ /pattern1/ && $2 !~ /pattern2/ ' in.txt
    awk '$1 ~ /pattern1/ || $2 ~ /pattern2/ {next} {print}' in.txt
  • Capturer le caractère # à la 4ème position
    egrep '^.{3}#' in.txt
  • Capturer les lignes commencant par 1 espace ou plus, sans celles commencant par 2 espaces
    grep "[ ]\{1\}" in.txt | awk '$0 !~ /^ / {print}'
  • Capturer les lignes ayant 4 chiffres ou plus
    grep "[0-9]\{4\}" in.txt
  • Lire plusieurs patterns - (possibilite de lignes doubles)
    awk '/pattern1/ {print $0} /pattern2/ {print $0}' in.txt
    awk 'FNR==NR && a[$0]=/^t/ || a[$0]=/^d/ {b[$0] ; next} $0 in b' in.txt in.txt
  • Utiliser 'egrep' si le pattern a plusieurs lignes
    egrep -a "MIN WORD 2|MIN WORD32" in.txt
  • Ajouter antislash (\) pour le caractère special: |
    egrep "3 \|DISK|4 \| DISK" in.txt
  • Pattern1 OR pattern2
    sed '/[pattern1pattern2]/!d' in.txt
    sed -e '/pattern1/b' -e '/pattern2/b' -e d in.txt
    awk '/pattern1|pattern2/' in.txt
    grep -E "pattern1|pattern2" in.txt
    grep -e pattern1 -e pattern2 in.txt
  • Pattern1 AND pattern2
    sed '/a/!d; /b/!d' in.txt
    sed '/pattern1.*pattern2/!d in.txt
    awk '/pattern1.*pattern2/' in.txt
    awk '/pattern1/ && /pattern2/' in.txt
    grep -E 'pattern1.*pattern2' in.txt
  • NOT pattern1
    grep -v 'pattern1' in .txt
    awk '!/pattern1/' in.txt
    sed -n '/pattern1/!p' in.txt
  • Printer les 2 premieres occurrences du pattern
    grep -m2 "tata" in.txt
  • Substitution uniquement pour la 1ere occurrence
    sed '0,/tata/ s//zaza/' in.txt
  • Remplace 'old' par 'new' uniquement sur les lignes commencant par %%
    sed '/^%%/ s/old/new/g' in.txt
  • Remplace sur chaque ligne du début de la ligne au signe '=' par 'new'
    sed -e '1,$ s/^.*=/new/' in.txt
  • Supprimer la ligne contenant 'toto' entre 'titi' et 'tutu'
    sed -e '/titi/,/tutu/ {/toto/d}' in.txt
  • Capture entre 'toto' et 'tata' (attention si plusieurs occurrences du pattern)
    sed -n '/toto/,/tata/p' in.txt
    sed -e '/toto/,/tata/ !{/./d}' in.txt
    sed -e '/toto/,/tata/ \!{/./d}' in.txt
    perl -e "while(<>) {print if/toto/.../tata/}" in.txt
    awk "/toto/,/tata/" in.txt
  • Supprimer entre 'pattern1' et 'pattern2' (les patterns inclus)
    sed -e '/pattern1/,/pattern2/d' in.txt
  • Supprimer d'un debut de fichier a un pattern
    sed -e '1,/pattern/d' in.txt
  • Supprimer d'un pattern a la fin d'un fichier
    sed -e '/pattern/,$d' in.txt
  • Substitution entre 2 patterns
    sed '/titi/,/tata/ s/toto/zz/g' in.txt
  • Definir un pattern sur lequel la substitution ne se fera pas
    sed '/toto/!s/t/z/g' in.txt
  • Printer entre 'titi' et 'tutu'
    sed -n '/titi/{:a;N;/tutu/!ba;p;}' in.txt
  • Capture de 'titi' a 'tutu' de la ligne 3 a 10
    sed -n '3,10{/titi/,/tutu/p}' in.txt
  • Supprimer une ligne contenant un pattern + les 2 lignes suivantes
    sed '/pattern/,+2d' in.txt
  • Supprimer de la ligne 3 a la ligne contenant 'pattern'
    sed -e '3,/pattern/d' in.txt
  • Printer d'une ligne contenant 1 pattern jusqu'a la fin
    sed -n '/pattern/,$p' in.txt
    sed -n '/pattern/,EOF' in.txt
  • Si le pattern est une variable
    sed -n '/'$var'/p' in.txt
  • Ne pas selectionner les lignes contenant un pattern
    grep -v "pattern" in.txt
    awk '!/pattern/' in.txt
    sed '/pattern/d' in.txt
    sed -n '/pattern/!p' in.txt
    awk '$0 ~ /pattern/ {next} {print}' in.txt
  • A un pattern inserer une ligne
    sed -e '/pattern/ i\ligne ecrite avant le pattern' in.txt ............ (option 'i' : avant le pattern)
    sed -e '/pattern/ a\ligne ecrite apres le pattern' in.txt ............ (option 'a' : apres le pattern)
  • A un pattern inserer une ligne blanche
    sed -e '/pattern/ i\ ' in.txt ............ (option 'i' : avant le pattern)
    sed -e '/pattern/ a\ ' in.txt ............ (option 'a' : apres le pattern)
  • print 2 lignes après un pattern ( dans la colonne 1 )
    awk '/^pattern/ {c=2; next} c-->0' in.txt
    awk 'BEGIN {counter=0}; $1=="pattern" {counter=2; next}; counter>0 {counter--; print}' in.txt
  • print le pattern + 2 lignes après (After)
    grep -A2 "pattern" in.txt
    sed -n '/pattern/ {N;N;p;}' in.txt
  • delete le pattern + 2 lignes après
    sed '/pattern/ {N;N;d;}' in.txt
  • print le pattern + 2 lignes avant (Before)
    grep -B2 "pattern" in.txt
  • Sélectionner tous les caractères (sans afficher les lignes blanches)
    grep "." in.txt
    awk "/./" in.txt
    sed -n '/./ {p;d}' in.txt
  • Combiner motif et ligne
    sed '8,/fin/ s/toto/titi/g' in.txt
    sed '/debut/,$ s/toto/titi/g' in.txt
  • Substituer tout un texte entre 2 motifs excluant les motifs
    sed '/titi/,/tutu/{/titi/b;/tutu/b;s/.*/SED/;}' in.txt
  • Ne pas printer les lignes contenant 'tata'
    sed '/tata/d' in.txt
    sed -n '/tata/!p' in.txt
  • Printer les lignes precedant un pattern
    sed -n '/tata/{g;1!p;};h' in.txt
  • Printer les lignes suivant un pattern
    sed -n '/tata/{n;p;}' in.txt
  • Remembering a pattern ('_' is delimiter)
    echo "a line1" | sed 's_\([a-z]\)\([ ]\)\([a-z]*\)\([0-9]\)_\1\2\3 \4_'
    (result: a line 1)

    #5-Remplacer des lignes des chiffres ou des lettres

  • Exemple d'une suite d'actions entre 2 patterns
    sed -n '4,10 {/pattern1/,/pattern2/ {s/^0./y&/;/^$/d;s/m/w/g;p}}' in.txt
  • Supprimer tous les chiffres en gardant un tiret '-' a la place
    tr -d 0-9 < in.txt
  • Supprimer toutes les lettres en gardant un tiret '-' a la place
    tr -d [a-zA-Z] < in.txt
  • Conserver les lignes contenant des chiffres
    sed -e '/[0-9]/!d' in.txt
    sed -e '/[0-9]/\!d' in.txt ........... (selon version Unix)
  • Changer un texte majuscule en minuscule
    awk '{print tolower($0)}' in.txt
    cat in.txt | tr -s A-Z a-z
  • Changer un texte minuscule en majuscule
    cat in.txt | tr -s a-z A-Z
  • Supprimer les lettres minuscules en fin de ligne
    awk '{ sub("[a-z]*$", ""); print }' in.txt
  • print le pattern sans distinguer majuscules ou minuscules
    grep -i "pattern" in.txt
  • Mettre en majuscule la 1ère lettre d'une phrase
    echo -e "texte ligne1\ntexte ligne2" | sed 's/^./\u&/'
  • Remplacer les lettres par une operande (ici: +)
    cat in.txt | tr '[:alpha:]' +
  • Remplacer les chiffres par une operande (ici: +)
    cat in.txt | tr '[:digit:]' +
  • Remplacer 1 caractere par un autre
    tr "t" "z" < in.txt
  • Suppression des sauts de lignes
    tr '\n' ' ' < in.txt
  • Supprimer la répétition de caractères
    echo "boonnjoouuur" | tr -s "onu"
  • Remplace le bloc ('t' suivi de 2 caracteres) par zorro en ligne 4
    sed -e '4s/t../zorro/g' in.txt
  • Insérer 1 caractère (1 point=1 caractère)
    ( ici l'insertion de 'Q' se fera apres les 2 premiers caractères )
    echo 'abcdef' | sed 's/^../&Q/' ........... #resultat : abQcdef
  • Remplacer en debut de chaine un nombre de points par une lettre
    echo 'abcdef' | sed 's/^../Q/' ........... #resultat : Qcdef
  • Uniquement le 2eme caractere 't' est remplace par 'z' en ligne 4
    sed -e '4s/t/z/2' in.txt
    awk 'NR==4 {print gensub(/t/,"z",2)}; NR!=4 {print}' in.txt
  • Remplace 't' par 'k' , et 'o' par 'l'
    sed 'y/to/kl/' in.txt
  • Effectue le remplacement des lignes 4 a 10 et n’écrit dans 'out.txt' que celles modifiées
    sed -e '4,10 s/t/&zorro/gw out.txt' in.txt
  • Remplacer un pattern ('titi' remplace par: 'titi et tata')
    sed '/titi/ s//& et tata/g' in.txt
    sed 's/titi/titi et tata/g' in.txt
  • tr : remplacement dans un sous shell (taper: sh)
    a=abcdef; echo $a | tr f g ........... #resultat : abcdeg
    a=abcdef; echo ${a//f/g} ........... #resultat : abcdeg
    a=abcdef; echo $a | tr [ac] [xz] ........... #resultat : xbzdef
  • tr + option -d: effacement (utiliser un sous shell) (taper: sh)
    a=abcdef; echo $a | tr -d f ........... #resultat : abcde
    a=abcdef; echo ${a//f/} ........... #resultat : abcde
    a=abcdef; echo $a | tr -d [a-c] ........... #resultat : def
    a=abcdef; echo ${a//[a-c]/} ........... #resultat : def
    a=abcdef; echo $a | tr -d [ac] ........... #resultat : bdef
    a=abcdef; echo ${a//[ac]/} ........... #resultat : bdef
  • tr + option -c: inverse l'ensemble des caractères a detecter
    echo "acfdeb123" | tr -c b-d + ....... resultat: +c+d+b++++
  • Remplacer toutes les occurrences d'un caractère ou d'un pattern pour chaque ligne
    var="newpattern" ; awk '{gsub( /oldpattern/, "'"$var"'" )};1' in.txt
    var="newpattern" ; awk -v v="$var" '{gsub( /oldpattern/, v )}1' in.txt
  • Remplacer la 2eme occurrence d'un caractère ou d'un pattern pour chaque ligne
    awk '{print gensub(/old/, "new", 2) }' in.txt
  • Remplacer 'o' par 'zorro' sauf pour le pattern 'toto' ,
    sed -e '/toto/!s/o/zorro/' in.txt
  • Supprimer les 3 derniers caractères de la dernière ligne uniquement
    expr "$(cat in.txt)" : "\(.*\)...$"
  • Supprimer les 3 derniers caractères de chaque ligne
    awk 'sub( "...$", "" )' in.txt
  • Printer les 5 premiers caractères de la premiere ligne
    echo `cat in.txt`| cut -c1-5
    echo `expr "$(cat in.txt)" : '\(.....\)'`
  • Printer les 5 premiers caractères de toutes les lignes d'un fichier
    cat in.txt | cut -c1-5
    while read line;do echo ${line::5};done < in.txt
    while read line ; do echo $line | cut -c1-5 ; done < in.txt
  • Printer les 5 derniers caracteres de toutes les lignes d'un fichier
    while read line;do echo ${line: -5};done < in.txt
    sed 's/^.*\(.....\)$/\1/' in.txt
    sed 's/\(.*\)\(.\{5\}\)/\2/' in.txt
  • Substituer toto ou titi par tata
    sed 's/toto\|titi/tata/g' in.txt

    #6-Supprimer des lignes blanches ,espaces ,tabulations

  • Supprimer les lignes blanches (l'option '-i' reecrit directement dans le fichier)
    sed '/./!d' in.txt
    sed -i '/^$/d' in.txt ........... (l'option '-i' est a manier avec precaution)
  • Supprimer les lignes blanches repetees sauf la 1ere
    cat -s in.txt
  • Supprimer uniquement les lignes blanches du debut du fichier
    sed '/./,$!d' in.txt
  • Supprimer tout ce qui suit la 1ere ligne blanche
    sed '/^$/q' in.txt
  • Supprimer tout ce qui precede la 1ere ligne blanche
    sed '1,/^$/d' in.txt
  • Supprimer les lignes blanches entre 'tata' et 'route'
    sed -e '/tata/,/route/ {/^$/d}' in.txt
  • Remplacer 2 blancs (ou +) par 1 seul blanc
    sed 's/\ \ */\ /g' in.txt
  • Suppression des espaces et tabulations en debut et fin de ligne
    sed 's/^[ \t]*//;s/[ \t]*$//' in.txt
  • Suppression des lignes vides
    grep -v '^$' in.txt
    grep '.' in.txt
    sed -n '/^$/!p' in.txt
    awk NF in.txt
    awk '/./' in.txt
    sed '/^$/d' in.txt
    sed '/./!d' in.txt
    awk '/^$/ {next} {print}' in.txt
  • tr + option squeeze-repeats: efface tout sauf la première
    occurence d'une chaîne de caractères
    (utile pour supprimer plusieurs espaces blancs)
    echo "XXXXX" | tr --squeeze-repeats 'X' ....... resultat: X
  • Supprime tous les espaces au début de toutes les lignes
    sed 's/^ *//g' in.txt
  • Supprime tous les espaces à la fin de toutes les lignes
    sed 's/ *$//g' in.txt
  • Supprimer seulement la première ligne de chaque ensemble de lignes vides consecutives
    sed '/[0-9A-Za-z]/,/^$/{/^$/d}' in.txt
  • to join lines ( en deletant les lignes blanches )
    sed -e '/./!d' -e '$!N;s/\n/ /' in.txt
    sed -e '/./\!d' -e '$\!N;s/\n/ /' in.txt
    grep "." in.txt | sed '$\!N;s/\n/ /'
  • to join lines ( en gardant les lignes blanches )
    sed -e '/./!b' -e '$!N;s/\n/ /' in.txt
    sed -e '/./\!b' -e '$\!N;s/\n/ /' in.txt
    grep "." in.txt | sed '$\!N;s/\n/ /' | sed G

    #7-Inserer

  • Insérer une ligne blanche après chaque ligne
    sed G in.txt
    sed 'a\ ' in.txt
  • Insérer une ligne de tirets toutes les 2 lignes
    sed 'n;a\----------' in.txt
  • Insérer une ligne blanche toutes les 3 lignes
    sed 'n;n;G;' in.txt
  • Insérer une ligne blanche après chaque ligne sauf après la ligne 3
    sed '3!G' in.txt
  • Insérer une ligne au début, à la 3eme ligne et à la fin du fichier
    sed -e '1i \debut\ du\ traitement' in.txt
    sed -e '3i \ajout\ a\ la\ 3eme\ ligne' in.txt
    awk 'NR == 3 {print "line3"}1' in.txt
    sed -e '$a \fin\ du\ traitement' in.txt
  • Insérer une ligne à un pattern
    sed -e '/pattern/ i\ligne ecrite avant le pattern' in.txt ............ (option 'i' : avant le pattern)
    sed -e '/pattern/ a\ligne ecrite apres le pattern' in.txt ............ (option 'a' : apres le pattern)
  • Insérer une ligne blanche à un pattern
    sed -e '/pattern/ i\ ' in.txt ............ (option 'i' : avant le pattern)
    sed -e '/pattern/ a\ ' in.txt ............ (option 'a' : apres le pattern)
  • Changer la ligne si elle contient un pattern
    sed -e '/pattern/ c\new line' in.txt
  • Inserer **DELETED** et supprimer les lignes entre 2 patterns
    sed '/pattern1/,/pattern2/ c\**DELETED**' in.txt
  • Insérer la ligne 'line before' avant chaque ligne du fichier
    sed -e 'i\line before' in.txt
  • Insérer du texte avant une ligne matchée par un pattern
    sed -e '/pattern/ i\line before pattern' in.txt
  • Insérer une ligne blanche avant une ligne matchée par un pattern
    sed '/tata/{x;p;x}' in.txt
    sed -e '/pattern/ i\ ' in.txt
  • Insérer une ligne blanche après une ligne matchée par un pattern
    sed '/tata/G' in.txt
    sed -e '/pattern/ a\ ' in.txt
  • Insérer une ligne blanche avant et après une ligne matchée par un pattern
    sed '/tata/{x;p;x;G}' in.txt
  • Insérer un fichier 'temp.txt'
    sed '1r temp.txt' < in.txt ..........après la 1ère ligne de 'in.txt'
    sed '/pattern/ r temp.txt' < in.txt .........apres le pattern
  • Insérer un 'blanc' devant toutes les lignes
    sed -e 's/^./ &/g' in.txt
    sed '{s_^_ _}' in.txt
  • Insérer un 'blanc' à toutes les fins de lignes
    sed -e 's/.$/& /g' in.txt
  • Insérer un 'blanc' après tous les 't' (a droite) en ligne 4
    sed -e '4s/t/& /g' in.txt
    sed -e '4\!s/t/& /g' in.txt ........... #syntaxe inverse
  • Insérer au 5ème caractère après 3 caractères le signe # sur la ligne 2
    sed -r "2 ~ s/^(.{4})(.{3})/\2#/" in.txt

    #8-divers

  • Retirer les accents d'un texte
    cat non-ascii.txt | iconv -f utf8 -t ascii//TRANSLIT//IGNORE > ascii.txt
  • Printer les lignes d'un fichier2 qui ne sont pas dans le fichier1
    comm -23 file2.txt file1.txt 2>dev
    grep -vxFf file1.txt file2.txt
  • Printer un fichier
    cat in.txt
    sed '' in.txt
    sed ':' in.txt
  • Dupliquer toutes les lignes
    sed 'p' in.txt
  • printer 3 fois chaque ligne
    sed '{h;p;p}' in.txt
    while read line;do for i in `seq 1 3`;do echo $line;done;done < in.txt
  • Inverser l'ordre d'un fichier
    tac in.txt
    sed -n '1!G;h;$p' in.txt
    awk '{ a[i++]=$0 } END { for (j=i-1; j>=0; ) print a[j--] }' in.txt
  • Ecrire 1 mot par ligne (pour 5 mots: -n5)
    cat in.txt | xargs -n1
    awk '{i=1; while (i<=NF){print $i, " ";i++}}' in.txt
  • Ecrire un caractère par ligne
    while read line; do echo -n "$line" | dd cbs=1 conv=unblock 2>/dev/null; done < in.txt
  • Ecrire un fichier sur une ligne
    sed '{:a;$!N;s_\n_ _;ta}' in.txt
  • Joindre les lignes paires a la suite des lignes impaires
    sed '$!N; s/\n/ /g' in.txt
  • Transforme les lignes en colonnes
    awk '{printf "ligne%d: %s ",NR,$0>"z-cible"}' z-source
  • Ajouter en prefixe le nombre d'occurences des mots et trier
    cat in.txt | xargs -n1 | sort | uniq -c | sort -nr
  • Print les 10 premiers (ou derniers) caracteres d'un fichier
    head -10c in.txt ........... #les 10 premiers
    tail -10c in.txt ........... #les 10 derniers
  • Decoupe en n caracteres le fichier 'in.txt' (ici n=10)
    creation de fichiers: prefixe_outaa (outab..outac...)
    split -b 10 in.txt prefixe_out
  • Decoupe en n lignes le fichier 'in.txt' (ici n=5)
    creation de fichiers: prefixe_outaa (outab..outac...)
    split -l 5 in.txt prefix_out
    awk '{print >("prefix_out" int((NR+4)/5))}' in.txt
  • Trier un fichier
    dans un ordre numerique (-n); avec separateur (-t); colonne (-k); et place du caractere (.)
    cat in.txt | sort -n -t" " -k2.4
    dans un ordre decroissant (-r) et en retirant les doubles (-u) :
    cat in.txt | sort -r -u
  • Copier un fichier
    cp old_file new_file
    sed 'w new_file' old_file
  • Definir un marqueur en fin de ligne (ici ,) qui joindra la ligne suivante
    sed '/\,$/ {N; s_\,\n_ _}' in.txt
    sed -e :a -e '/\,$/N; s_\,\n_ _; ta' in.txt
  • Si 1 ligne se termine par ',' joindre la suivante a elle
    sed -e :a -e '/,$/N ; s#\n## ; ta' in.txt
  • Si 1 ligne commence par un signe egale '=' , l'ajouter a la ligne precedente et remplacer le signe egale '=' par un espace
    sed -e :a -e '$!N;s/\n=/ /;ta' -e 'P;D' in.txt
  • "Dispach" (inverse du "regroupe")
    split en couples: ['colonne 1'-'parties[k]']
    en 'k' fois nombre de lignes
    awk '{key=$1;$1="";n=split($0, parties, "[,]");for(k=1; k<=n; k++) print ""key" "1" "parties[k] ""}' in.txt| awk '{if($2>0) print $0}' | awk '{if($1 != key){key = $1} else {$2 += cum} cum=$2; print}' > out.txt
  • "Regroupe" (inverse du "dispach")
    (tous les elements semblables de la colonne 1
    sont regroupes sur 1 seule ligne)
    awk '{key=$1; $1=$2="";f[key]=f[key] s[key] $0;s[key]=","} END {for(key in f){gsub(/[[:space:]]/,"",f[key]);printf "%s %s\n",key,f[key]}}' in.txt| sort > out.txt
  • Encadre le premier nombre de la ligne avec des ** , ne printer que ces lignes
    sed -n "s/\([0-9][0-9]*\)/**\1**/p" in.txt
  • Printer les lignes avec 3 digits consecutifs
    sed -n '/[0-9]\{3\}/p' in.txt
  • Insérer un espace entre chaque lettre
    echo -e "bonjour"|sed 's/./& /g' ................resultat: b o n j o u r
    echo -e "bonjour"|sed -r 's/([^ ])/\1 /g'
    echo -e "bonjour"|sed 's/\([^ ]\)/\1 /g'
  • dirname ............(en sous shell)
    var="/home/Bureau/1/in.txt" ....... (en sous shell)
  • dirname $var ........... ----> /home/Bureau/1
    echo ${var%/*} ........... ----> /home/Bureau/1
  • basename ....... (en sous shell)
    basename $var ........... ----> in.txt
    echo ${var##*/} ........... ----> in.txt
  • while dans un sous shell (taper: sh)
    while read line; do echo -en "$line\n"; done < in.txt
    while read line; do echo -e $line; done < in.txt
  • 'set' decoupe 1 variable en parametres positionnels dans un sous shell (taper: sh)
    string="a b:c def:g"; IFS=':'; set $string; echo "$1"
  • read ...$REPLY : equivalent de : head -1
    read -r
  • Contenu des dossiers sans les sous dossiers
    for fichier in *;do ls -al ;done
  • Contenu des dossiers avec les sous dossiers
    for fichier in *;do ls -al "$fichier";done
  • nombre de fichiers dans le repertoire courant (equivaut a: ls|wc -l)
    a=0;for i in *;do a=$(($a+1));done;echo nb=$a
  • apostrophe et guillemet
    echo -n "your name is: "; read name ........... #taper: toto
    echo 'hi $name' ........... #resultat : hi name
    echo "hi $name" ........... #resultat : hi toto
  • par defaut, le separateur est 'blanc'
    [Utiliser les parentheses () pour le sous shell]
    echo "moi et moi, lui, les autres" | (read x y ;echo $y) ........... (->lui les autres)
  • nouveau séparateur
    IFS=",";echo "moi et moi, lui, les autres" | (read x y;echo $x) ........... (->moi et moi)
  • liste des variables d'environnement
    export
  • detruire la valeur d'une variable
    (utiliser un sous shell en tapant: sh + return)
    var=7 echo $var ........... -> 7
    unset var ........... -> nothing
  • Concatenation
    (utiliser un sous shell en tapant: sh + return)
    var=debut;echo ${var}ant ........... ---->debutant
  • Commande 'set' et 'shift'
    (utiliser un sous shell en tapant: sh + return)
    c="prof eleve classe note";set $c;echo $1 $2
    ........... --->prof eleve
    c="prof eleve classe note";shift;echo $1 $2
    ........... --->eleve classe
  • Commande 'eval'
    (utiliser un sous shell en tapant: sh + return)
    message="date d'aujourd'hui?";set $message;echo $# .......#resultat: 2
    message="date d'aujourd'hui?";set $message;echo $1 .......#resultat: date
    message="date d'aujourd'hui?";set $message;eval $1 .......#resultat: dim 20 jan..
Dernière modification : Octobre 2013