En ligne

Open CPN : navigation opensource

2016-12-14T10:00:00.001+01:00

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

Page de compilation : http://opencpn.org/ocpn/compiling_source_linux

Installation des dépendances

Il s'agit d'installer les programmes nécessaire à la récupération des sources, à la compilation, au packaging et à l'installation du logiciel :

sudo apt-get install build-essential cmake gettext git-core gpsd gpsd-clients libgps-dev wx-common libwxgtk3.0-dev libglu1-mesa-dev libgtk2.0-dev wx3.0-headers libbz2-dev libtinyxml-dev libportaudio2 portaudio19-dev libcurl4-openssl-dev libexpat1-dev libcairo2-dev

Récupération des sources

La gestion des sources du projet Open CPN se fait avec l'outil "git". La commande pour récupérer les sources est la suivante :

git clone git://github.com/OpenCPN/OpenCPN.git

Compilation

Cette opération consiste à "fabriquer" le programme exécutable à partir des sources récupéré. Elle se déroule en plusieurs étape :

cd OpenCPN

mkdir build

cd build

cmake ../

make

Installation

Manuelle

L'installation manuelle permet de rendre le logiciel disponible pour les utilisateurs sans pour autant le répertorier dans les outils de gestion des logiciels du système d'exploitation. C'est rapide et pratique mais l'inconvénient de cette méthode est le défaut d'intégration qui aura entre autre pour effet de ne pas afficher le logiciel dans la liste de la logithèque.

sudo make install

Création de package

La création de package permet de construire un package du même type que ceux qu'un peut installer avec la logithèque. Cela permet de partager le paquet avec d'autre utilisateurs (sous réserve que ces derniers utilisent la même version de Linux) et d'intégrer parfaitement le logiciel dans l'outil de gestion des paquets du système d'exploitation.

sudo make package

Notes sur installation par logithèque :

Il est possible d'installer OpenCPN à partir des dépôts logicielles fournis par la communauté :

http://opencpn.org/ocpn/start_install-ubuntu-ppa

https://launchpad.net/~opencpn/+archive/ubuntu/opencpn

grep - awk - sed

2016-12-14T09:53:00.000+01:00

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

Mémo awk : comment identifier les doublons dans un fichier ?

2016-12-13T11:02:00.000+01:00

Dans l'exemple ci-dessous, le nom du fichier d'entrée est "in.txt" :

awk 'FNR==NR && a[$0]++ {b[$0] ; next} $0 in b' in.txt in.txt

Cette exemple retourne les lignes en double dans le fichier.