Les scripts BASH AWK SED

Site de reference : http://unstableme.blogspot.com

COMBINAISON DE BOUCLES WHILE ET UNTIL
  1. COMBINAISON DE BOUCLES WHILE ET UNTIL
DEFINIR DES PATTERNS QUI SERONT CAPTURES DANS DES PARAGRAPHES DELIMITES PAR START ET END
  1. Des patterns vont selectionner des lignes N dans des paragraphes (delimites par START et END) (de bas en haut)
  2. Des patterns vont selectionner des lignes N dans des paragraphes (delimites par START et END) (de haut en bas)
  3. Des patterns vont selectionner des lignes (N et N+1) dans des paragraphes (delimites par START et END) (de haut en bas)
  4. Modifier une syntaxe de patterns enregistres dans une liste - en BASH : boucle sur ses elements
GREP et syntaxes equivalentes a GREP
  1. Une commande equivalente a "grep -A1 -B1" utilise "xdpn"
  2. Une commande equivalente a "grep -v" utilise "split" et est construite automatiquement par le script
  3. Une commande equivalente a "grep -v" utilise "set" : affichage des variables
La commande SED
  1. la syntaxe print 'p' : sed -n '....p' fichier.txt
  2. Inserer un 'blanc' apres 3 caracteres (sur toutes les lignes)
  3. Deleter une fin de ligne a partir d'un pattern precis
LES LIGNES SONT DANS UN TABLEAU
  1. Le tableau permet le cumul
  2. Le tableau permet l'ordre inverse
  3. Le tableau permet de selectionner des lignes
  4. Le tableau permet de modifier des fins de lignes
  5. Le tableau permet de modifier des lignes
  6. Le tableau permet d'ajouter des digits
  7. Le tableau permet d'avoir les elements uniques d'une colonne
SYNTHAXES DE COMMANDES DANS UNE PROC
  1. Synthaxe d'une commande AWK dans une proc
SUITE D'ACTIONS COURANTES DANS UN TRAITEMENT DE TEXtE
  1. Traitement d'un texte
SYNTAXE : " if [[ `awk " pour remplacer la boucle : " while read line "
  1. La syntaxe : " if [[ `awk " est plus rapide que la boucle " while " pour capturer plusieurs patterns dans des paragraphes
CONVERSION ISO-8859-1 ET UTF-8
  1. CONVERSION ISO-8859-1 ET UTF-8
CONVERSION ASCII TO HEXADECIMAL TO ASCII
  1. Suppression d'accents (par l'hexadecimal) - script perl - (ascii -> hexa -> ascii)
  2. Suppression d'accents (par l'hexadecimal - script bash (contenant du perl et python) - (ascii -> hexa -> ascii)

haut

COMBINAISON DE BOUCLES WHILE ET UNTIL


#!/bin/bash

# but du script : cumuler a l'aide d'un compteur.
# La 1ere ligne du compteur (1001 1005) indique
# qu'il y aura cumul de la colonne 1 de 1001 a 1005.

############ parametres:

# attention retirer le "0" devant les SY (colonne 2)

# fichier depart : in.txt 

#43167743288 1001
#42873289688 1002
#43086137576 1003      #col1 : bytes
#43169846528 1004      #col2 : SY
#22802491016 1005
#43617416000 1011
#42650346248 1012
#43165640048 1013
#42811875080 1014
#43304033240 1015
#42919560968 1016
#31827073208 1017
#            ^   ajouter le digit "1" devant la colonne 2

# compteur.txt
#1001 1005
#1011 1017

IN=in.txt                   #1/3 : changer ici   
COMPTEUR=compteur.txt       #2/3 : changer ici
OUT=decoupemanuelle.txt     #3/3 : changer ici   (resultat)

########### fin des parametres

while read var1 var2
do
sum=0      # desactiver cette ligne pour le cumul de toutes les lignes
   until [ $var1 -gt $var2 ]
   do
   var3=`awk '$2 ~ '$var1' {print $1}' $IN`
   echo $var3
   ((sum+=$var3))
   let var1=var1+1
   done
echo "s= " $sum
done < $COMPTEUR > tmp1.txt

awk '/s=/ {print $2}' tmp1.txt > tmp2.txt
paste $COMPTEUR tmp2.txt > tmp3.txt
awk '{print $1"-"$2," cumul = "$3"   "$3/1024/1024/1024}' tmp3.txt > $OUT
cat $OUT

# resultat
#1001-1005  cumul = 195099508096   181,701
#1011-1017  cumul = 290295944792   270,359

haut

Des patterns vont selectionner des lignes N dans des paragraphes (delimites par START et END) (de bas en haut)


#!/bin/bash

#################### parametres

IN=in.txt

INTER=startnb-from-end.txt
OUT=out.txt

# variables du debut et fin de la boucle 
START=#
END=%%%%%    # le script part du bas (END) et remonte ligne par ligne) 

# variables qui vont selectionner les lignes de IN
PATTERN1=[1-9]\.
PATTERN2=@ 

###########  fin des parametres

############  IN

# arise

@ intransitive verb  
1.	 [appear, happen]     survenir,   se presenter 
 a doubt arose in his mind   un doute est apparu dans son esprit
2.	 [result]   resulter 
 a problem that arises from this decision   un probleme qui resulte OR decoule de cette decision 
3.	 (literary) [person]     se lever 
[sun]     se lever, paraitre
%%%%%

# assume

@ transitive verb  
1.	 [presume]     supposer,   presumer 
 let's assume that to be the case   mettons OR supposons que ce soit le cas 
2.	 [undertake]     assumer,   endosser 
 he assumed management of the firm   il a pris la direction de l'entreprise
3.	 [usurp  power]     prendre
4.	 [adopt]     prendre 
 she assumed a look of indifference   elle affectait un air d'indifference 
%%%%%

##################   fin de IN

rm $OUT   2>/dev/null

# capture des numeros de lignes des END
awk '$0 ~ /'$END'/ {print NR,$0}' $IN > $INTER

# nb lignes de INTER
nblines=`grep "." $INTER | wc -l`
echo "nb de END : $END : " $nblines
sleep 3

# recherche par le bas
countline=1
until [ $countline -gt $nblines ]
do

   for i in `awk '{print $1}' $INTER | sed -n ''$countline'p'`  # $i prend les numeros de lignes des END
   do
   echo "ligne de fin : " $END "(de " $INTER " ) : " $countline "/" $nblines  "  -  ligne nb de : " $IN " : " $i  
   
       counter=1
       until [ $counter -gt $i ]  # compteur de 1 a $i
       do
       # avec l'aide du compteur, part de END et remonte vers le haut jusqu'au PATTERN
       if [[ `awk 'NR == '$i-$counter' {print}' $IN` =~ $PATTERN1 ]] ; then echo `awk 'NR == '$i-$counter' {print $0}' $IN` ; fi
        
       if [[ `awk 'NR == '$i-$counter' {print}' $IN` =~ $PATTERN2 ]] ; then echo `awk 'NR == '$i-$counter' {print $0}' $IN` ; fi
        
       # inserer ici 1 autre 'if'      
        
       if [[ `awk 'NR == '$i-$counter' {print}' $IN` =~ $START ]] ; then echo `awk 'NR == '$i-$counter' {print $0}' $IN` ; echo "----------------" ; break ; fi
        
       let counter+=1
       # sleep 1   
       done  # >> $OUT # du decompte
        
   done  # lecture des numeros de lignes des END 

let countline=countline+1  
done  # compteur des lignes du fichier des END (incremente de 1)

# resultat :

nb de END : %%%%% :  2
ligne de fin :  %%%%% (de  startnb-from-end.txt  ) :  1 / 2   -  ligne nb de :  in.txt  :  10
3. (literary) [person] se lever
2. [result] resulter
1. [appear, happen] survenir, se presenter
@ intransitive verb
# arise
----------------
ligne de fin :  %%%%% (de  startnb-from-end.txt  ) :  2 / 2   -  ligne nb de :  in.txt  :  22
4. [adopt] prendre
3. [usurp power] prendre
2. [undertake] assumer, endosser
1. [presume] supposer, presumer
@ transitive verb
# assume
----------------

haut

Des patterns vont selectionner des lignes N dans des paragraphes (delimites par START et END) (de haut en bas)


#!/bin/bash

###########  parametres

IN=in.txt

INTER=startnb-from-start.txt
OUT=out.txt

START=#      
END=%%%%%     

PATTERN1=[1-9]\.
PATTERN2=@ 

# si ajout d'1 autre pattern : inserer 1 'elif' 

###########  fin des parametres

#############  IN

# arise

@ intransitive verb  
1.	 [appear, happen]     survenir,   se presenter 
 a doubt arose in his mind   un doute est apparu dans son esprit
2.	 [result]   resulter 
 a problem that arises from this decision   un probleme qui resulte OR decoule de cette decision 
3.	 (literary) [person]     se lever 
[sun]     se lever, paraitre
%%%%%

# assume

@ transitive verb  
1.	 [presume]     supposer,   presumer 
 let's assume that to be the case   mettons OR supposons que ce soit le cas 
2.	 [undertake]     assumer,   endosser 
 he assumed management of the firm   il a pris la direction de l'entreprise
3.	 [usurp  power]     prendre
4.	 [adopt]     prendre 
 she assumed a look of indifference   elle affectait un air d'indifference 
%%%%%

###############  fin de IN

rm $OUT   2>/dev/null

# capture des numeros de lignes START
awk '$0 ~ /'$START'/ {print NR,$0}' $IN > $INTER

# nb lignes du fichier des START
NBLINESTART=`grep "." $INTER | wc -l`
echo "nb d'occurrences du pattern : $START : " $NBLINESTART

# nb lignes de IN
NBLINEIN=`cat $IN | wc -l`
echo "nb lignes ds $IN : " $NBLINEIN
sleep 3

# recherche du haut en bas
countline=1
until [ $countline -gt $NBLINESTART ]     # compteur de lignes de START
do

   for i in `awk '{print $1}' $INTER | sed -n ''$countline'p'`  # capture du numero de ligne START dans IN
   do
   echo `awk 'NR == '$countline' {print "_  "substr($0,3,25)}' $INTER` " : " $countline "/" $NBLINESTART
        counter=$i   
        until [ $counter -gt $NBLINEIN ]   # compteur de 1 a ~ 44860
        do        
        if [[ `awk 'NR == '$counter' {print}' $IN` =~ $PATTERN1 ]] ; then echo `awk 'NR == '$counter' {print $0}' $IN`
        
        elif [[ `awk 'NR == '$counter' {print}' $IN` =~ $PATTERN2 ]] ; then echo `awk 'NR == '$counter' {print $0}' $IN`
        
# inserer ici 1 autre pattern        
        
        elif [[ `awk 'NR == '$counter' {print}' $IN` =~ $END ]] ; then  echo "----------------" ; break ; fi

        let counter+=1
        done   # >> $OUT   # compteur de lignes de IN
        
   done  # capture du numero de ligne START dans IN

let countline=countline+1  
done  # compteur de lignes de START  # incremente de 1

# resultat :

nb d'occurrences du pattern : # :  2
nb lignes ds in.txt :  23
_ # arise  :  1 / 2
@ intransitive verb
1. [appear, happen] survenir, se presenter
2. [result] resulter
3. (literary) [person] se lever
----------------
_ # assume  :  2 / 2
@ transitive verb
1. [presume] supposer, presumer
2. [undertake] assumer, endosser
3. [usurp power] prendre
4. [adopt] prendre
----------------

haut

Des patterns vont selectionner des lignes (N et N+1) dans des paragraphes (delimites par START et END) (de haut en bas)


#!/bin/bash
###################  parametres

IN=in.txt   # marquer a l'avance les START et END

INTER=search-a.b.txt

OUT=out.txt

START=\#      # ne pas changer 
END=%%%%%    # ne pas changer 

PATTERN1=^@ 
PATTERN2=^[\ ][a-zA-Z]
PATTERN3=^[a-h]

##################### fin des parametres

# IN
# engage

@ engage
transitive verb  
1.	 [occupy, involve] 
 to engage somebody in conversation 
a. [talk to]   discuter avec quelqu'un 
b. [begin talking to]   engager la conversation avec quelqu'un
2.	 (formal) [employ - staff]     engager
[ - lawyer]   engager les services de
3.	 (formal) [attract, draw - interest, attention]     attirer
[ - sympathy]     susciter
4.	 cars & technology     engager 
 to engage the clutch   embrayer

%%%%%
# free

@ free
adjective
1.	 [unconfined, unrestricted - person, animal, passage, way]   libre 
 the hostage managed to get free   l'otage a reussi a se liberer 
 to set free 
a. [prisoner, animal]   remettre en liberte 
b. [slave]   affranchir 
c. [hostage]   liberer 
 you are free to leave   vous etes libre de partir 
 you are free to refuse   libre a vous de refuser 
2.	 [unattached]   libre, sans attaches 
 grab the free end of the rope   attrape le bout libre de la corde

%%%%%

###########################

# capture des numeros de lignes START
awk '$0 ~ /'$START'/ {print NR,$0}' $IN > $INTER

# nb lignes du fichier des START
NBLINESTART=`grep "." $INTER | wc -l`
echo "nb d'occurrences du pattern : $START : " $NBLINESTART

# nb lignes de IN
NBLINEIN=`cat $IN | wc -l`
echo "nb lignes ds $IN : " $NBLINEIN
sleep 3

##########################"
countline=1
until [ $countline -gt $NBLINESTART ]
do

   for i in `awk '{print $1}' $INTER | sed -n ''$countline'p'`  # occurrences du pattern
   do
   echo `awk 'NR == '$countline' {print NR"_ line nb : "$0}' $INTER` " : " $countline "/" $NBLINESTART

        counter=$i   
        until [ $counter -gt $NBLINEIN ]   # compteur de 1 a ~ 44860
        do        

        counter2=`expr $counter + 1`

        if [[ `awk 'NR == '$counter' {print}' $IN` =~ $PATTERN1 ]] ; then echo "`awk 'NR == '$counter' {print $0}' $IN`" ;fi    
         
        if [[ `awk 'NR == '$counter' {print}' $IN` =~ $PATTERN2 ]] ; then echo "`awk 'NR == '$counter' {print $0}' $IN`" ;fi
        
        if [[ `awk 'NR == '$counter2' {print}' $IN` =~ $PATTERN3 ]] ; then  echo "`awk 'NR == '$counter2' {print $0}' $IN`" ;fi
   
        # inserer ici 1 autre pattern        
        
        if [[ `awk 'NR == '$counter' {print}' $IN` =~ $END ]] ; then  echo "______________________________" ; echo ; break ; fi

        let counter+=1
        done  # >> $OUT  

   done  # lecture des occurrences du pattern  

let countline=countline+1  
done  # compteur des occurrences du pattern

# resultat

1_ line nb : 1 # engage  :  1 / 2
@ engage
 to engage somebody in conversation 
a. [talk to]   discuter avec quelqu'un 
b. [begin talking to]   engager la conversation avec quelqu'un
 to engage the clutch   embrayer
____________________________________________

2_ line nb : 17 # free  :  2 / 2
@ free
adjective
 the hostage managed to get free   l'otage a reussi a se liberer 
 to set free 
a. [prisoner, animal]   remettre en liberte 
b. [slave]   affranchir 
c. [hostage]   liberer 
 you are free to leave   vous etes libre de partir 
 you are free to refuse   libre a vous de refuser 
 grab the free end of the rope   attrape le bout libre de la corde
____________________________________________

haut

Modifier une syntaxe de patterns enregistres dans une liste - en BASH : boucle sur ses elements


#!/bin/bash

############### parametres

IN=in.txt
IN2=in2.txt
IN3=in3.txt
IN4=in4.txt

PATTERNS=patterns.txt
PATTERNS2=patterns2.txt
PATTERNS3=patterns3.txt

################ fin des parametres
# IN
@ arise
intransitive verb  
1.	 [appear, happen]     survenir,   se presenter 
 a doubt arose in his mind
 if the need arises   en cas de besoin 
 if the occasion arises
2.	 [result]   resulter 
 a problem that arises from this decision   un probleme qui resulte OR decoule de cette decision 
 matters arising from the last meeting
3.	 (literary) [person]     se lever 
[sun]     se lever, paraitre
STOP

##############################

# but du script : selectionner les lignes debutant par un espace, sans contenir 3 espaces
# formant ainsi une liste de patterns : PATTERNS
# appliquer ensuite un changement de syntaxe : mettre 2 espaces devant ces lignes
# PATTERNS
 a doubt arose in his mind
 if the occasion arises
 matters arising from the last meeting

##################
rm $PATTERNS2   2>/dev/null

# nb lignes de $IN
NBLINEIN=`sed -n -e '$=' $IN`
echo "nb lignes ds $IN : " $NBLINEIN

# connaitre les lignes debutant par 1 espace , et ne contenant pas 3 espaces
awk '$0 ~ /^ / {print}' $IN | grep -v "^  " |  grep -v "   " > $PATTERNS

# retirer l'espace du debut
sed 's/^ //g' $PATTERNS > $PATTERNS2

# nb lignes de $PATTERNS2
NBLINE=`cat $PATTERNS2 | wc -l`
echo "nb lignes ds $PATTERNS2 : " $NBLINE
sleep 2

###############  script

j=1
until [ $j -gt $NBLINEIN ]   
do

  # cas ou la ligne est un pattern de la liste ( e memorise le pattern mais doit rester ds la boucle )
     while read line
     do
     awk '(NR == '$j' && $0 ~ /'"$line"'/) {e=$0 ; f=" "$0 ; print e"@@"f}' $IN   
     done < $PATTERNS2
     
let j=j+1   
done > $PATTERNS3

###############  fin du script

# habillage
# coller
awk -F"@@" 'NR==FNR { f[$1] = $2 ; next } { print $0"@@"f[$0] ; next }1' $PATTERNS3 $IN > $IN2

# retirer le @@ des fins de lignes
sed 's/@@$//g' $IN2 > $IN3

# retirer tout ce qui est avant @@
sed 's_\(.*\)\(@@\)\(.*\)_\3_' $IN3 > $IN4

# resultat
@ arise
intransitive verb  
1.	 [appear, happen]     survenir,   se presenter 
  a doubt arose in his mind
 if the need arises   en cas de besoin 
  if the occasion arises
2.	 [result]   resulter 
 a problem that arises from this decision   un probleme qui resulte OR decoule de cette decision 
  matters arising from the last meeting
3.	 (literary) [person]     se lever 
[sun]     se lever, paraitre
STOP

haut

Une commande equivalente a "grep -A1 -B1" utilise "xdpn"


# etude de xdpn
# equivalent de : grep -A1 -B1

# in.txt
data1
data2
pattern1
data3
data4
pattern2
data5
data6

# attention de bien observer la syntaxe
# 1_ /pattern/! : on selectionne tout sauf "pattern" et on delete
# s'il n'y avait pas "-n" serait affiche : pattern1 et pattern2 (echo de l'espace annexe)

# x : on place la ligne dans la mmoire annexe (en fait on change le contenu)
# d : on efface l'espace de travail

# 2_ /pattern/ : on selectionne "pattern"
# du fait que les patterns sont ds espace annexe
# quand on selectionne les patterns (place vide) s'affiche la ligne du dessus
# un 2eme "x" suivi de "p" pour afficher l'espace annexe opere avec "/pattern/!"
#                            pattern1 et pattern2 (echo de l'espace annexe)
# ensuite "n" suivi de "p" affiche la ligne qui suit  "pattern1 et pattern2"
# un dernier "x" pour replacer tout dans la memoire annexe 

word=pattern

sed -n '/'$word'/! {
x       
d       
} 

/'$word'/ {
x
p
x
p

n
p
x
}
' in.txt

# resultat
data2
pattern1
data3
data4
pattern2
data5

haut

Une commande equivalente a "grep -v" utilise "split" et est construite automatiquement par le script


# in.txt                                      
the workplace where we carry out our professional activities 
it is a melting pot in which we join our energies
the purpose of the company is to offer an harmonious context
strategically situated in a booming business quarter
that will allow us to efficiently adapt to the evolving needs
up and above its functional aspect , the building embodies the values of excellence
in a multicultural context, the building reflects our unity

# except.txt   # patterns qui vont deleter les lignes
company
building

#!/bin/bash

# le but du script est de deleter les lignes contenant des patterns (equivalent a "grep -v" pour plusieurs patterns)

#################  parametres
count=1
LISTE=except.txt
START=in.txt
RESULT=out.txt    # fichier du resultat
#################  fin des parametres

# deleter les anciens resultats
rm part2.txt   2>/dev/null

# nb lignes sans les lignes vides
nbline=`grep "." $LISTE | wc -l`
echo $nbline

# boucle sur le nb lignes
until [ "$count" -gt $nbline ]
do
   echo $count > echocount.txt   
   acount=`awk 'NR=='$count' {split( $0, d, " " ) ; print d[1]}' $LISTE`  

   #creation de la syntaxe equivalente a "grep -v"
   echo "awk 'FNR==NR &&" > part1.txt
   echo "a[\$0]=/$acount/ ||" >> part2.txt ; sed -e '$ s/||//g' part2.txt > part2b.txt    
   echo "{b[\$0] ; next} !(\$0 in b)' \$START" > part3.txt
   cat part1.txt part2b.txt part3.txt > action.txt
   ACTION=`cat action.txt`
   eval `echo $ACTION` > $RESULT
let count=count+1
done

# resultat
the workplace where we carry out our professional activities 
it a melting pot in which we join our energies
strategically situated in a booming business quarter
that will allow us to efficiently adapt to the evolving needs

haut

Une commande equivalente a "grep -v" utilise "set" : affichage des variables


# in.txt                                      
the workplace where we carry out our professional activities 
it is a melting pot in which we join our energies
the purpose of the company is to offer an harmonious context
strategically situated in a booming business quarter
that will allow us to efficiently adapt to the evolving needs
up and above its functional aspect , the building embodies the values of excellence
in a multicultural context, the building reflects our unity

# except.txt   # patterns qui vont deleter les lignes
company
building

#!/bin/bash

# le but du script est de deleter les lignes contenant des patterns (equivalent a "grep -v" pour plusieurs patterns)

#################  parametres
count=1
LISTE=except.txt
START=in.txt
RESULT=out.txt    # fichier du resultat
#################  fin des parametres

# deleter auciens resultats
rm part2.txt   2>/dev/null

# nb lignes sans les lignes vides
nbline=`grep "." $LISTE | wc -l`
echo $nbline

# initialiser les variables
variables=`cat except.txt`
set -- $variables

# nombre de mots dans le fichier: variable speciale $#
for i in `seq 1 $#`
do
t=`echo var$i="\$"{$i} "; echo \$"var$i`
echo $t
done > tmp.txt

# creation des variables
while read line ; do eval $line ; done < tmp.txt 

until [ "$count" -gt $nbline ]
do
   echo "awk 'FNR==NR &&" > part1.txt
   echo "a[\$0]=/'\$var$count'/ ||" >> part2.txt ; sed -e '$ s/||//g' part2.txt > part2b.txt    
   echo "{b[\$0] ; next} !(\$0 in b)' \$START" > part3.txt
   cat part1.txt part2b.txt part3.txt > action.txt
   ACTION=`cat action.txt`
   eval `echo $ACTION` > $OUT
let count=count+1
done

# resultat
the workplace where we carry out our professional activities 
it is a melting pot in which we join our energies
strategically situated in a booming business quarter
that will allow us to efficiently adapt to the evolving needs

haut

la syntaxe print 'p' : sed -n '....p' fichier.txt


# in.txt
line1 data
line2 data2 test sed command
line3 513
line4 data4
line5

# print la ligne 2  :

sed -n '2p' in.txt

# resultat : 
line2 data2 test sed command
#-----------------------

# print de la ligne 2 a 4  : 
 
sed -n '2,4p' in.txt

# resultat : 
line2 data2 test sed command
line3 513
line4 data4
#-----------------------

# print la 1ere et derniere ligne :  

sed -n '1p ; $p' in.txt

# resultat :
line1 data
line5
#-----------------------
 
# print si la ligne a au moins 6 caracteres :  

sed -n '/^.\{6\}/p' in.txt

# resultat :
line1 data
line2 data2 test sed command
line4 data4
#-----------------------

# print un pattern :  

sed -n '/data/p' in.txt

# resultat :
line1 data
line2 data2 test sed command
line4 data4
#-----------------------

# print entre 2 patterns :  

sed -n '/data2/,/data4/p' in.txt

# resultat :
line2 data2 test sed command
line3 513
line4 data4
#-----------------------

# print un pattern mis en variable :
 
var=sed
sed -n '/'$var'/p' in.txt

# resultat :
line2 data2 test sed command
#-----------------------

# ne pas printer un pattern :  

sed -n '/data/!p' in.txt

# resultat :
line3 513
line5
#-----------------------

# print 3 digits numeriques consecutifs :  

sed -n '/[0-9]\{3\}/p' in.txt

# resultat
line3 513
#-----------------------

# print le nombre minimum de champs des lignes d'un fichier : 
 
awk '{print NF}' in.txt | sort -n | sed -n '1p'
 
# resultat
1
#-----------------------

# print le nombre maximum de champs des lignes d'un fichier :  

awk '{print NF}' in.txt | sort -n | sed -n '$p'

# resultat
5

haut

Inserer un 'blanc' apres 3 caracteres (sur toutes les lignes)


# in.txt
123456789
23456789
3456789

pos=3

while read line
do
echo $line | sed 's/^.\{'$pos'\}/& /1'
done < in.txt

# resultat : 
123 456789
234 56789
345 6789

haut

Deleter une fin de ligne a partir d'un pattern precis


# in.txt                                      
line1 pattern 1 cancelled
line2 2
line3 pattern 3 cancelled
line4 4

sed 's/pattern.*//g' in.txt

# resultat
line1 
line2 2
line3 
line4 4

haut

Le tableau permet le cumul


# in.txt                                      
line1 1
line2 2
line3 3
line4 4

awk '{arr[NR] = $2 ; sum+= $2}      # oubien :  {arr[NR] = $0 " " sum+= $2}
END {
for (i = 1 ; i<= NR ; i++)
printf "%s(%2.2f %)\n" , arr[i],(100 * arr[i])/sum
}' FS=" " in.txt

# resultat
1(10.00 %)
2(10.00 %)
3(10.00 %)
4(10.00 %)

haut

Le tableau permet l'ordre inverse


Noter que ce qui suit peut etre obtenu plus rapidement avec : tac in.txt

# in.txt                                      
line1 1
line2 2
line3 3
line4 4

awk '{ arr[NR]=$0 }
END {
for (i=NR; i>=1; i--)
print arr[i]
}' in.txt

# resultat
line4 4
line3 3
line2 2
line1 1

haut

Le tableau permet de selectionner des lignes


# voici une liste de magasins (de marque 1, 2 ou 3) avec leur nombre de parkings dans quelques villes
# le but est de selectionner la ville qui n'a que le magasin1 et plus de 5 parkings

# in.txt   (colonne 1 : ville /// colonne 2 : magasin /// colonne 3 : nombre de parkings)
marseille   marque1   7
marseille   marque2   10
marseille   marque3   3

lyon        marque1   2
lyon        marque3   9

rennes      marque1   3

bordeaux    marque2   4

strasbourg  marque1   8

#!/bin/bash
######    parametres

parking="5"

######    fin des parametres

# cas ou on s'interesse uniquement au magasin  marque[$1]

awk '
# creer le tableau  marque1[$1]  
# (on ne peut ecrire ici la synthaxe  delete marque1[$1]
# puisque le tableau  marque1[$1]  nest pas encore cree)
$3 > '$parking' && $2 == "marque1" && !($1 in marque2) && !($1 in marque3) {marque1[$1]}

# si la ville possede marque2 , retirer la ville de marque1
$3 > '$parking' && $2 == "marque2" {marque2[$1] ; delete marque1[$1]}

# si la ville possede marque3 , retirer la ville de marque1
$3 > '$parking' && $2 == "marque3" {marque3[$1] ; delete marque1[$1]}

END {
for (ville in marque1) print "la ville qui n a que la marque1 et plus de 5 parkings est : " ville
}
' in.txt

# resultat
la ville qui n a que la marque1 et plus de 5 parkings est : strasbourg

haut

Le tableau permet de modifier des fins de lignes


# in.txt                                      
H0104 STREAMER DETAILS          MAL PORT STREAMER            1       0
H0105 OTHER DETAILS             OEX Outer STBD TAILBUOY      1           0
R 283 487217.26818026.9     284 487229.76818026.3     285 487242.26818025.6    9
R 286 487254.66818025.0     287 487267.16818024.3     288 487279.66818023.7    9
R   1 483732.86818401.6       2 483745.26818400.0       3 483757.66818398.4    0
R   4 483770.06818396.8       5 483782.46818395.3       6 483794.86818393.9    0

awk '{ f[NR]=$0 }
END {
for (i=1; i<=NR; i++)
if (length(f[i]) == 80)
{print f[i]"@"}
else
{print f[i]}
}' in.txt | sed 's/9@/9/g' | sed 's/0@/A/g'

# resultat (attention de ne pas transformer toutes les lignes se terminant par 0)
H0104 STREAMER DETAILS          MAL PORT STREAMER            1       0
H0105 OTHER DETAILS             OEX Outer STBD TAILBUOY      1           0
R 283 487217.26818026.9     284 487229.76818026.3     285 487242.26818025.6    9
R 286 487254.66818025.0     287 487267.16818024.3     288 487279.66818023.7    9
R   1 483732.86818401.6       2 483745.26818400.0       3 483757.66818398.4    A
R   4 483770.06818396.8       5 483782.46818395.3       6 483794.86818393.9    A

haut

Le tableau permet de modifier des lignes


# in.txt                                      
line1 1 data1
line2 2 data1
line3 3 data2
line4 4 data2

awk '{ f[NR]=$3 ; g[NR]=$1" "$2 }
END {
for (i=1; i<=NR; i++)
if (f[i] != f[i-1])
{print "@",f[i],g[i]}
else
{print f[i],g[i]}
}' in.txt | sed '/@/G'

# resultat
@ data1 line1 1

data1 line2 2
@ data2 line3 3

data2 line4 4

haut

Le tableau permet d'ajouter des digits


Noter que ce qui suit peut etre obtenu plus rapidement avec : seq -w 11

seq 11 | awk '{
arr[NR] = $0
arr[NR] = (length(NR)==1 ? "0"NR : NR) }
END {
for (i=1; i<=NR; i++)
{print i,arr[i]}
}' | sort -n

# resultat
.....
8 08
9 09
10 10
11 11

haut

Le tableau permet d'avoir les elements uniques d'une colonne


# in.txt                                      
100
100
100
101
101
102
102

awk '{ arr[$1]++ }
END {
for (i in arr) print i}
' in.txt

# resultat
100
101
102

haut

Synthaxe d'une commande AWK dans une proc


# in.txt
1734P1 4095 203 194523                                      

#!/bin/bash
var=\'
awk '{print "awk '$var'$4 ~ /"$2"/ {print}'$var' z"$1".txt"}' in.txt > out.sh

# ajouter un shebang en ligne 1
sed -e '1i \#!/bin/bash' out.sh > out2.sh

chmod 777 out2.sh

# syntaxe de la commande cree , prete a etre executee
awk '$4 ~ /4095/ {print}' z1734P1.txt

haut

Traitement d'un texte


# in1.txt
data1
pattern1
data2
data3
pattern2
data4

# in2.txt
data1b
pattern1
data2b
data3b
pattern2
data4b

# capture du paragraphe
for i in in*.txt
do
sed -n '
/pattern1/ {:a
N
/pattern2/ !ba
p
}' $i > z-$i
done

# renommer entierement le nom des fichiers
find . -name "z-*.txt" |
while read j
do
mv -v "$j" `echo "$j" | awk '{print "z-"substr($1,7,1)}'`
done

# ajouter le nom du fichier devant chaque ligne des fichiers
for k in z-*
do
seq=`ls $k | 
cut -c3-3`                                                                  
awk '{print seq,$0}' seq=${seq} $k > y$k
done

# resultat
# yz-1
1 pattern1
1 data2
1 data3
1 pattern2

# yz-2
2 pattern1
2 data2b
2 data3b
2 pattern2

haut

La syntaxe : " if [[ `awk " est plus rapide que la boucle " while " pour capturer plusieurs patterns dans des paragraphes


# in.txt :
%%%%% title1
line1
pattern3 from title1
STEPATT=INTEGER
pattern2 from title1
SORT=TWO
end from title1
XYB1

%%%%% title2
line1
pattern3 from title2
data2
SORT=ONE
end from title2
XYB1

#!/bin/bash
###########  parametres

IN=in.txt
INTER=search-end.txt
OUT=out-result.txt
START=%%%%%

END=XYB1    # ne pas changer 

PATTERN1=SORT\=
PATTERN2=STEPATT\=

# resultats ds search 1,2,3

###########  fin des parametres

rm $OUT   2>/dev/null

awk '$0 ~ /'$END'/ {print NR,$0}' $IN | sed 's/\*//1' > $INTER

# nb lignes de search1.txt
nblines=`grep "." $INTER | wc -l`
echo "nb d'occurrences du pattern : $END : " $nblines
sleep 3

# recherche par le bas
countline=1
until [ $countline -gt $nblines ]
do

   for i in `awk '{print $1}' $INTER | sed -n ''$countline'p'`  # occurrences du pattern
   do
   echo "ligne de fin : " $END "(de " $INTER " ) : " $countline "/" $nblines  "  -  ligne nb de : " $IN " : " $i  
   
        counter=1
        until [ $counter -gt $i ]  # recherche %%%%% dans l'ordre decroissant des lignes
        do
        if [[ `awk 'NR == '$i-$counter' {print}' $IN` =~ $PATTERN1 ]] ; then echo `awk 'NR == '$i-$counter' {print NR,$0}' $IN`
        
        elif [[ `awk 'NR == '$i-$counter' {print}' $IN` =~ $PATTERN2 ]] ; then echo `awk 'NR == '$i-$counter' {print NR,$0}' $IN`
        
        elif [[ `awk 'NR == '$i-$counter' {print}' $IN` =~ $START ]] ; then echo `awk 'NR == '$i-$counter' {print NR,$0}' $IN` ; 
           echo `awk 'NR == '$countline' {print NR"_ (occurrence de XYB1) "$0}' $INTER` ; echo "----------------" ; break ; fi
        let counter+=1
        # sleep 1   
        done  >> $OUT # du decompte
        
   done  # lecture des occurrences du pattern   (search1.txt)

let countline=countline+1  
done  # compteur des occurrences du pattern

# resultat :
6 SORT=TWO
4 STEPATT=INTEGER
1 %%%%% title1
1_ (occurrence de XYB1) 8 XYB1
----------------
14 SORT=ONE
10 %%%%% title2
2_ (occurrence de XYB1) 16 XYB1
----------------

haut

CONVERSION ISO-8859-1 ET UTF-8



1- Convert a UTF-8 charset file into a ISO-8859-1 charset file using standard Linux tools :

iconv --to-code=ISO-8859-1 --from-code=UTF-8 utf.txt > iso.txt

2- Convert a ISO-8859-1 charset file into a UTF-8 charset file using standard Linux tools :

iconv --from-code=ISO-8859-1 --to-code=UTF-8 iso.txt > utf.txt

haut

Suppression d'accents (par l'hexadecimal) - script perl - (ascii -> hexa -> ascii)


#!/usr/bin/perl

## changer START1 (fichier entree)
## changer RESULT (a la fin , au 5 eme script)

## script 1 en bash

my @args = ( "bash", "-c", "

START1=0-start-complet-from-cgg.txt
OUT1=1-ascii.txt
SLEEP=3

## attention ajouter un antislash devant les caracteres : \$ \" \\
echo \"nb de caracteres speciaux ds \$START1\"
echo
echo \"nb de  :  c3              :  \$(grep \"\" \$START1 | wc -l)\"
echo \"nb de  :  c2              :  \$(grep \"\" \$START1 | wc -l)\"
echo \"nb de  :  etre            :  \$(grep \"\" \$START1 | wc -l)\"
echo \"nb de  :  sur - <>  :  \$(grep \"\" \$START1 | wc -l)\"
echo \"nb de  :  role            :  \$(grep \"\" \$START1 | wc -l)\"
echo \"nb de  :  relache         :  \$(grep \"\" \$START1 | wc -l)\"
echo \"nb de  :  tres            :  \$(grep \"\" \$START1 | wc -l)\"
echo \"nb de  :  naif            :  \$(grep \"\" \$START1 | wc -l)\"
echo \"nb de  :  Noel - <> :  \$(grep \"\" \$START1 | wc -l)\"
echo \"nb de  :  Livre           :  \$(grep \"\" \$START1 | wc -l)\"
echo \"nb de  :  degres          :  \$(grep \"\" \$START1 | wc -l)\"
echo \"nb de  :  Etat            :  \$(grep \"\" \$START1 | wc -l)\"
echo \"nb de  :  ou              :  \$(grep \"\" \$START1 | wc -l)\"
echo \"nb de  :  facon           :  \$(grep \"\" \$START1 | wc -l)\"
echo \"nb de  :  ecouler         :  \$(grep \"\" \$START1 | wc -l)\"
echo \"nb de  :  paraitre        :  \$(grep \"\" \$START1 | wc -l)\"
echo \"nb de  :  oeil            :  \$(grep \"\" \$START1 | wc -l)\"
                                                                    
sleep \$SLEEP
sleep \$SLEEP
sleep \$SLEEP
sleep \$SLEEP
sleep \$SLEEP


# deleter les anciens resultats
rm 1-hexa*
rm 1-result-ascii*
rm 1-ascii*

echo \"-----> ok anciens resultats deletes\"
sleep \$SLEEP

# marquer les fins de lignes
awk '{print \$0\"**\"}' \$START1 | sed 's/\t/      /g' > 1-inter1

# mettre sur 1 ligne
sed '{:a;\$!N;s_\\n_ _;ta}' 1-inter1 > \$OUT1 

echo \"-----> ok script 1 termine\"
echo \"-----> ok fichier ascii mis sur 1 ligne\"
sleep \$SLEEP

" );
system(@args);


################################
## script 2 en perl

##  entree : 1-ascii.txt  ## sur 1 ligne
##  sortie : 1-hexa1.txt  ## bytes sans espace sur 1 ligne

use strict;
sub ascii_to_hex ($)
{
        ## Convert each ASCII character to a two-digit hex number.
        (my $str = shift) =~ s/(.|\n)/sprintf("%02lx", ord $1)/eg;
        return $str;
}

##
open(DA, "<1-ascii.txt") or die "Le fichier n'existe pas !";
open(WRITER, ">1-hexa1.txt") or die "Le fichier ne peut etre edite !\n";

        my $str = <DA> ;
        chomp $str;
        my $h_str = ascii_to_hex $str;

        print WRITER $h_str;

close(DA);

close(WRITER);


###########################
## script 3 en bash

my @args = ( "bash", "-c", "

START2=1-hexa1.txt
OUT2=1-hexa1e.txt
PATTERN=0-patterns.txt
SLEEP=3

echo \"-----> ok fichier ascii converti en hexa sur une ligne\"
echo \"-----> ok script 2 termine\"
sleep \$SLEEP


##################  fin des parametres

# ajouter 1 blanc apres 2 digits
sed 's/../& /g' \$START2 > 1-hexa1b.txt
       
echo \"-----> ok blanc entre octet\"
sleep \$SLEEP
        
## attention : penser a ecrire le code aussi ds le fichier : PATTERN

## correspondance : exemple de mots a changer

echo \"ee :  i with circumflex         -->  69 \"
echo \"e9 :  e with acute              -->  65 \"
echo \"e7 :  c with cedilla            -->  63 \"
echo \"e0 :  a with grave              -->  61 \"
echo \"f4 :  o with circumflex         -->  6f \"
echo \"fb :  u with circumflex         -->  75 \"
echo \"f9 :  u with grave              -->  75 \"
echo \"ef :  i with diaeresis          -->  69 \"
echo \"ea :  e with circumflex         -->  65 \"
echo \"91 :  ' left single quotation   -->  91 \"
echo \"92 :  ' right single quotation  -->  92 \"
echo \"e8 :  e with grave              -->  65 \"
echo \"e2 :  a with circumflex         -->  61 \"
echo \"9c :  oe small ligature         -->  6f 65 \"
echo \"eb :  e with diaeresis          -->  65 \"
echo \"a3 :  pound sign                -->  4c 20 \"
echo \"ba :  degres                    -->  20 44 \"
echo \"ab :  <<                        -->  20 \"
echo \"bb :  >>                        -->  20 \"
                                            


echo \"c2 9c    oe small ligature   :  oeil : 6f 65 (retirer c2) \"
echo \"c3 ae    i with circumflex   :  paraitre      \"
echo \"c3 a9    e with acute        :  ecouler       \"
echo \"c3 a7    c with cedilla      :  facon         \"
echo \"c3 a0    a with grave        :  a l'avance    \"
echo \"c3 b4    o with circumflex   : role           \"
echo \"c3 bb    u with circumflex   : surete         \"
echo \"c3 b9    u with grave        : ou             \"
echo \"c3 af    i with diaeresis    : naif           \"
echo \"c3 aa    e with circumflex   :  etre          \"
echo \"c2 91    left single quotation mark : '       \"
echo \"c2 92    right single quotation mark : '      \"
echo \"c3 a8    e with grave        : tres           \"
echo \"c3 a2    a with circumflex   : relache        \"
echo \"c3 89    capital letter E with acute : Etat   \"
echo \"c3 ab    e with diaeresis    : Noel           \"
echo \"c2 ab    left double angle quote   : <<       \"
echo \"c2 bb    right double angle quote  : >>       \"
echo \"c2 a3    pound sign                           \"
echo \"c2 ba    degres                               \"
echo \"c2 a0    non breaking space                   \"

                                                  
sleep \$SLEEP
sleep \$SLEEP
sleep \$SLEEP


## ajouter ici manuellement la substitution (retrait du blanc de separation)
                                    
sed 's/c2 9c/9c/g' 1-hexa1b.txt |
sed 's/c3 a9/c3a9/g' |
sed 's/c3 ae/c3ae/g' |
sed 's/c3 a7/c3a7/g' | 
sed 's/c3 a0/c3a0/g' |
sed 's/c3 aa/c3aa/g' |
sed 's/c2 91/c291/g' |
sed 's/c2 92/c292/g' | 
sed 's/c3 bb/c3bb/g' |
sed 's/c3 b4/c3b4/g' |
sed 's/c3 a2/c3a2/g' |
sed 's/c3 a8/c3a8/g' | 
sed 's/c3 af/c3af/g' |
sed 's/c3 89/c389/g' |
sed 's/c3 ab/c3ab/g' |
sed 's/c2 ab/c2ab/g' |
sed 's/c2 bb/c2bb/g' |
sed 's/c2 a3/c2a3/g' |
sed 's/c2 ba/c2ba/g' |
sed 's/c2 a0/c2a0/g' |
sed 's/c3 b9/c3b9/g'> 1-hexa1bb.txt

## ajouter manuellement ds le fichier : PATTERN

###################
# verif
echo
echo \"avant changement\"

## ecrit les occurrences des patterns rencontres avant le changement
   while read pattern
   do
   
   var1=`cat 1-hexa1bb.txt | awk '{f[j]=\$0} {for(i=1;i<=NF;i++) if(\$i ~ /'\$pattern'/) {j++}} END {print \"'\$pattern'\",j}'` 

echo \$var1

   done < \$PATTERN
        
## le fichier PATTERN doit etre mis a jour
                              
############################                                                        
## AJOUTER MANUELLEMENT DES CHANGEMENTS DE CARACTERES AVEC : SED
## la substitution retirera l'accent de la lettre
sed 's/ee/69/g' 1-hexa1bb.txt | 
sed 's/e9/65/g' | 
sed 's/e7/63/g' | 
sed 's/e0/61/g' | 
sed 's/f4/6f/g' | 
sed 's/fb/75/g' | 
sed 's/f9/75/g' | 
sed 's/ef/69/g' | 
sed 's/ea/65/g' | 
sed 's/e8/65/g' | 
sed 's/e2/61/g' | 
sed 's/9c/6f 65/g' |
sed 's/eb/65/g' | 
sed 's/a3/4c 20/g' | 
sed 's/ba/20 44/g' | 
sed 's/ab/20/g' | 
sed 's/bb/20/g' | 
sed 's/c29c/6f 65/g' |
sed 's/c3a9/65/g' |
sed 's/c3ae/69/g' |
sed 's/c3a7/63/g' |
sed 's/c3a0/61/g' |
sed 's/c3aa/65/g' | 
sed 's/c291/91/g' |
sed 's/c292/92/g' |
sed 's/c3bb/75/g' |
sed 's/c3b9/75/g' |
sed 's/c3b4/6f/g' |
sed 's/c3a2/61/g' | 
sed 's/c3a8/65/g' |
sed 's/c389/65/g' |
sed 's/c3ab/65/g' |
sed 's/c2ab/20/g' |
sed 's/c2bb/20/g' |
sed 's/c2a3/4c 20/g' |
sed 's/c2ba/20 44/g' |
sed 's/c2a0/20/g' |
sed 's/c3af/69/g' > 1-hexa1c.txt

echo
echo \"apres changement\"

## ecrit les occurrences des patterns rencontres apres le changement
   while read pattern
   do
   
   var1=`cat 1-hexa1c.txt | awk '{f[j]=\$0} {for(i=1;i<=NF;i++) if(\$i ~ /'\$pattern'/) {j++}} END {print \"'\$pattern'\",j}'` 

echo \$var1

   done < \$PATTERN

## le fichier PATTERN doit etre a jour
                                             
# retirer les blancs de separation
sed 's/ //g' 1-hexa1c.txt > 1-hexa1d.txt

# mettre sur 1 ligne
sed '{:a;\$!N;s_\\n_ _;ta}' 1-hexa1d.txt | sed 's/ //g' > \$OUT2 

echo \"-----> ok hex mis sur 1 ligne sans blanc entre octet\"
echo \"-----> ok script 3 termine\"
sleep \$SLEEP
sleep \$SLEEP

" );
system(@args);

#####################################
## script 4 en perl

## noms des fichiers non mis en variable (a cause de perl)
##  entree : 1-hexa1e.txt  ## sur 1 ligne
##  sortie : 1-result-ascii1.txt  ## bytes sans espace sur 1 ligne

## 

## use strict;
sub hex_to_ascii ($)
{
        ## Convert each two-digit hex number back to an ASCII character.
        (my $str = shift) =~ s/([a-fA-F0-9]{2})/chr(hex $1)/eg;
        return $str;
}


##  entree : 1-hexa1d.txt  ## sur 1 ligne
open(DA2, "<1-hexa1e.txt") or die "Le fichier n'existe pas !";
open(WRITER2, ">1-result-ascii-1") or die "Le fichier ne peut tre dit !\n";

        my $str = <DA2> ;
        chomp $str;
        my $a_str = hex_to_ascii $str;

         print WRITER2 $a_str;

close(DA2);

close(WRITER2);

####################################
## script 5 en bash

my @args = ( "bash", "-c", "

RESULT=0-final-result-complet-from-cgg.txt
SLEEP=3

echo \"-----> ok hex converti en ascii\"
echo \"-----> ok script 4 termine\"
sleep \$SLEEP

# ajouter saut de ligne apres **
sed 's/\\\*\\\*/\\\*\\\*\\n/g' 1-result-ascii-1 | sed 's/\\\*\\\*//g' | sed 's/^ //g' > \$RESULT

echo \"-----> ok script 5 termine - FIN des 5 scripts\"
echo \"-- >  resultat ds : \$RESULT\"
echo
echo \"nb de caracteres speciaux ds \$RESULT\"
echo
echo \"nb de  :  c3              :  \$(grep \"\" \$RESULT | wc -l)\"
echo \"nb de  :  c2              :  \$(grep \"\" \$RESULT | wc -l)\"
echo \"nb de  :  etre            :  \$(grep \"\" \$RESULT | wc -l)\"
echo \"nb de  :  sur - <>  :  \$(grep \"\" \$RESULT | wc -l)\"
echo \"nb de  :  role            :  \$(grep \"\" \$RESULT | wc -l)\"
echo \"nb de  :  relache         :  \$(grep \"\" \$RESULT | wc -l)\"
echo \"nb de  :  tres            :  \$(grep \"\" \$RESULT | wc -l)\"
echo \"nb de  :  naif            :  \$(grep \"\" \$RESULT | wc -l)\"
echo \"nb de  :  Noel - <> :  \$(grep \"\" \$RESULT | wc -l)\"
echo \"nb de  :  Livre           :  \$(grep \"\" \$RESULT | wc -l)\"
echo \"nb de  :  degres          :  \$(grep \"\" \$RESULT | wc -l)\"
echo \"nb de  :  Etat            :  \$(grep \"\" \$RESULT | wc -l)\"
echo \"nb de  :  ou              :  \$(grep \"\" \$RESULT | wc -l)\"
echo \"nb de  :  facon           :  \$(grep \"\" \$RESULT | wc -l)\"
echo \"nb de  :  ecouler         :  \$(grep \"\" \$RESULT | wc -l)\"
echo \"nb de  :  paraitre        :  \$(grep \"\" \$RESULT | wc -l)\"
echo \"nb de  :  oeil            :  \$(grep \"\" \$RESULT | wc -l)\"
                                      
" );
system(@args);

haut

Suppression d'accents (par l'hexadecimal - script bash (contenant du perl et python) - (ascii -> hexa -> ascii)


#!/bin/bash

# script BASH contenant du PERL et PYTHON
# attention de retirer le retour chariot en copiant ce script dans un autre pour l'executer.
# faire : sed 's/\r//g' ce_script.sh > script_copy.sh   (et executer script_copy.sh) 

################  parametres

START1=0-start.txt
OUT1=1-inter-ascii-2.txt

START2=1-inter-hexa-2.txt
OUT2=1-inter-hexa-4.txt

START3=1-inter-hexa-5.txt
OUT3=1-inter-ascii-result.txt

PATTERN=0-patterns.txt
SLEEP=3

################ fin des parametres

# contenu de START1 :
# [sun]     se lever, paraître
# b. [from a person]   chasser le mauvais œil 
# c'est à cette époque que remontent
# venir grossir les rangs des chômeurs
# au troisième top, il sera exactement 6 h
# elle n'arrêtait pas de se balancer
 
# contenu de PATTERN :
# ee
# e9
# e7
# e0
# f4
# fb
# f9
# ef
# ea
# e8
# e2
# 9c
# eb
# c9
# a3
# ba
# ab
# bb
# c29c
# c3a9
# c3ae
# c3a7
# c3a0
# c3aa
# c291
# c292
# c3bb
# c3b9
# c3b4
# c3a2
# c3a8
# c3af
# c389
# c3ab
# c2ab
# c2bb
# c2a3
# c2ba
# c2a0


# deleter les anciens resultats
rm 1-inter*
sleep $SLEEP
sleep $SLEEP

# 1_ en bash : tout sur 1 ligne

awk '{print $0"%%%"}' $START1 > 1-inter-ascii-1.txt

# sur 1 ligne en ascii
sed '{:a;$!N;s_\n_ _;ta}' 1-inter-ascii-1.txt > $OUT1

###########################

# 2_ en python : conversion en hexa

cat << EOF | python -

import sys
import binascii
import base64

f = open ("$OUT1", "r")
fd = open ("1-inter-hexa-1.txt", "w")
t = f.read()

print t.encode("hex")
fd.write(t.encode("hex"))

f.close()
fd.close()

EOF

#################
# 3_bash : substitutions

sed 's/../& /g' 1-inter-hexa-1.txt > $START2


echo "nb de caracteres speciaux ds $START2"
echo
echo "nb de à :  c3              :  $(grep \"Ã\" $START2 | wc -l)"
echo "nb de  :  c2              :  $(grep \"Â\" $START2 | wc -l)"
echo "nb de ª :  etre            :  $(grep \"ª\" $START2 | wc -l)"
echo "nb de » :                  :  $(grep \"»\" $START2 | wc -l)"
echo "nb de Ž :  role            :  $(grep \"Ž\" $START2 | wc -l)"
echo "nb de ¢ :  relache         :  $(grep \"¢\" $START2 | wc -l)"
echo "nb de š :  tres            :  $(grep \"š\" $START2 | wc -l)"
echo "nb de ¯ :  naif            :  $(grep \"¯\" $START2 | wc -l)"
echo "nb de « :                  :  $(grep \"«\" $START2 | wc -l)"
echo "nb de £ :  Livre           :  $(grep \"£\" $START2 | wc -l)"
echo "nb de º :  degres          :  $(grep \"º\" $START2 | wc -l)"
echo "nb de ‰ :  Etat            :  $(grep \"‰\" $START2 | wc -l)"
echo "nb de ¹ :  ou              :  $(grep \"¹\" $START2 | wc -l)"
echo "nb de § :  facon           :  $(grep \"§\" $START2 | wc -l)"
echo "nb de © :  ecouler         :  $(grep \"©\" $START2 | wc -l)"
echo "nb de ® :  paraitre        :  $(grep \"®\" $START2 | wc -l)"
echo "nb de œ :  oeil            :  $(grep \"œ\" $START2 | wc -l)"
echo "nb de É :  Etat            :  $(grep \"É\" $START2 | wc -l)"
                                                                    
sleep $SLEEP
sleep $SLEEP
sleep $SLEEP

#######################
        
## attention : penser a ecrire le code aussi ds le fichier : PATTERN

## correspondance : exemple de mots a changer
echo "---> INFOS"

echo "ee :  i with circumflex             -->  69 "
echo "e9 :  e with acute                  -->  65 "
echo "e7 :  c with cedilla                -->  63 "
echo "e0 :  a with grave                  -->  61 "
echo "f4 :  o with circumflex             -->  6f "
echo "fb :  u with circumflex             -->  75 "
echo "f9 :  u with grave                  -->  75 "
echo "ef :  i with diaeresis              -->  69 "
echo "ea :  e with circumflex             -->  65 "
echo "91 :  ' left single quotation       -->  91 "
echo "92 :  ' right single quotation      -->  92 "
echo "e8 :  e with grave                  -->  65 "
echo "e2 :  a with circumflex             -->  61 "
echo "9c :  oe small ligature             -->  6f 65 "
echo "eb :  e with diaeresis              -->  65 "
echo "c9 :  capital letter E with acute   -->  65 "
                                            


echo "c2 9c    oe small ligature   :  oeil : 6f 65 (retirer c2) "
echo "c3 ae    i with circumflex   :  paraitre      "
echo "c3 a9    e with acute        :  ecouler       "
echo "c3 a7    c with cedilla      :  facon         "
echo "c3 a0    a with grave        :  a l'avance    "
echo "c3 b4    o with circumflex   : role           "
echo "c3 bb    u with circumflex   : surete         "
echo "c3 b9    u with grave        : ou             "
echo "c3 af    i with diaeresis    : naif           "
echo "c3 aa    e with circumflex   :  etre          "
echo "c2 91    left single quotation mark : '       "
echo "c2 92    right single quotation mark : '      "
echo "c3 a8    e with grave        : tres           "
echo "c3 a2    a with circumflex   : relache        "
echo "c3 89    capital letter E with acute : Etat   "
echo "c3 ab    e with diaeresis    : Noel           "
echo "c2 ab    left double angle quote   : <<       "
echo "c2 bb    right double angle quote  : >>       "
echo "c2 a3    pound sign                           "
echo "c2 ba    degres                               "
echo "c2 a0    non breaking space                   "

                                                  
sleep $SLEEP
sleep $SLEEP
sleep $SLEEP


## ajouter ici manuellement la substitution (retrait du blanc de separation)
                                    
sed 's/c2 9c/9c/g' $START2 |
sed 's/c3 a9/c3a9/g' |
sed 's/c3 ae/c3ae/g' |
sed 's/c3 a7/c3a7/g' | 
sed 's/c3 a0/c3a0/g' |
sed 's/c3 aa/c3aa/g' |
sed 's/c2 91/c291/g' |
sed 's/c2 92/c292/g' | 
sed 's/c3 bb/c3bb/g' |
sed 's/c3 b4/c3b4/g' |
sed 's/c3 a2/c3a2/g' |
sed 's/c3 a8/c3a8/g' | 
sed 's/c3 af/c3af/g' |
sed 's/c3 89/c389/g' |
sed 's/c3 ab/c3ab/g' |
sed 's/c2 ab/c2ab/g' |
sed 's/c2 bb/c2bb/g' |
sed 's/c2 a3/c2a3/g' |
sed 's/c2 ba/c2ba/g' |
sed 's/c2 a0/c2a0/g' |
sed 's/c3 b9/c3b9/g'> 1-inter-hexa-3.txt

## ajouter manuellement ds le fichier : PATTERN

###################
# verif
echo
echo "avant changement"

## ecrit les occurrences des patterns rencontres avant le changement
   while read octets
   do
   
   var1=`cat 1-inter-hexa-3.txt | awk '{f[j]=\$0} {for(i=1;i<=NF;i++) if(\$i ~ /'$octets'/) {j++}} END {print "'$octets'",j}'` 

echo $var1

   done < $PATTERN
        
## le fichier PATTERN doit etre mis a jour
                              
############################                                                        
## AJOUTER MANUELLEMENT DES CHANGEMENTS DE CARACTERES AVEC : SED
## la substitution retirera l'accent de la lettre
sed 's/ee/69/g' 1-inter-hexa-3.txt | 
sed 's/e9/65/g' | 
sed 's/e7/63/g' | 
sed 's/e0/61/g' | 
sed 's/f4/6f/g' | 
sed 's/fb/75/g' | 
sed 's/f9/75/g' | 
sed 's/ef/69/g' | 
sed 's/ea/65/g' | 
sed 's/e8/65/g' | 
sed 's/e2/61/g' | 
sed 's/9c/6f 65/g' |
sed 's/eb/65/g' | 
sed 's/c9/65/g' | 
sed 's/c29c/6f 65/g' |
sed 's/c3a9/65/g' |
sed 's/c3ae/69/g' |
sed 's/c3a7/63/g' |
sed 's/c3a0/61/g' |
sed 's/c3aa/65/g' | 
sed 's/c291/91/g' |
sed 's/c292/92/g' |
sed 's/c3bb/75/g' |
sed 's/c3b9/75/g' |
sed 's/c3b4/6f/g' |
sed 's/c3a2/61/g' | 
sed 's/c3a8/65/g' |
sed 's/c389/65/g' |
sed 's/c3ab/65/g' |
sed 's/c2ab/20/g' |
sed 's/c2bb/20/g' |
sed 's/c2a3/4c 20/g' |
sed 's/c2ba/20 44/g' |
sed 's/c2a0/20/g' |
sed 's/c3af/69/g' > $OUT2

echo
echo "apres changement"

## ecrit les occurrences des patterns rencontres apres le changement
   while read octets
   do
   
   var1=`cat $OUT2 | awk '{f[j]=\$0} {for(i=1;i<=NF;i++) if(\$i ~ /'$octets'/) {j++}} END {print "'$octets'",j}'` 

echo $var1

   done < $PATTERN

## le fichier PATTERN doit etre a jour

################                                             
# retirer les blancs de separation
sed 's/ //g' $OUT2 > $START3


echo "-----> ok hex mis sur 1 ligne sans blanc entre octets"
sleep $SLEEP
sleep $SLEEP

################
# 4_ python : convertir hexa en ascii

cat << EOF | python -

import sys
import binascii
import base64


with open ("$START3") as original_string:
        fd = open ("1-inter-ascii-3.txt", "w")

        for line in original_string:
               
                print (line.decode("hex"))
                fd.write(line.decode("hex"))
 
original_string.close()
fd.close()

EOF

# le marqueur de fin de ligne remet les lignes en ordre
sed 's/%%% /\n/g' 1-inter-ascii-3.txt > $OUT3

echo " ok resultat ds : $OUT3"

# contenu de OUT3 :
# [sun]     se lever, paraitre
# b. [from a person]   chasser le mauvais oeil 
# c'est a cette epoque que remontent
# venir grossir les rangs des chomeurs
# au troisieme top, il sera exactement 6 h
# elle n'arretait pas de se balancer

haut

Derniere modification : DECEMBRE 2014