LA LIGNE
MIN - MAX - CUMUL
- Min et Max de valeurs placées sur une ligne
- Cumul de valeurs sur une ligne
MODIFIER LE DEBUT , LA FIN OU TOUT CARACTERE D'UNE LIGNE
- Supprimer un debut de fichier avant un pattern
- Supprimer une fin de fichier apres un pattern
- Modifier les extremites d'une ligne avec "gsub" (bash)
- Modifier une fin de ligne en retirant les espaces (sed)
- Modifier une fin de ligne en retirant un caractere (bash)
- Modifier une fin de ligne en ajoutant un caractere (bash)
- Modifier une fin de ligne en changeant un caractere - exemple 1 (awk)
- Modifier une fin de ligne en changeant un caractere - exemple 2 (awk)
- Modifier tout caractere en maitrisant sa position (awk)
- Ajouter un signe dans une colonne qui fera office de separateur (awk)
- Un signe en bout de ligne fait joindre la ligne qui suit (awk + getline)
- Lire les 3 premiers caracteres de chaque ligne d'un fichier
- Lire les 3 derniers caracteres de chaque ligne d'un fichier
- Effacer les 3 derniers caracteres de chaque ligne d'un fichier
TESTER LES FINS DE LIGNES
- En "AWK" : tester les tabulations cachees en fin de lignes
- En "BASH" : tester les derniers caracteres en fin de lignes
DECOUPER UN FICHIER
- Decouper un fichier a un pattern precis (le pattern est la fin du fichier decoupe)
- Decouper un fichier a un pattern precis (le pattern est le debut du fichier decoupe)
- Decouper un fichier a un pattern precis (autre exemple)
- Decouper un fichier d'apres la forme de sa fin de ligne
AJOUTER - INSERER
- Inserer une ligne avant ou apres un pattern (en AWK et en BASH)
- Inserer un trait au changement d'un pattern
- Inserer une ligne avant des patterns listes dans un fichier
- Ajouter du texte sur une ligne ou apres une ligne
- Inserer une ligne blanche selon un critere de longueur de ligne
- Memoriser une chaine de caracteres pour l'inserer sur une autre ligne
CAPTURER - MODIFIER
- Capturer dans un fichier des patterns listes dans un 2eme fichier (exemple 1)
- Capturer dans un fichier des patterns listes dans un 2eme fichier (exemple 2)
- Modifier dans un fichier des patterns listes dans un 2eme fichier
- Stopper la lecture d'un fichier à un pattern liste dans un 2eme fichier
- Capturer un pattern a une position fixe sur une ligne
- Capturer un pattern avec un depart, une longueur et une arrivee
- Capturer la premiere occurrence d'une serie de lignes ayant meme pattern
- Selectionner des lignes d'un fichier par des caracteres d'une colonne
- Une seule variable dans une seule boucle suffit pour la source et la cible
- Capture de lignes avec pattern de debut et de fin
- Maitrise de la ligne et du champ pour reorganiser les champs
COLLER - MARQUER - REMPLACER
- Marquer des groupes de patterns semblables (exemple simple)
- Marquer des groupes de patterns semblables (exemple plus complique)
- Coller des valeurs a un pattern (exemple 1)
- Coller des valeurs a un pattern (exemple 2)
- Coller des valeurs a un pattern (exemple 3)
- Remplacer des patterns par d'autres, contenus dans un 2eme fichier (3 exemples)
- Un titre de paragraphe devient marqueur (en utilisant 'split')
- Un titre de paragraphe devient marqueur (sans utiliser 'split')
- Un champ d'une ligne devient titre de la ligne (sans utiliser 'split')
L'OCCURRENCE D'UN PATTERN
- Repeter un nombre de fois (valeur en colonne 2), un pattern situe en colonne 1
- Occurrences d'un pattern (syntaxe courte)
- Occurrences d'un pattern
- Occurrences d'un pattern - precision de sa position (exemple 1)
- Occurrences d'un pattern - precision de sa position (exemple 2)
- Capturer ou deleter des lignes dont le mot en colonne 1 a une autre occurrence sur la ligne (en BASH et en AWK)
- Marquer les numeros des occurrences a partir d'une liste de patterns
- Deleter les occurrences repetees dans une colonne, et ne garder que la 1ere
- Occurrences d'un caractere dans plusieurs fichiers
- Afficher toutes les occurrences d'un titre
ADDITION
- Addition d'une constante aux chiffres d'une colonne
LES DOUBLES
- Deleter des lignes semblables consecutives
INCREMENTER DES LIGNES CONSECUTIVES DE SYNTAXE IDENTIQUE
- Incrementer des lignes consecutives de format identique, le compteur est mis a zero ensuite
JOINDRE
- Joindre un signe avec la ligne suivante (exemple 1)
- Joindre un signe avec la ligne suivante (exemple 2)
- Joindre un signe avec la ligne suivante (exemple 3)(awk + getline)
- Joindre un signe au bout de la ligne precedente (exemple 1)
- Joindre un signe au bout de la ligne precedente (exemple 2)
- Joindre un signe au bout de la ligne precedente sauf si cette derniere se termine par @ (exemple 3)
- Un signe en debut de ligne 1, fait joindre la ligne 2 a la suite de la 1
- Les lignes qui commencent par un signe collent les suivantes a leur fin si elles ne possedent pas ce signe
COMPARER 2 FICHIERS
- Printer les lignes du fichier2 qui manquent dans le fichier1
- Comparer 2 fichiers : identiques ou differents
- Intersection de 2 fichiers : lignes uniques et communes
DIVERS
- Un titre de paragraphe est capture a un pattern
- Operations entre lignes 'n+1' et 'n'
- Supprimer des caracteres entre 2 bornes connues
- Supprimer des lignes doubles
haut
Min et Max d'une colonne
# in.txt
694
1004
438
# methode courte ( min et max )
awk 'min=="" || $1 < min {min=$1}
END {print min}' FS=" " in.txt # 438
awk 'max=="" || $1 > max {max=$1}
END {print max}' FS=" " in.txt # 1004
# methode longue ( max )
array=(`cat in.txt`)
max=0
len=${#array[*]}
i=0
while [ $i -lt $len ]
do
val=`echo "${array[$i]}"`
if [ $(echo "$max < $val" | bc) -eq 1 ]
then
max=$val
fi
let i++
done
echo "max is => $max" # max is => 1004
haut
Min et Max d'une colonne avec choix des limites de debut de coupe
# in.txt
70 1001
50 1002
30 1003
20 1005
30 1006
40 1007
# compteur.txt
1001 1003
1005 1007
#!/bin/bash
while read var1 var2
do
if [ -e temp.txt ] ; then rm temp.txt ; fi
until [ $var1 -gt $var2 ]
do
var3=`awk '$2 ~ '$var1' {print $1}' in.txt`
echo $var3 >> temp.txt
echo $var3
min=`awk 'min=="" || $1 < min {min=$1} END {print min}' temp.txt`
max=`awk 'max=="" || $1 > max {max=$1} END {print max}' temp.txt`
let var1=var1+1
done
echo "min= " $min " ; max= " $max
done < compteur.txt > temp2.txt
awk '/min/ {print $0}' temp2.txt > temp3.txt
paste compteur.txt temp3.txt
# resultat
1001 1003 min= 30 ; max= 70
1005 1007 min= 20 ; max= 40
haut
Cumul d'une colonne en regroupant des patterns semblables (associative array)
# in.txt
100 1001
100 1002
100 1003
101 1004
101 1005
#!/bin/bash
awk '{ arr[$1]+=$2 }
END{ for( i in arr )
{print i, arr[i]}
}' in.txt | sort -n
# resultat
100 3006
101 2009
haut
Cumul d'une colonne avec limite de coupe manuelle
#!/bin/bash
# but du script : cumuler a l'aide d'un compteur.
# La 1ere ligne du compteur (1001 1003) indique
# qu'il y aura cumul de la colonne 1 de 1001 a 1003.
############ parametres:
# fichier depart : in.txt
# 70 1001
# 50 1002
# 30 1003
# 20 1004
# 30 1005
# 40 1006
# compteur.txt
# 1001 1003
# 1004 1006 # supprimer le dernier retour chariot
IN=in.txt # changer ici les noms des fichiers
COMPTEUR=compteur.txt
OUT=out.txt
########### 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}' tmp3.txt > $OUT
cat $OUT
# resultat
# 1001-1003 cumul = 150
# 1004-1006 cumul = 90
haut
Cumul d'une colonne avec limite de coupe automatique
#!/bin/bash
####### parametres #############
LIMIT=7
IN=stmdepart.txt
OUT=stmresult.txt
###
# stmdepart.txt
# 3
# 2
# 5 # une seule colonne de valeurs (sans compteur)
# 1
# 6
# 4
# 2 # sans retour chariot final
####### fin des parametres ############
### script
awk '{print total+=$1}' $IN > inter2.txt
paste $IN inter2.txt > inter3.txt
# si le cumul > $LIMIT
cat inter3.txt | awk '{
# ajouter syntaxe si necessaire : < '$LIMIT' ? total3 : (total4+=$1) < '$LIMIT' ? total4 : (total5+=$1)
f[$2] = ($2 < '$LIMIT' ? $2 : (total+=$1) < '$LIMIT' ? total : (total2+=$1) < '$LIMIT' ? total2 : (total3+=$1))
{print f[$2]}
}' > inter4.txt
# mettre les lignes en tableau
awk '{f[NR] = $0}
END {
for (i=1; i<=NR; i++)
if (f[i+1] <= f[i])
{print f[i],"@"} # ajouter un marqueur
else
{print f[i]}
}' inter4.txt > inter5.txt
# creer un compteur a la repetition d'un pattern
while read line
do echo "$line"
if [[ "$line" =~ "@" ]] ; then echo "------ tape " ; fi
done < inter5.txt | sed -e '1i \------ tape ' | sed '$d' | sed 's/@//g' > inter6.txt
# habillage final
# marquer les occurrences du pattern "@" (et effacer les marqueurs inutiles)
awk '/tape/ {i=i+1} {print $0,i}' inter6.txt |
awk '!a[$NF]++ {print $0 ; next} { sub($NF, "") ; print }' > $OUT ; cat $OUT
# resultat
# --- tape 1
# 3
# 5
# --- tape 2
# 5
# 6
# --- tape 3
# 6
# --- tape 4
# 4
# 6
haut
Afficher 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
Cumul d'une colonne avec decoupe a une limite definie - METHODE 1
#!/bin/bash
# SCRIPT 1 - METHODE 1
# avantages : court - habillage a l'exterieur de la boucle
# avantages : 1 seule boucle UNTIL
########## parametres
LIMIT=100
NBOFTAPES=10
ORIG=0-start.txt
OUTMETHODE1=1-result-1A-$LIMIT.txt
SLEEP=0
########### fin des parametres
# ORIG
# 10001 30
# 10002 2
# 10003 30
# 10004 30
# 10005 14
# 10006 30
# 10007 30
# 10008 30
# 10009 17
# 10010 30
# 10011 30
############### ZONE ARRONDIR : pour arrondir des valeurs
# arrondir 0.3 en 0 /// 0.7 en 1 :
# ATTENTION CHANGER LA VIRGULE EN POINT
# script pour arrondir
# while read col1 col2
# do
# awk -v var2="$col2" -v var1="$col1" 'BEGIN { rounded = sprintf("%.0f", var2) ; print var1,rounded }'
# done < fichier entree > 0-start.txt
# exit # pour verifier si le fichier ARRONDI a bien ete fait
################## fin de la zone ARRONDIR
# deleter les anciens resultats
rm 1a-in*
rm 1a-tape*
# etat apres la suppression des anciens resultats
echo "apres suppression : nb de 1a-in* : `ls 1a-in* | wc -l`"
echo "apres suppression : nb de 1a-tape* : `ls 1a-tape* | wc -l`"
# exit # activer pour deleter uniquement (sans faire marcher le script)
echo "les anciens resultats sont deletes"
sleep $SLEEP
##################
# sauvegarde de l'original
cp $ORIG 1a-in1.txt
# boucle sur les tapes
n=1
until [[ $n -gt "$NBOFTAPES" ]]
do
awk '{print $1,$2,x+=$2}' 1a-in$n.txt > 1a-inter$n.txt
# marquer les lignes dont le cumul est < $LIMIT
awk '{
if($3 < '$LIMIT' ) {print $0" @"}
else
{print}
}' 1a-inter$n.txt | grep "@" > 1a-tape$n.txt
# retirer de l'original les lignes de cette tape traitee
awk 'BEGIN{FS=" "}
FNR==NR {ex[$1]; next}
!($1 in ex)
' 1a-tape$n.txt 1a-in$n.txt > 1a-in`expr $n + 1`.txt
######### test si arret
# tester si fichier 1f-in`expr $counter + 1`.txt est vide ou non
test -s 1a-in`expr $n + 1`.txt # Check if file is nonzero size
var1=`echo $?` # code retour = 0 -> commande bien executee -> Check if file is nonzero size
# echo $var1
if [ "$var1" -eq "0" ] ; then
echo "code retour=0 - bien execute - file is nonzero size - ok : 1a-in`expr $n + 1`.txt"
echo "----------------"
else
echo "code retour=1 - mal execute - file is zero size - pas de 1a-in`expr $n + 1`.txt - arret" ; break
fi
let n=n+1
done # fin de la boucle sur les tapes
##############
# habillage
# renommer les fichiers tapes avec 2 digits
for i in `seq 1 9`
do
mv 1a-tape$i.txt 1a-tape0$i.txt
done 2>/dev/null
grep -H "." 1a-tape* | sed 's/@//g' | sed 's/.txt:/ : /g' | sed 's/4-//g' |
awk 'BEGIN{OFS=FS=" "}
{if ($1 != var )
{var=$1;e="@"
print $0,e}
else
print $0
}' | sed -e '/@/i\----------------' | sed 's/@//g' | sed 's/1a-//g' > $OUTMETHODE1
echo "resultat ds $OUT : "
cat $OUTMETHODE1
echo "------------------"
echo "---> liste des fichiers generes par ce script"
echo " nb de 1a-in* : `ls 1a-in* | wc -l`"
echo " nb de 1a-tape* : `ls 1a-tape* | wc -l`"
echo "------------------"
echo "total des 1a : `ls 1a* | wc -l`"
echo "---> la fin du script est a l'exterieur de la boucle"
echo "donc un autre script peut etre execute a sa suite"
# resultat
# ----------------
# tape01 : 10001 30 30
# tape01 : 10002 2 32
# tape01 : 10003 30 62
# tape01 : 10004 30 92
# ----------------
# tape02 : 10005 14 14
# tape02 : 10006 30 44
# tape02 : 10007 30 74
# ----------------
# tape03 : 10008 30 30
# tape03 : 10009 17 47
# tape03 : 10010 30 77
# ----------------
# tape04 : 10011 30 30
haut
Cumul d'une colonne avec decoupe a une limite definie - METHODE 1B
#!/bin/bash
# SCRIPT 1 - METHODE 1B
# avantages : court - methode de la coupe du dernier cumul jusqu'a une limite
# avantages : on peut executer un autre script a sa suite
ORIG=0-start.txt
LIMIT=40
SLEEP=0
NBTAPES=10
OUT=1-result-$LIMIT.txt
#####################
# 0-start.txt
# 1001 1
# 2001 2
# 3001 3
# 4001 4
# 5001 5
# 6001 6
# 7001 7
# 8001 8
# 9001 9
# 10001 10
# 11001 11
# 12001 12
# 13001 13
# 14001 14
# 15001 15
# 16001 16
# 17001 17
# 18001 18
# 19001 19
# 20001 20
######################
# deleter les anciens resultats
rm 2-shift*
rm 3-shift*
rm inter*
rm 1-cat-tapes.txt
sleep $SLEEP
# copier l'original pour le 1er fichier
cp $ORIG 0-startcopie.txt
awk '{print $2}' 0-startcopie.txt > 1-shift1.txt
#######################
j=1
until [[ $j -gt $NBTAPES ]] # boucle sur les tapes
do
echo
echo "@@@@ nouvelle tape"
echo " numero de tape : $j"
###### test du "non zero file size"
test -s 1-shift$j.txt # Check if file is nonzero size
var3=`echo $?` # code retour = 0 -> commande bien executee
# echo $var3
if [ "$var3" -eq "0" ] ; then
echo "code retour=0 - bien execute - fichier depart n'est pas vide"
else
echo " ARRET - mal execute - fichier depart vide"
break
fi
###### fin du test du "non zero file size"
# nb lignes
NBLINES=`sed -n -e '$=' 1-shift$j.txt`
NBLINES2=`expr $NBLINES + 1`
echo "nb de lignes du fichier a traiter : $NBLINES2"
sleep $SLEEP
n=$NBLINES2
until [[ $n -lt 1 ]] # boucle sur les lignes cumulees
do
awk '{print x+=$0}' 1-shift$j.txt > 2-shift$j.txt
var1=`sed ''$n','$NBLINES'd' 2-shift$j.txt | tail -1`
echo "valeur de n : $n - limite = $LIMIT - dernier cumul : $var1"
# si le cumul est inferieur a $LIMIT : pause
if [[ $var1 -lt $LIMIT ]] ; then sed ''$n','$NBLINES'd' 2-shift$j.txt > 3-shift$j.txt
# nb lignes de 3-shift$j.txt
var2=`sed -n -e '$=' 3-shift$j.txt`
echo " ---> nb lignes de la tape : 3-shift$j.txt : $var2"
echo " ---> fin de l'ecriture ds la tape : $j"
# deleter les lignes traites : $var2 lignes de 1-shift$j.txt
sed '1,'$var2'd' 1-shift$j.txt > 1-shift`expr $j + 1`.txt
break
fi
sleep $SLEEP
let n=n-1
done # fin de la boucle sur les lignes cumulees
let j=j+1
done # fin de la boucle sur les tapes
###############
echo "################## sortie des 2 boucles"
# assembler les tapes
cat 3-shift* > 1-cat-tapes.txt
paste $ORIG 1-cat-tapes.txt | sed 's/\t/ /g' > inter1.txt
# ajouter trait si colonne 2 = colonne 3
awk '{if($2 == $3) {print "------------------\n"$1" "$2" "$3}
else
print
}' inter1.txt > inter2.txt
# ajouter l'occurence des traits
awk '{
if($1 ~ /^------------------/) {i=i+1 ; print $0" tape "i}
else
{print}
}' inter2.txt > $OUT
# resultat
# ------------------ tape 1
# 1001 1 1
# 2001 2 3
# 3001 3 6
# 4001 4 10
# 5001 5 15
# 6001 6 21
# 7001 7 28
# 8001 8 36
# ------------------ tape 2
# 9001 9 9
# 10001 10 19
# 11001 11 30
# ------------------ tape 3
# 12001 12 12
# 13001 13 25
# 14001 14 39
# ------------------ tape 4
# 15001 15 15
# 16001 16 31
# ------------------ tape 5
# 17001 17 17
# 18001 18 35
# ------------------ tape 6
# 19001 19 19
# 20001 20 39
haut
Cumul d'une colonne avec decoupe a une limite definie - METHODE 2
#!/bin/bash
# SCRIPT 2 - METHODE 2
# Cumul d'une colonne avec decoupe a une limite definie (utilise csplit)
# utilise csplit
######################## parametres
ORIG=0-start.txt
LIMIT=100
NBOFTAPES=10
OUTMETHODE2=1-result-2B-$LIMIT.txt
SLEEP=0
######################## fin des parametres
# ORIG
# 10001 30
# 10002 2
# 10003 30
# 10004 30
# 10005 14
# 10006 30
# 10007 30
# 10008 30
# 10009 17
# 10010 30
# 10011 30
############### ZONE ARRONDIR : pour arrondir des valeurs
# arrondir 0.3 en 0 /// 0.7 en 1 :
# ATTENTION CHANGER LA VIRGULE EN POINT
# script pour arrondir
# while read col1 col2
# do
# awk -v var2="$col2" -v var1="$col1" 'BEGIN { rounded = sprintf("%.0f", var2) ; print var1,rounded }'
# done < fichier entree > 0-start.txt
# exit # pour verifier si le fichier ARRONDI a bien ete fait
################## fin de la zone ARRONDIR
# deleter les anciens resultats
rm 1b-y*
rm 1b-z*-file*
rm 1b-tape-*.txt
rm 1b-in-*.txt
# etat apres la suppression des anciens resultats
echo "apres suppression : nb de 1b-in-* : `ls 1b-in* | wc -l`"
echo "apres suppression : nb de 1b-tape- : `ls 1b-tape-* | wc -l`"
echo "apres suppression : nb de 1b-y : `ls 1b-y* | wc -l`"
echo "apres suppression : nb de 1b-z*-file* : `ls 1b-z*-file* | wc -l`"
# exit # activer pour deleter uniquement (sans faire marcher le script)
echo "les anciens resultats sont deletes"
sleep $SLEEP
########################
# marquer la fin du fichier a lire
sed -e '$a \END' $ORIG > 1b-in-1.txt # ne pas changer la destination
# nb lignes du fichier original
LINES=`sed -n -e '$=' $ORIG`
# boucle sur les tapes
tapecount=1
until [[ $tapecount -gt $NBOFTAPES ]]
do
echo "tapecount= $tapecount"
# boucle sur les lignes
n=1
until [[ $n -gt $LINES ]]
do
echo "n= $n"
csplit -k --prefix=1b-z$n-file 1b-in-$tapecount.txt $n {*} 2>/dev/null
grep "." 1b-z$n-file00 > 1b-y$n
echo
var1=`awk '{print x+=$2}' 1b-y$n | tail -1`
varend=`while read line;do echo $line|grep "END";done < 1b-y$n`
echo "varend=$varend"
echo "cumul de `expr $n - 1` lignes : $var1"
before=`expr $n - 1` ; echo "before= $before" # pour valider le contenu de la tape
before2=`expr $n - 2` ; echo "before2= $before2" # pour un nouveau fichier entree
if [[ $var1 -gt $LIMIT ]] ; then `awk '{print $0,x+=$2}' 1b-y$before > 1b-tape-$tapecount.txt` ;
sed -e '1,'$before2'd' 1b-in-$tapecount.txt > 1b-in-`expr $tapecount + 1`.txt ; break ; fi
if [[ $varend == "END" ]] ; then `awk '{print $0,x+=$2}' 1b-y$before > 1b-tape-$tapecount.txt` ;
# habillage : separer les tapes par un trait
grep -H "." 1b-tape* | sed 's/.txt:/ : /g' |
awk 'BEGIN{OFS=FS=" "}
{if ($1 != var )
{var=$1;e="@"
print $0,e}
else
print $0
}' | sed -e '/@/i\----------------' | sed 's/@//g' | sed 's/1b-//g' > $OUTMETHODE2
cat $OUTMETHODE2
echo "------------------"
echo "----> etat avant de deleter les anciens resultats"
echo "nb de 1b-in-* : `ls 1b-in* | wc -l`"
echo "nb de 1b-tape- : `ls 1b-tape-* | wc -l`"
echo "nb de 1b-y : `ls 1b-y* | wc -l`"
echo "nb de 1b-z*-file* : `ls 1b-z*-file* | wc -l`"
echo "total des 1b = `ls 1b* | wc -l`"
exit ; fi
echo "----------------"
sleep $SLEEP
let n=n+1
done # fin de la boucle sur les lignes
let tapecount=tapecount+1
done # fin de la boucle sur les tapes
########################
# resultat
# ----------------
# tape-1 : 10001 30 30
# tape-1 : 10002 2 32
# tape-1 : 10003 30 62
# tape-1 : 10004 30 92
# -------------
# tape-2 : 10005 14 14
# tape-2 : 10006 30 44
# tape-2 : 10007 30 74
# -------------
# tape-3 : 10008 30 30
# tape-3 : 10009 17 47
# tape-3 : 10010 30 77
# -------------
# tape-4 : 10011 30 30
haut
Cumul d'une colonne avec decoupe a une limite definie - METHODE 3
#!/bin/bash
# SCRIPT 3 - METHODE 3
# Cumul d'une colonne avec decoupe a une limite definie
# but du script : des que le cumul de la colonne 2 atteint $LIMIT, il est envoye dans un fichier 'tape'
# les fichiers "1c-out" sont les cumuls
######################## parametres
# ATTENTION LE FICHIER ENTREE DOIT AVOIR DES VALEURS ARRONDIES (sans . ni ,)
ORIG=0-start.txt # fournir ce fichier
LIMIT=100
NBOFTAPES=10 # estimation nombre de tapes
SLEEP=1
PRINTF=50 # regle le nombre de digits necessaires a la colonne 1 pour l'affichage du resultat final
# resultat
OUTMETHODE3=1-result-3C-$LIMIT.txt
########################### fin des parametres
# fichier entree arrondi
# 10001 30
# 10002 2
# 10003 30
# 10004 30
# 10005 14
# 10006 30
# 10007 30
# 10008 30
# 10009 17
# 10010 30
# 10011 30
############### ZONE ARRONDIR : pour arrondir des valeurs
# arrondir 0.3 en 0 /// 0.7 en 1 :
# ATTENTION CHANGER LA VIRGULE EN POINT
# script pour arrondir
# while read col1 col2
# do
# awk -v var2="$col2" -v var1="$col1" 'BEGIN { rounded = sprintf("%.0f", var2) ; print var1,rounded }'
# done < fichier-entree > fichier-sortie
# exit
################## fin de la zone ARRONDIR
# effacer les anciens resultats de la boucle
rm 1c-cat-tape*
rm 1c-in*
rm 1c-inter*
rm 1c-out*
rm 1c-start-met*
rm 1c-tape* 2>/dev/null
# etat apres la suppression des anciens resultats
echo "apres suppression : nb de 1c-cat-tape* : `ls 1c-cat-tape* | wc -l`"
echo "apres suppression : nb de 1c-in* : `ls 1c-in* | wc -l`"
echo "apres suppression : nb de 1c-out* : `ls 1c-out* | wc -l`"
echo "apres suppression : nb de 1c-start-met* : `ls 1c-start-met* | wc -l`"
echo "apres suppression : nb de 1c-tape* : `ls 1c-tape* | wc -l`"
# exit # activer pour deleter uniquement (sans faire marcher le script)
echo "les anciens resultats sont deletes"
sleep $SLEEP
##########################
# retirer les \r et lignes blanches
sed 's/\r//g' $ORIG | grep "." > 1c-start-met5-inter.txt
# ne pas desactiver cette 2eme copie
cp 1c-start-met5-inter.txt 1c-in1.txt
echo "###################"
echo "ok le fichier entree est pret pour la boucle until : 1c-in1.txt"
sleep $SLEEP
# nb de lignes
echo "nb lignes du fichier entree : `sed -n -e '$=' 1c-in1.txt`"
sleep $SLEEP
# marquer l'arret sur la derniere valeur de la colonne 1 de ORIG
STOP=`sed -n '$p' 1c-in1.txt | awk '{print $1}'`
echo "arret sur STOP : $STOP"
sleep $SLEEP
############### boucle sur les tapes
counter=1
until [ $counter -gt $NBOFTAPES ]
do
echo "##### start tape nb : $counter/$NBOFTAPES"
sleep $SLEEP
awk '{print $1,x+=$2}' 1c-in$counter.txt > 1c-out$counter.txt
########## boucle sur les lignes cumulees
count=1
while read col1 col2
do
if [[ `echo $col2` -lt $LIMIT ]] ; then echo $col1 $col2 ; echo $col1 $col2 > 1c-inter$count
else
cat 1c-inter* > 1c-tape$counter ; newcount=`expr $count - 1` ; echo " ---> tape nb $counter a pris : $newcount idents "
sed '1,'$newcount'd' 1c-in$counter.txt > 1c-in`expr $counter + 1`.txt ; rm 1c-inter* ; break
fi
if [[ `echo $col1` -eq $STOP ]] ; then cat 1c-inter* > 1c-tape$counter ; echo " ---> tape nb $counter a pris : $count idents" ;
# renommer les fichiers tapes
for i in `seq 1 9`
do
mv 1c-tape$i 1c-tape00$i
done
for i in `seq 10 99`
do
mv 1c-tape$i 1c-tape0$i
done
grep -H "." 1c-tape* | sed 's/:/ /g' > 1c-cat-tape1.txt
# la colonne 2 doit avoir au moins 4 digits
awk '{
if(length($2) == 1)
{print $1" 000"$2,$3}
if(length($2) == 2)
{print $1" 00"$2,$3}
if(length($2) == 3)
{print $1" 0"$2,$3}
if(length($2) == 4)
{print $1,$2,$3}
if(length($2) == 5)
{print $1,$2,$3}
}' 1c-cat-tape1.txt | sort > 1c-cat-tape1b.txt
awk '{print $1,$2"@",$3"%"}' 1c-cat-tape1b.txt > 1c-cat-tape1c.txt
# regrouper
awk 'BEGIN {FS=OFS=" "}
!a[$1] {a[$1] = $0;next}
{a[$1] = a[$1] " " $2 " " $3 " " $4 " " $5 " " $6 " " $7 " " $8 " " $9 " " $10}
END {for(i in a) {print a[i]}
}' 1c-cat-tape1c.txt | sort > 1c-cat-tape2.txt
# habillage
sed 's/[0-9]*%//g' 1c-cat-tape2.txt | sed 's/@[ ]*/-/g' | sed 's/ / : /g' > 1c-cat-tape3a.txt
sed 's/[0-9]*@//g' 1c-cat-tape2.txt | sed 's/%[ ]*/ /g' | awk '{print $1" : "$NF" (GB)"}' > 1c-cat-tape3b.txt
paste 1c-cat-tape3a.txt 1c-cat-tape3b.txt | sed 's/\t/ % /g' |
awk -F"%" '{printf ("%-'$PRINTF's %-'$PRINTF's\n",$1,$2)}' | sed 's/[ ]*$//g' | sed 's/1c-//g' > $OUTMETHODE3
echo
echo "##################"
echo " ---> resultat dans $OUTMETHODE3"
cat $OUTMETHODE3
echo "------------------"
echo "---> etat avant de deleter les anciens resultats"
echo "nb de 1c-cat-tape* : `ls 1c-cat-tape* | wc -l`"
echo "nb de 1c-in* : `ls 1c-in* | wc -l`"
echo "nb de 1c-out* : `ls 1c-out* | wc -l`"
echo "nb de 1c-start-met* : `ls 1c-start-met* | wc -l`"
echo "nb de 1c-tape* : `ls 1c-tape* | wc -l`"
echo "------------------"
echo "total des 1c : `ls 1c* | wc -l`"
exit
fi
# sleep $SLEEP
let count=count+1
done < 1c-out$counter.txt
########## fin de la boucle sur les lignes cumulees
let counter=counter+1
done 2>/dev/null
########## fin de la boucle sur les tapes
# resultat
# tape001 : 10001-10002-10003-10004- tape001 : 92 (GB)
# tape002 : 10005-10006-10007- tape002 : 74 (GB)
# tape003 : 10008-10009-10010- tape003 : 77 (GB)
# tape004 : 10011- tape004 : 30 (GB)
haut
Cumul d'une colonne avec decoupe a une limite definie - METHODE 4
#!/bin/bash
# SCRIPT 4 - METHODE 4
# Cumul d'une colonne avec decoupe a une limite definie
# but du script : coller la syntaxe "chiffre+chiffre" de la ligne N-1 a ligne N
# et faire l'addition
######################## parametres
ORIG=0-start.txt # fichier entree contenant 2 colonnes
LIMIT=100
NBOFTAPES=10 # estimation nombre de tapes
SLEEP=1
OUTMETHODE4=1-result-4D-$LIMIT.txt
########################### fin des parametres
# fichier entree arrondi
# 10001 30
# 10002 2
# 10003 30
# 10004 30
# 10005 14
# 10006 30
# 10007 30
# 10008 30
# 10009 17
# 10010 30
# 10011 30
############### ZONE ARRONDIR : pour arrondir des valeurs
# arrondir 0.3 en 0 /// 0.7 en 1 :
# ATTENTION CHANGER LA VIRGULE EN POINT
# script pour arrondir
# while read col1 col2
# do
# awk -v AR2="$col2" -v AR1="$col1" 'BEGIN { rounded = sprintf("%.0f", AR2) ; print AR1,rounded }'
# done < fichier-entree > fichier-sortie
# exit
################## fin de la zone ARRONDIR
# effacer les anciens resultats
rm 1d-in*.txt
rm 1d-tape* 2>/dev/null
rm 1d-z1d-tape*
rm 1d-cat-tape*
rm 1d-start-met*
rm 1d-temp*
# etat apres la suppression des anciens resultats
echo "apres suppression : nb de 1d-cat-tape* : `ls 1d-cat-tape* | wc -l`"
echo "apres suppression : nb de 1d-in* : `ls 1d-in* | wc -l`"
echo "apres suppression : nb de 1d-start-met* : `ls 1d-start-met* | wc -l`"
echo "apres suppression : nb de 1d-tape* : `ls 1d-tape* | wc -l`"
echo "apres suppression : nb de 1d-temp* : `ls 1d-temp* | wc -l`"
echo "apres suppression : nb de 1d-z1d-tape* : `ls 1d-z1d-tape* | wc -l`"
# exit # activer pour deleter uniquement (sans faire marcher le script)
echo "les anciens resultats sont deletes"
sleep $SLEEP
#######################
# retirer les \r et lignes blanches
sed 's/\r//g' $ORIG | grep "." > 1d-start-met4-inter.txt
# copier avec un nom de fichier adapte a la boucle until
cp 1d-start-met4-inter.txt 1d-in1.txt
################## boucle sur les tapes
counter=1
until [[ "$counter" -gt $NBOFTAPES ]]
do
echo "##########"
# code retour de la taille nulle
test -s 1d-in$counter.txt
var2=`echo $?`
if [ "$var2" -eq "0" ] ; then
echo "code retour=0 - ok le fichier 1d-in$counter.txt a une taille non nulle"
else
echo "code retour=1 - le fichier 1d-in$counter.txt a une taille nulle ---> arret" ; break
fi
total=`sed -n '$=' 1d-in$counter.txt`
echo "nb lignes de 1d-in$counter.txt : $total"
rm 1d-tempA 2>/dev/null
# boucle sur les lignes du fichier
N=1
until [[ "$N" -gt "$total" ]]
do
OPA=$N
OPB=`expr $N - 1`
N=`expr $N + 1`
VALA=`sed -n "$OPA p" 1d-in$counter.txt | awk '{print $2}'`
VALB=`sed -n "$OPB p" 1d-tempA | awk '{print $1}'`
line=`echo $VALA+$VALB`
echo $line >> 1d-tempA
add=`cat 1d-tempA | tail -1 | sed 's/+/ + /g'`
echo $add
varA=`eval $(echo "expr" $add "0")`
# echo $varA
if [[ $varA -lt $LIMIT ]] ; then echo $varA >> 1d-tape$counter
else
break
fi
done
# fin de la boucle sur les lignes
# creer un nouveau fichier entree pour un nouveau cumul
varB=`cat 1d-tape$counter | wc -l` ; # echo $varB
sed '1,'$varB'd' 1d-in$counter.txt > 1d-in`expr $counter + 1`.txt
let counter=counter+1
done 2>/dev/null # fin de la boucle sur les tapes
############################
############## habillage
# renommer les fichiers tapes avec 3 digits
for i in `seq 1 9`
do
mv 1d-tape$i 1d-tape00$i
done 2>/dev/null
for i in `seq 10 99`
do
mv 1d-tape$i 1d-tape0$i
done 2>/dev/null
###############
# ecrire nom du fichier devant lignes
for i in 1d-tape*
do
seq=`ls $i`
awk '{print seq,$0}' seq=${seq} $i > 1d-z$i # ne pas oublier d'ajouter 1d-z
done 2>/dev/null
# rassembler les tapes
cat 1d-z1d-tape* > 1d-cat-tape1.txt
awk '{print $1}' $ORIG > 1d-tempcol1.txt
paste 1d-tempcol1.txt 1d-cat-tape1.txt > 1d-cat-tape2.txt
sed 's/\t/ /g' 1d-cat-tape2.txt | awk '{print $2,$1,$3}' > 1d-cat-tape3.txt
# ajouter 1 trait
awk 'BEGIN{OFS=FS=" "}
{if ($1 != var )
{var=$1;e="@"
print $0,e}
else
print $0
}' 1d-cat-tape3.txt | sed -e '/@/i\----------------' | sed 's/@//g' | sed 's/1d-//g' > $OUTMETHODE4
echo " ---> resultat dans $OUTMETHODE4"
cat $OUTMETHODE4
#####################
echo "------------------"
echo "---> etat avant de deleter les anciens resultats"
echo "nb de 1d-cat-tape* : `ls 1d-cat-tape* | wc -l`"
echo "nb de 1d-in* : `ls 1d-in* | wc -l`"
echo "nb de 1d-start-met* : `ls 1d-start-met* | wc -l`"
echo "nb de 1d-tape* : `ls 1d-tape* | wc -l`"
echo "nb de 1d-temp* : `ls 1d-temp* | wc -l`"
echo "nb de 1d-z1d-tape* : `ls 1d-z1d-tape* | wc -l`"
echo "------------------"
echo "total des 1d : `ls 1d* | wc -l`"
# resultat
# ----------------
# tape001 10001 30
# tape001 10002 32
# tape001 10003 62
# tape001 10004 92
# ----------------
# tape002 10005 14
# tape002 10006 44
# tape002 10007 74
# ----------------
# tape003 10008 30
# tape003 10009 47
# tape003 10010 77
# ----------------
# tape004 10011 30
haut
Cumul d'une colonne avec decoupe a une limite definie - METHODE 5
#!/bin/bash
# SCRIPT 3 - METHODE 3
# but du script : si le cumul atteint 1 limite
# il est ecrit dans un fichier 'tape'
# utilise le tableau de la ligne f[NR]
###################### parametres
ORIG=0-start.txt
LIMIT=100
NBOFTAPES=10
SLEEP=1
# resultat
OUTMETHODE5=1-result-5E-$LIMIT.txt
#################### fin des parametres
# fichier entree arrondi
# 10001 30
# 10002 2
# 10003 30
# 10004 30
# 10005 14
# 10006 30
# 10007 30
# 10008 30
# 10009 17
# 10010 30
# 10011 30
############### ZONE ARRONDIR : pour arrondir des valeurs
# arrondir 0.3 en 0 /// 0.7 en 1 :
# ATTENTION CHANGER LA VIRGULE EN POINT
# script pour arrondir
# while read col1 col2
# do
# awk -v var2="$col2" -v var1="$col1" 'BEGIN { rounded = sprintf("%.0f", var2) ; print var1,rounded }'
# done < fichier-entree > fichier-sortie
# exit
################## fin de la zone ARRONDIR
# effacer les anciens resultats de la boucle
rm 1e-in*
rm 1e-incumul*
rm 1e-nbligne*
rm 1e-tape-all*
rm 1e-tape-paste-all*
rm 1e-tape*
rm 1e-z1e-tape*
rm 1e-cat-tape*
rm 1e-start-met*
# etat apres la suppression des anciens resultats
echo "apres suppression : nb de 1e-in* : `ls 1e-in* | wc -l`"
echo "apres suppression : nb de 1e-nbligne* : `ls 1e-nbligne* | wc -l`"
echo "apres suppression : nb de 1e-tape* : `ls 1e-tape* | wc -l`"
echo "apres suppression : nb de 1e-z1e-tape* : `ls 1e-z1e-tape* | wc -l`"
echo "apres suppression : nb de 1e-cat-tape* : `ls 1e-cat-tape* | wc -l`"
echo "apres suppression : nb de 1e-start-met* : `ls 1e-start-met* | wc -l`"
# exit # activer pour deleter uniquement (sans faire marcher le script)
echo "les anciens resultats sont deletes"
sleep $SLEEP
#######################
# retirer les lignes vides
grep -v "^$" $ORIG > 1e-start-met2-inter.txt
# garder l'original
cp 1e-start-met2-inter.txt 1e-in1.txt
echo "###################"
echo "ok le fichier 'start' est pret pour la boucle until : 1e-in1.txt"
sleep $SLEEP
############### boucle sur les tapes
counter=1
until [[ $counter -gt $NBOFTAPES ]]
do
echo "boucle $counter"
# nb lignes
sed -n -e '$=' 1e-in$counter.txt > 1e-nbligne$counter
echo "nb de lignes restant pour faire un nouveau cumul : $(cat 1e-nbligne$counter)"
# tester si le fichier est de taille non nulle
test -s 1e-nbligne$counter
verif=`echo $?`
if [ "$verif" -eq "0" ] ; then
echo "code retour=$verif - bien execute - fichier taille non nulle"
else
echo "code retour=$verif - mauvais - fichier taille nulle" ; break
fi
# la 3eme colonne est le cumul
awk '
f[NR]=$0
g[NR]=$2
END { for (i=1;i<=NR;i++)
print f[i],x+=g[i] }
' 1e-in$counter.txt | tail -$(cat 1e-nbligne$counter) > 1e-incumul$counter
# arret si cumul > $LIMIT --> creation de la tape
awk '
f[NR]=$1
g[NR]=($3 < '$LIMIT' ? $3 : "@")
END { for (i=1;i<=NR;i++)
print f[i],g[i] }
' 1e-incumul$counter | tail -$(cat 1e-nbligne$counter) | grep -v "@" > 1e-tape$counter.txt
# all = tape + @
awk '
f[NR]=$1
g[NR]=($3 < '$LIMIT' ? $3 : "@")
END { for (i=1;i<=NR;i++)
print f[i],g[i] }
' 1e-incumul$counter | tail -$(cat 1e-nbligne$counter) > 1e-tape-all$counter
# paste 1e-in1.txt all
paste 1e-in$counter.txt 1e-tape-all$counter > 1e-tape-paste-all$counter
grep "@" 1e-tape-paste-all$counter | awk '{print $1,$2}' > 1e-in`expr $counter + 1`.txt
echo "-----"
let counter=counter+1
done
################## fin de la boucle sur les tapes
# habillage
# renommer les fichiers tapes avec 3 digits
for i in `seq 1 9`
do
mv 1e-tape$i.txt 1e-tape00$i.txt
done 2>/dev/null
for i in `seq 10 99`
do
mv 1e-tape$i.txt 1e-tape0$i.txt
done 2>/dev/null
#################
# ecrire le nom du fichier devant chaque ligne
# cut -c3-9 # <-- attention changer si pas bon
# cut -c4-10
for i in 1e-tape*.txt
do
seq=`ls $i|cut -c4-10`
awk '{print seq,$0}' seq=${seq} $i > 1e-z$i # ne pas oublier d'ajouter 1e-z
done
cat 1e-z1e-tape*.txt > 1e-cat-tape1.txt
##################
# separer les tapes par un trait
awk 'BEGIN{OFS=FS=" "}
{if ($1 != var )
{var=$1;e="@"
print $0,e}
else
print $0
}' 1e-cat-tape1.txt | sed -e '/@/i\----------------' | sed 's/@//g' > $OUTMETHODE5
echo "##################"
echo " ---> resultat dans $OUTMETHODE5"
cat $OUTMETHODE5
#####################
echo "------------------"
echo "---> etat avant de deleter les anciens resultats"
echo "nb de 1e-in* : `ls 1e-in* | wc -l`"
echo "nb de 1e-nbligne* : `ls 1e-nbligne* | wc -l`"
echo "nb de 1e-tape* : `ls 1e-tape* | wc -l`"
echo "nb de 1e-z1e-tape* : `ls 1e-z1e-tape* | wc -l`"
echo "nb de 1e-cat-tape* : `ls 1e-cat-tape* | wc -l`"
echo "nb de 1e-start-met* : `ls 1e-start-met* | wc -l`"
echo "------------------"
echo "total des 1e : `ls 1e* | wc -l`"
# resultat
# ----------------
# tape001 10001 30
# tape001 10002 32
# tape001 10003 62
# tape001 10004 92
# ----------------
# tape002 10005 14
# tape002 10006 44
# tape002 10007 74
# ----------------
# tape003 10008 30
# tape003 10009 47
# tape003 10010 77
# ----------------
# tape004 10011 30
haut
Cumul d'une colonne avec decoupe a une limite definie - METHODE 6
#!/bin/bash
# SCRIPT 6 - METHODE 6
# Cumul d'une colonne avec decoupe a une limite definie
# but du script : des que le cumul de la colonne 2 atteint $LIMIT, il est envoye dans un fichier 'tape'
# les fichiers "out" sont les cumuls
######################## parametres
ORIG=0-start.txt
LIMIT=100
NBOFTAPES=10
SLEEP=2
OUTMETHODE6=1-result-6F-$LIMIT.txt
####################### fin des parametres
# ORIG
# 10001 30
# 10002 2
# 10003 30
# 10004 30
# 10005 14
# 10006 30
# 10007 30
# 10008 30
# 10009 17
# 10010 30
# 10011 30
############### ZONE ARRONDIR : pour arrondir des valeurs
# arrondir 0.3 en 0 /// 0.7 en 1 :
# ATTENTION CHANGER LA VIRGULE EN POINT
# script pour arrondir
# while read col1 col2
# do
# awk -v var2="$col2" -v var1="$col1" 'BEGIN { rounded = sprintf("%.0f", var2) ; print var1,rounded }'
# done < fichier-entree > fichier-sortie
# exit
################## fin de la zone ARRONDIR
# exit # activer pour connaitre l'etat avant la suppression
# deleter les resultats precedents
rm 1f-in*.txt
rm 1f-inter*.txt
rm 1f-pretape*
rm 1f-tape*
rm 1f-cattapes*.txt
rm 1f-start-met*.txt
# etat apres la suppression des anciens resultats
echo "apres suppression : nb de 1f-cattapes* : `ls 1f-cattapes* | wc -l`"
echo "apres suppression : nb de 1f-in* : `ls 1f-in* | wc -l`"
echo "apres suppression : nb de 1f-pretape* : `ls 1f-pretape | wc -l`"
echo "apres suppression : nb de 1f-start-met* : `ls 1f-start-met* | wc -l`"
echo "apres suppression : nb de 1f-tape* : `ls 1f-tape* | wc -l`"
# exit # activer pour deleter uniquement (sans faire marcher le script)
echo "les anciens resultats sont deletes"
sleep $SLEEP
#########################
# retirer le dernier retour chariot
sed 's/\r//g' $ORIG | grep "." > 1f-start-met1-inter.txt
# inverser le fichier (la 1ere ligne devient derniere)
awk '{ arr[NR]=$0 }
END {
for (i=NR; i>=1; i--)
print arr[i]
}' 1f-start-met1-inter.txt | sed 's/\r//g' > 1f-in1.txt # cette sortie est codee en dur (ne pas changer)
############## boucle sur les tapes
COUNTTAPES=1
until [[ "$COUNTTAPES" -gt "$NBOFTAPES" ]]
do
echo "--> counttapes=$COUNTTAPES"
##### test sur existence de 1f-in$COUNTTAPES.txt
test -e 1f-in$COUNTTAPES.txt
check=`echo $?` ; echo "code retour = $check"
if [[ "$check" -eq "0" ]] ; then echo "ok fichier : 1f-in$COUNTTAPES.txt existe"
else
echo "1f-in$COUNTTAPES.txt n'existe pas"
echo "ok copie du reliquat de 1f-pretapecumul`expr $COUNTTAPES - 1`.txt dans 1f-tape`expr $COUNTTAPES - 1`.txt"
cp 1f-pretapecumul`expr $COUNTTAPES - 1`.txt 1f-tape`expr $COUNTTAPES - 1`.txt
############ habillage
cat 1f-tape*.txt > 1f-cattapes1.txt
TOTALCAT=`sed -n -e '$=' 1f-cattapes1.txt` ; echo "nombre de lignes : $TOTALCAT"
LINE=1
until [[ "$LINE" -gt "$TOTALCAT" ]]
do
AFTER=`expr $LINE + 1`
if [[ `awk 'NR == '$AFTER' {print $3}' 1f-cattapes1.txt` -lt `awk 'NR == '$LINE' {print $3}' 1f-cattapes1.txt` ]] ;
then echo `awk 'NR == '$LINE' {print $0}' 1f-cattapes1.txt` ;
echo "-----------"
else
echo `awk 'NR == '$LINE' {print $0}' 1f-cattapes1.txt`
fi
let LINE=LINE+1
done > 1f-cattapes2.txt
# retirer le dernier trait
if [[ `sed -n '$p' 1f-cattapes2.txt` = "-----------" ]] ; then sed '$d' 1f-cattapes2.txt > 1f-cattapes3.txt ; fi
# ajouter un trait en ligne 1
sed -e '1i \-----------' 1f-cattapes3.txt > 1f-cattapes4.txt
# numeroter les occurrences des tapes
awk '{
if($0 ~ /^-----/) {i=i+1 ; print $0" tape "i}
else
{print}
}' 1f-cattapes4.txt > $OUTMETHODE6
echo "################"
echo "---> resultat dans : $OUTMETHODE6 :"
cat $OUTMETHODE6
# etat avant de deleter les anciens resultats
echo "------------------"
echo "nb de 1f-cattapes* : `ls 1f-cattapes* | wc -l`"
echo "nb de 1f-in* : `ls 1f-in* | wc -l`"
echo "nb de 1f-pretape* : `ls 1f-pretape* | wc -l`"
echo "nb de 1f-start-met* : `ls 1f-start-met* | wc -l`"
echo "nb de 1f-tape* : `ls 1f-tape* | wc -l`"
echo "total = `ls 1f* | wc -l`"
break
##### fin de l'habillage
fi
##### fin du test sur existence de 1f-in$COUNTTAPES.txt
NBLINES=`sed -n -e '$=' 1f-in$COUNTTAPES.txt` ; echo "nombre de lignes : $NBLINES"
######## boucle sur les lignes du fichier entree
COUNT=1
until [[ "$COUNT" -gt "$NBLINES" ]]
do
echo "--> count=$COUNT"
# arret s'il n'y a plus de fichier entree
test -e 1f-in$COUNTTAPES.txt
check2=`echo $?` # ; echo $check2
if [[ "$check2" -eq "1" ]] ; then exit ; fi
cat 1f-in$COUNTTAPES.txt | tail -$COUNT | head -1 >> 1f-inter$COUNTTAPES.txt
cp 1f-inter$COUNTTAPES.txt 1f-pretape$COUNTTAPES.txt
awk '{print $1,$2,x+=$2}' 1f-pretape$COUNTTAPES.txt > 1f-pretapecumul$COUNTTAPES.txt
CUMUL=`cat 1f-pretapecumul$COUNTTAPES.txt | tail -1 | awk '{print $3}'`
echo "$CUMUL"
if [[ "$CUMUL" -gt "$LIMIT" ]] ; then cat 1f-pretapecumul$COUNTTAPES.txt |
sed '$d' > 1f-tape$COUNTTAPES.txt ;
STOP=`expr $COUNT - 1` # ; echo $STOP ;
sed -n -e :a -e '1,'$STOP'!{P;N;D;};N;ba' 1f-in$COUNTTAPES.txt > 1f-in`expr $COUNTTAPES + 1`.txt ; break ; fi
let COUNT=COUNT+1
done
######### fin boucle sur les lignes du fichier entree
echo "############## fin de la tape : $COUNTTAPES"
echo
sleep $SLEEP
let COUNTTAPES=COUNTTAPES+1
done
##### fin de la boucle sur les tapes
# resultat
# ----------- tape 1
# 10001 30 30
# 10002 2 32
# 10003 30 62
# 10004 30 92
# ----------- tape 2
# 10005 14 14
# 10006 30 44
# 10007 30 74
# ----------- tape 3
# 10008 30 30
# 10009 17 47
# 10010 30 77
# ----------- tape 4
# 10011 30 30
haut
Cumul d'une colonne avec decoupe a une limite definie - METHODE 7
#!/bin/bash
# SCRIPT 7 - METHODE 7
# boucle inverse sur les lignes dans une boucle sur les tapes
############ parametres
LIMIT=100
NBOFTAPES=10
ORIGALL=0-start.txt
ORIGA=0-starta.txt # colonne 1
ORIGB=0-startb.txt # colonne 2
OUTMETHODE7=1-result-7G-$LIMIT.txt
SLEEP=0
######################## fin des parametres
# ORIG
# 10001 30
# 10002 2
# 10003 30
# 10004 30
# 10005 14
# 10006 30
# 10007 30
# 10008 30
# 10009 17
# 10010 30
# 10011 30
############### ZONE ARRONDIR : pour arrondir des valeurs
# arrondir 0.3 en 0 /// 0.7 en 1 :
# ATTENTION CHANGER LA VIRGULE EN POINT
# script pour arrondir
# while read col1 col2
# do
# awk -v var2="$col2" -v var1="$col1" 'BEGIN { rounded = sprintf("%.0f", var2) ; print var1,rounded }'
# done < fichier entree > 0-start.txt
# exit # pour verifier si le fichier ARRONDI a bien ete fait
################## fin de la zone ARRONDIR
# deleter les anciens resultats
rm 1g-cat-result*
rm 1g-cat-1g-z1g-*
rm 1g-inter*
rm 1g-start*
rm 1g-z1g-inter*
# etat apres la suppression des anciens resultats
echo "apres suppression : nb de 1g-cat-result* : `ls 1g-cat-result* | wc -l`"
echo "apres suppression : nb de 1g-cat-1g-z1g-* : `ls 1g-cat-z1g-* | wc -l`"
echo "apres suppression : nb de 1g-inter* : `ls 1g-inter* | wc -l`"
echo "apres suppression : nb de 1g-start* : `ls 1g-start* | wc -l`"
echo "apres suppression : nb de 1g-z1g-inter* : `ls 1g-z1g-inter* | wc -l`"
# exit # activer pour deleter uniquement (sans faire marcher le script)
echo "les anciens resultats sont deletes"
sleep $SLEEP
##################
# separer les colonnes
awk '{print $1}' $ORIGALL > $ORIGA
awk '{print $2}' $ORIGALL > $ORIGB
cp $ORIGB 0-sauv-orig.txt
cp 0-sauv-orig.txt 1g-start1.txt
# boucle sur le numero de tape (start 1 2 ..)
g=1
until [[ $g -gt "$NBOFTAPES" ]]
do
echo
echo "%%%%%%%%%%%%%%"
echo "numero de tape : $g"
NBLINES=`cat 1g-start$g.txt | wc -l`
echo " nb lignes du fichier depart : 1g-start$g.txt : $NBLINES (ce nb est copie pour le conserver)"
# conserver l'original du nb de lignes de depart (voir a la fin : 1g-start2 , 3 , ...
NEWNBLINES=$NBLINES
sleep $SLEEP
# renommer 1g-start$g.txt en 1g-start$g-$NBLINES.txt
mv 1g-start$g.txt 1g-start$g-$NBLINES.txt
echo " fichier depart renomme (nb lignes colle au nom du fichier) : 1g-start$g.txt -> 1g-start$g-$NBLINES.txt"
sleep $SLEEP
####################
# boucle inverse sur le nombre de lignes
n=$NBLINES
until [[ $n -lt "1" ]]
do
echo " boucle inverse : ligne $n/$NEWNBLINES "
echo " fichier traite : 1g-start$g-$n.txt"
echo " g = $g (boucle sur les tapes)"
echo " n = $n (boucle inverse sur les lignes)"
awk '{ arr[NR]=$1 ; sum+=$1}
END {
for (i=1; i<=NR; i++)
print arr[i],sum
}' 1g-start$g-$n.txt > 1g-inter$g-$n.txt # | sed '10,$d'
echo " resultat du traitement (fichier : 1g-inter$g-$n.txt : (a droite: cumul total des lignes colonne 1)"
cat 1g-inter$g-$n.txt
sleep $SLEEP
sed ''$n',$d' 1g-inter$g-$n.txt | awk '{print $1}' > 1g-start$g-`expr $n - 1`.txt
# echo "fin boucle nb lignes - fichier suivant : 1g-start$g-`expr $n - 1`.txt"
# sleep $SLEEP
let n=n-1
done # fin boucle sur le nombre de lignes
#####################
# ajouter "0" si 1 digit ds noms fichiers : 1g-inter$g-*
for i in `seq 1 9`
do
mv 1g-inter$g-$i.txt 1g-inter$g-0$i.txt 2>/dev/null
done
echo "-------- habillage de la tape : $g"
echo " ok ajout de '0' aux noms de fichiers (de 1 a 9) : 1g-inter$g -> 1g-inter0$g"
sleep $SLEEP
####################
# avant d'assembler les fichiers : marquer les lignes (avec @)
for i in `ls 1g-inter$g-*`
do
awk '{
if($2 < '$LIMIT') {print $0" @"}
else
{print}
}' $i > 1g-z$i
done
echo " ajout de @ a la fin des lignes de : 1g-inter$g-* ds 1g-z1g-inter$g-* si le cumul est < $LIMIT"
echo "creation de fichiers 1g-z1g-inter$g-*"
sleep $SLEEP
grep -H "." 1g-z1g-inter$g-* | grep "@" > 1g-cat-1g-z1g-inter$g-a.txt
echo " ok les fichiers 1g-z1g-inter$g-* contenant @ sont ds : 1g-cat-1g-z1g-inter$g-a.txt"
sleep $SLEEP
##################
# isoler le dernier 1g-inter$g avant $LIMIT
# marquer les occurrences de la colonne 2
awk 'BEGIN{OFS=FS=" "}
{if ($2 != var )
{var=$2;count++};print $0,count}
' 1g-cat-1g-z1g-inter$g-a.txt | sed 's/:/ /g' > 1g-cat-1g-z1g-inter$g-b.txt
##################
echo " ok les occurrences sont marquees pour capturer la maxi"
sleep $SLEEP
# capturer le dernier champ et prendre le maxi
dern=`cat 1g-cat-1g-z1g-inter$g-b.txt | tail -1 | awk '{print $NF}'` # echo $dern
awk '$NF == '$dern' {print}' 1g-cat-1g-z1g-inter$g-b.txt | awk -F"@" '{print $1}' > 1g-cat-1g-z1g-inter$g-c.txt
echo " ok l'occurrence maxi est capturee ds : 1g-cat-1g-z1g-inter$g-c.txt :"
cat 1g-cat-1g-z1g-inter$g-c.txt
sleep $SLEEP
# echo $dern # correspond au nb lignes a deleter ds $ORIGIN
# deleter le nb lignes ($dern) dans 1g-start$g-$NBLINES.txt
sed '1,'$dern'd' 1g-start$g-$NEWNBLINES.txt > 1g-start`expr $g + 1`.txt
##################
# Check if file is nonzero size
test -s 1g-start`expr $g + 1`.txt # Check if file is nonzero size
var2=`echo $?` # code retour = 0 -> commande bien executee -> Check if file is nonzero size
echo " --> test sur nonzero size du fichier suivant a lire : code retour= $var2"
if [ "$var2" -eq "0" ] ; then
echo " code retour=0 - bien execute - file '1g-start`expr $g + 1`.txt' is nonzero size"
else
echo " code retour=1 - mal execute - file is zero size - ARRET"
cat 1g-cat-1g-z1g-inter*-c.txt > 1g-cat-result1.txt
####################
# habillage
sed 's/1g-z1g-inter/tape /g' 1g-cat-result1.txt | sed 's/[.-]/ /g' | awk '{$3=$4=""} {print $0}' > 1g-cat-result2a.txt
paste $ORIGA 1g-cat-result2a.txt | awk '{print $2,$3,$1,$4,$5}' > 1g-cat-result2b.txt
# prendre un marqueur different de @ : %
awk 'BEGIN{OFS=FS=" "}
{if ($2 != var )
{var=$2;e="%"
print $0,e}
else
print $0
}' 1g-cat-result2b.txt | sed -e '/%/i\----------------' | sed 's/%//g' > $OUTMETHODE7
echo "resultat ds : $OUTMETHODE7"
cat $OUTMETHODE7
echo "------------------"
echo "---> etat avant de deleter les anciens resultats"
echo " nb de 1g-cat-result* : `ls 1g-cat-result* | wc -l`"
echo " nb de 1g-cat-1g-z1g-* : `ls 1g-cat-1g-z1g-* | wc -l`"
echo " nb de 1g-inter* : `ls 1g-inter* | wc -l`"
echo " nb de 1g-start* : `ls 1g-start* | wc -l`"
echo " nb de 1g-z1g-inter* : `ls 1g-z1g-inter* | wc -l`"
echo "------------------"
echo "total des 1g : `ls 1g* | wc -l`"
exit # sortie si fichier 1g-start vide
fi
sleep $SLEEP
#################
# info
echo "boucle numero de tape - fichier a lire : 1g-start`expr $g + 1`.txt"
let g=g+1
done # fin de la boucle sur le numero de tape (start 1 2 ..)
# resultat
# tape 1 10001 30 92
# tape 1 10002 2 92
# tape 1 10003 30 92
# tape 1 10004 30 92
# ----------------
# tape 2 10005 14 74
# tape 2 10006 30 74
# tape 2 10007 30 74
# ----------------
# tape 3 10008 30 77
# tape 3 10009 17 77
# tape 3 10010 30 77
# ----------------
# tape 4 10011 30 30
haut
Cumul d'une colonne avec decoupe a une limite definie - METHODE 8
#!/bin/bash
# SCRIPT 8 - METHODE 8
# but du script : une colonne mise sur une ligne
# addition des colonnes , arret jusqu'a une limite
############## parametres
# entree
ORIG=0-start.txt # fichier entree contenant 2 colonnes
LIMIT=100
NBOFTAPES=10
SLEEP=1
# sortie
OUTMETHODE8=1-result-8H-$LIMIT.txt
############## fin des parametres
# fichier entree arrondi
# 10001 30
# 10002 2
# 10003 30
# 10004 30
# 10005 14
# 10006 30
# 10007 30
# 10008 30
# 10009 17
# 10010 30
# 10011 30
############### ZONE ARRONDIR : pour arrondir des valeurs
# arrondir 0.3 en 0 /// 0.7 en 1 :
# ATTENTION CHANGER LA VIRGULE EN POINT
# script pour arrondir
# while read col1 col2
# do
# awk -v AR2="$col2" -v AR1="$col1" 'BEGIN { rounded = sprintf("%.0f", AR2) ; print AR1,rounded }'
# done < fichier-entree > fichier-sortie
# exit
################## fin de la zone ARRONDIR
# deleter les anciens resultats (avant de creer le fichier de demarrage : in1.txt)
rm 1h-in*
rm 1h-copietape*
rm 1h-lignetape*
rm 1h-nbcolpassage*
rm 1h-prein*
rm 1h-start-met*
rm 1h-tape*
# etat apres la suppression des anciens resultats
echo "apres suppression : nb de 1h-copietape* : `ls 1h-copietape* | wc -l`"
echo "apres suppression : nb de 1h-in* : `ls 1h-in* | wc -l`"
echo "apres suppression : nb de 1h-lignetape* : `ls 1h-lignetape* | wc -l`"
echo "apres suppression : nb de 1h-nbcolpassage* : `ls 1h-nbcolpassage* | wc -l`"
echo "apres suppression : nb de 1h-prein* : `ls 1h-prein* | wc -l`"
echo "apres suppression : nb de 1h-start-met* : `ls 1h-start-met* | wc -l`"
echo "apres suppression : nb de 1h-tape* : `ls 1f-tap* | wc -l`"
# exit # activer pour deleter uniquement (sans faire marcher le script)
echo "les anciens resultats sont deletes"
sleep $SLEEP
##################
###################
# transformer le "fichier-entree" pour mettre la colonne 2 sur une ligne
awk '{print $2}' $ORIG > 1h-start-met6-inter1.txt
sed '{:a;$!N;s_\n_ _;ta}' 1h-start-met6-inter1.txt > 1h-start-met6-inter2.txt # fichier entree ok (sur une ligne)
# nb de champs
echo "nb de champs : `awk '{print NF}' 1h-start-met6-inter2.txt`"
echo $SLEEP
###############
# garder l'original et creer le fichier de demarrage : 1h-in1.txt
cp 1h-start-met6-inter2.txt 1h-in1.txt
echo "###################"
echo "ok copie de l'original ds 1h-in1.txt"
echo "###################"
sleep $SLEEP
############# boucle sur le nombre de tapes
counter=1
until [ $counter -gt $NBOFTAPES ]
do
echo "boucle $counter"
echo "lecture de 1h-in$counter.txt : "
cat 1h-in$counter.txt
# nb de colonnes
awk '{print NF}' 1h-in$counter.txt > 1h-nbcolpassage$counter.txt
echo "nb de colonnes du passage $counter : `cat 1h-nbcolpassage$counter.txt`"
sleep $SLEEP
1h-nbcolpassage$counter=$(cat 1h-nbcolpassage$counter.txt) 2>/dev/null
######## boucle sur le nombre total de colonnes
n=1
until [ $n -gt `cat 1h-nbcolpassage$counter.txt` ]
do
# boucle pour creer des tapes
while read line
do
echo $line | cut -d" " -f$n >> 1h-inter$counter
if [[ `cat 1h-inter$counter | awk '{print $0,x+=$0}' | awk '{print $2}' | tail -n1` -lt $LIMIT ]] ;
then echo `cat 1h-inter$counter |
awk '{print $0,x+=$0}' | awk '{print $2}' | tail -n1` >> 1h-tape$counter ; fi
cp 1h-tape$counter 1h-copietape$counter
cat 1h-copietape$counter | wc -l > 1h-lignetape$counter
varcolues$counter=$(cat 1h-lignetape$counter) 2>/dev/null
echo `echo $line | awk '{for(n=1;n<='$varcolues$(cat 1h-lignetape$counter)';n++) $n="" ; print}' | cut -d" " -f$n` >> 1h-prein`expr $counter + 1`.txt
done < 1h-in$counter.txt
# fin de la boucle pour creer des tapes
let n=n+1
done
######## fin de la boucle sur le nombre total de colonnes
# la colonne devient ligne
grep "." 1h-prein`expr $counter + 1`.txt | sed '{:a;$!N;s_\n_ _;ta}' > 1h-in`expr $counter + 1`.txt
echo "creation de 1h-in`expr $counter + 1`.txt : `cat 1h-in$(expr $counter + 1).txt | sed '/./!d'`" 2>/dev/null
######### test si arret
# tester si fichier 1h-in`expr $counter + 1`.txt est vide ou non
test -s 1h-in`expr $counter + 1`.txt # Check if file is nonzero size
var1=`echo $?` # code retour = 0 -> commande bien executee -> Check if file is nonzero size
# echo $var1
if [ "$var1" -eq "0" ] ; then
echo "code retour=0 - bien execute - file is nonzero size - ok 1h-in`expr $counter + 1`.txt"
echo "----------------"
else
echo "code retour=1 - mal execute - file is zero size - pas de 1h-in`expr $counter + 1`.txt - arret" ; break
fi
let counter=counter+1
done
############# fin de la boucle sur le nombre de tapes
######################
# habillage
# mettre 3 digits dans les noms des fichiers tapes
for i in `seq 1 9`
do
mv 1h-tape$i 1h-tape00$i 2>/dev/null
done
for i in `seq 10 99`
do
mv 1h-tape$i 1h-tape0$i 2>/dev/null
done
# rassembler toutes les tapes
cat 1h-tape* > 1h-inter1-met5.txt
# coller la colonne 1 originale a 1h-inter1-met5.txt
cat $ORIG | awk '{print $1}' > 1h-inter1b-met5.txt
paste 1h-inter1b-met5.txt 1h-inter1-met5.txt > 1h-inter2-met5.txt
# nettoyer et ajouter 1 retour chariot a la fin de 1h-inter2-met5.txt
sed 's/\t/ /g' 1h-inter2-met5.txt | sed 's/^ //g' | grep "." | sed -e '$a \\r' > 1h-inter3-met5.txt
total=`sed -n '$=' 1h-inter3-met5.txt`
######## boucle sur le fichier du resultat
# separer les tapes par 1 trait
N=1
until [ $N -eq $total ]
do
S1=$N
S2=`expr $N + 1`
N=$S2
VAL1A=`sed -n "$S1 p" 1h-inter3-met5.txt`
VAL1B=`sed -n "$S1 p" 1h-inter3-met5.txt | awk '{print $2}'`
VAL2A=`sed -n "$S2 p" 1h-inter3-met5.txt`
VAL2B=`sed -n "$S2 p" 1h-inter3-met5.txt | awk '{print $2}'`
if [[ $VAL2B -lt $VAL1B ]] ; then echo $VAL1A ; echo "----------"
else
echo $VAL1A
fi
done > 1h-inter4-met5.txt
######## fin de la boucle sur le fichier du resultat
# deleter le trait de la derniere ligne
if [[ `sed -n '$p' 1h-inter4-met5.txt` = "----------" ]] ; then sed '$d' 1h-inter4-met5.txt > 1h-inter5-met5.txt ; fi
# ajouter un trait en ligne 1
sed -e '1i \---------' 1h-inter5-met5.txt > 1h-inter6-met5.txt
# numeroter les occurrences des tapes
awk '{
if($0 ~ /^-----/) {i=i+1 ; print $0"tape "i}
else
{print}
}' 1h-inter6-met5.txt > 1h-inter7-met5.txt
# nombre de tapes
info3=`grep "tape" 1h-inter7-met5.txt | tail -1 | cut -d" " -f2`
echo "##################"
echo "nombre total de tapes : $info3"
# copie du resultat
cp 1h-inter7-met5.txt $OUTMETHODE8
echo "##################"
echo " ---> resultat dans $OUTMETHODE8"
cat $OUTMETHODE8
echo "------------------"
echo "---> etat avant de deleter les anciens resultats"
echo "nb de 1h-copietape* : `ls 1h-copietape* | wc -l`"
echo "nb de 1h-in* : `ls 1h-in* | wc -l`"
echo "nb de 1h-lignetape* : `ls 1h-lignetape* | wc -l`"
echo "nb de 1h-nbcolpassage* : `ls 1h-nbcolpassage* | wc -l`"
echo "nb de 1h-prein* : `ls 1h-prein* | wc -l`"
echo "nb de 1h-start-met* : `ls 1h-start-met* | wc -l`"
echo "nb de 1h-tape* : `ls 1h-tape* | wc -l`"
echo "------------------"
echo "total des 1h : `ls 1h* | wc -l`"
# resultat
# ---------tape 1
# 10001 30
# 10002 32
# 10003 62
# 10004 92
# ----------tape 2
# 10005 14
# 10006 44
# 10007 74
# ----------tape 3
# 10008 30
# 10009 47
# 10010 77
# ----------tape 4
# 10011 30
haut
Lire les colonnes avec "while read col1 col2 ..."
# in.txt
line1 col2 data1
line2 col2 data2
line3 col2 data3
#!/bin/bash
while read col1 col2 # col2 se voit attribuer tout le reste des colonnes
do
echo $col2
done < in.txt
# resultat
col2 data1
col2 data2
col2 data3
haut
Repeter un nombre de fois different une valeur qui s'incremente de 1
#!/bin/bash
################ parametres
# valeurs de debut et de fin du compteur incremente de 1 :
first=810828 # 1ere valeur
last=810830 # derniere valeur
OCCUR=in-occur.txt # le dernier retour chariot sera delete automatiquement
OUT=out.txt
# contenu de OCCUR ( occurrence de chaque valeur )
# 3 # 1ere valeur repetee 3 fois
# 2 # 2eme valeur repetee 2 fois
# 4 # 3eme valeur repetee 4 fois
################ fin des parametres
# deleter le dernier retoue chariot
cat $OCCUR | grep "." > temp-occur.txt
# creation du compteur qui s'incremente de 1
seq $first $last > temp1.txt
# temp1.txt
# 810828
# 810829
# 810830
# fichier de base
paste temp1.txt temp-occur.txt > temp2.txt
# temp2.txt
# 810828 3
# 810829 2
# 810830 4
# creation du compteur des occurrences
while read line
do
seq 1 $line
done < temp-occur.txt > temp3.txt
# temp3.txt
# 1
# 2
# 3
# 1
# 2
# 1
# 2
# 3
# 4
###############
# boucle
while read col1 col2
do
COUNTER=1
until [ $COUNTER -gt $col2 ]
do
echo $col1
let COUNTER=COUNTER+1
done
done < temp2.txt > temp4.txt
# temp4.txt
810828
810828
810828
810829
810829
810830
810830
810830
810830
# habillage final
paste temp4.txt temp3.txt > $OUT
# fin du script
# resultat
810828 1
810828 2
810828 3
810829 1
810829 2
810830 1
810830 2
810830 3
810830 4
haut
Modifier une colonne avec l'action : "if(length())"
# in.txt
line1 1field data1
line2 data2
line3 3field data3
#!/bin/bash
awk 'BEGIN{FS=" "; OFS=" "}
{ if ( length($0) )
{ $0 = substr($0, 0, 5) }
else { $0 = "NA" }
print
}' in.txt
# resultat
line1
line2
NA
line3
haut
Decoupe verticale avant ou apres un separateur ( identique a split )
# in.txt
col1data1,a,col3new1
col1data2,b,col3new2
col1data3,c,col3new3
#!/bin/bash
while read line
do
# le separateur est ici: ','
echo ${line%%,*} # (la fin du fichier est supprimee)
done < in.txt
# resultat:
col1data1
col1data2
col1data3
#!/bin/bash
while read line
do
# le separateur est ici: ','
echo ${line##*,} # (le debut du fichier est supprime)
done < in.txt
# resultat:
col3new1
col3new2
col3new3
haut
Reperer les doublons d'une colonne en separant les series dont ils sont issus
#in.txt
10 4000
10 3400
10 4000
10 2800
11 300
11 300
11 200
11 100
11 100
11 100
############### parametres ####################
IN=in.txt # fichier de depart (changer ici le nom du fichier)
############### fin des parametres ##################
#creation d'un compteur
awk '{print $1}' $IN > in-count.txt
#elements uniques de la colonne 1
awk '{a[$1]++} END {for(k in a) print k}' in-count.txt > in-count2.txt
#ajout d'un marqueur devant la colonne 1
awk '{print "@"$1,$2}' $IN > in2.txt
if [ -e in3.txt ] ; then rm in3.txt ; fi
while read line
do
awk '
$1 ~ /'$line'/ && a[$2]++
END {
for (i in a)
print a[i],i
}' in2.txt >> in3.txt
done < in-count2.txt
awk '{if( $1 ~ /^@/ ) {e = $1}
else
{split( $0, d, " " ) ; print e, d[1], d[2], d[3], d[4]}
}' in3.txt | awk '$2 == "1" {next} {print}' > in4.txt
#habillage
awk '{print $1,$2" fois "$3}' in4.txt | sed 's/@//g' | sort -r > in5.txt
#regrouper
awk 'BEGIN{FS=OFS=" "}
{a[$1]++ ; b[$1] = b[$1] " "$2" "$3" "$4" "$5" "$6}
END{ for( i in a )
print i,b[i]}
' in5.txt
#resultat
10 2 fois 4000
11 3 fois 100 2 fois 300
haut
Decouper un fichier en creant autant de fichiers que de colonnes
# in.txt
11 colonnes
2 lignes
#!/bin/bash
# nb caracteres maximum pour toutes les lignes
while read caract
do
echo ${#caract}
done < in.txt | sort -n | sed -n '$p' > out.txt
# lit tous les caracteres
limit=`cat out.txt`
counter=1
until [ $counter -gt "$limit" ]
do
cat in.txt | cut -c ''$counter'-'$counter'' > cut-$counter
let counter=counter+1
done
# resultat
fichier out.txt ---> 11
# creation de 11 fichiers: cut-1 ; cut-2 ... cut-11
# contenu de cut-1
1
2
# contenu de cut-4
c
i
haut
Min et Max de valeurs placées sur une ligne
# in.txt # compteur.txt
1 902 993 1
2 1003 1256 899 1000 2
# degrouper tous les champs (de 2 a 5) sur 1 seule colonne
awk '{
key=$1 ; $1="" ; n=split( $0, parties, "[ ]" );
for ( i=1; i<=n; i++ )
{if( length( parties[i] ) == 3 )
print ""key" 0"parties[i] "" # valeurs a 4 digits
else
print ""key" "parties[i] ""}
}' in.txt | awk '{if ($2>0) print $0}' | sort > out1.txt
# out1.txt
1 0902
1 0993
2 0899
2 1000
2 1003
2 1256
# 1_script du minimum
if [ -e out-min.txt ] ; then rm out-min.txt ; fi
for i in `cat compteur.txt`
do
awk '{if( $1 == "'$i'" ) print $0}' out1.txt | head -1 >> out-min.txt
done
# resultat du minimum
1 0902
2 0899
# 2_script du maximum
if [ -e out-max.txt ] ; then rm out-max.txt ; fi
for i in `cat compteur.txt`
do
awk '{if( $1 == "'$i'" ) print $0}' out1.txt | tail -1 >> out-max.txt
done
# resultat du maximum
1 0993
2 1256
haut
Cumul de valeurs sur une ligne
# in.txt
line1 1 2 3
line2 4 5 6 7
line3 8 9 10
#!/bin/bash
awk 'BEGIN {FS=OFS=" "}
{ sum=0 ; n=0
for ( i=2; i<=NF; i++ )
{sum+=$i ; n++}
print $0,"sum:"sum," count:"n," avg:" sum/n
}' in.txt
# resultat
line1 1 2 3 sum:6 count:3 avg:2
line2 4 5 6 7 sum:22 count:4 avg:5.5
line3 8 9 10 sum:27 count:3 avg:9
haut
Supprimer un debut de fichier avant un pattern
# in.txt
1 fief toit
etre ville
toit eau
# supprimer le plus court 'debut-pattern'
#!/bin/bash
string=`cat in.txt`
echo "${string#*toit}"
# resultat
etre ville
toit eau
# supprimer le plus long 'debut-pattern'
#!/bin/bash
string=`cat in.txt`
echo "${string##*toit}"
# resultat
eau
haut
Supprimer une fin de fichier apres un pattern
# in.txt
1 fief toit
etre ville
toit eau
# supprimer le plus court 'pattern-fin'
#!/bin/bash
string=`cat in.txt`
echo "${string%toit*}"
# resultat
1 fief toit
etre ville
# supprimer le plus long 'pattern-fin'
#!/bin/bash
string=`cat in.txt`
echo "${string%%toit*}"
# resultat
1 fief
haut
Modifier les extremites d'une ligne avec "gsub" (bash)
# in.txt
data1 line1"
"data2 line2
"data3 line3"
#!/bin/bash
# deleter le debut des lignes
awk '{gsub( /^"/, "",$0 ) ; print}' in.txt |
# deleter la fin des lignes
awk '{gsub( /"$/, "",$0 ) ; print}'
# resultat
data1 line1
data2 line2
data3 line3
haut
Modifier une fin de ligne en retirant les espaces (sed)
# in.txt
# data1 colonne2a
# data2
# data3 colonne2b
sed 's/[ ]*$//g' in.txt > out.txt
# resultat : out.txt (sans les blancs en fin de ligne)
# data1 colonne2a
# data2
# data3 colonne2b
haut
Modifier une fin de ligne en retirant un caractere (bash)
#in.txt
123 data1@ data2 456@
789 data3@ 10 11
123 data4 data5 14@
#methode courte
#!/bin/bash
while read line ; do echo "${line%@}" ; done < in.txt #delete la derniere occurrence
#methode longue
#!/bin/bash
while read line
do
#definir le dernier caractere comme pattern
a=`expr "$line" : '.*\(.\)'`
#condition sur le pattern
if [[ $a = "@" ]] ; then
#creer une variable = nombre de caracteres de la ligne -1 caractere
var=`expr ${#line} - 1`
#lire la ligne avec ce nouveau nombre de caracteres
b=`expr substr "$line" 1 $var`
echo $b
else
echo "$line"
fi
done < in.txt
#resultat
123 data1@ data2 456
789 data3@ 10 11
123 data4 data5 14
haut
Modifier une fin de ligne en ajoutant un caractere (bash)
#in.txt
123 data1@ data2 456@
789 data3@ 10 11
123 data4 data5 14@
#!/bin/bash
while read line
do
#definir le dernier caractere comme pattern
a=`expr "$line" : '.*\(.\)'`
#condition sur le pattern
if [[ $a = "@" ]] ; then
#creer la nouvelle ligne
echo $line"%"
else
echo "$line"
fi
done < in.txt
#resultat
123 data1@ data2 456@%
789 data3@ 10 11
123 data4 data5 14@%
haut
Modifier une fin de ligne en changeant un caractere - exemple 1 (awk)
#in.txt
H0104 STREAMER DETAILS MAL PORT STREAMER
H0105 OTHER DETAILS OEX Outer STBD TAILBUOY
R 283 487217.26818026.9 284 487229.76818026.3 285 487242.26818025.6
R 286 487254.66818025.0 287 487267.16818024.3 288 487279.66818023.7
R 1 483732.86818401.6 2 483745.26818400.0 3 483757.66818398.4
R 4 483770.06818396.8 5 483782.46818395.3 6 483794.86818393.9
# script
awk '{
if(substr($0,1,1) == "R")
{print substr($0,1,79)"1"}
else
{print $0}
}' in.txt > out.txt
# resultat
H0104 STREAMER DETAILS MAL PORT STREAMER
H0105 OTHER DETAILS OEX Outer STBD TAILBUOY
R 283 487217.26818026.9 284 487229.76818026.3 285 487242.26818025.6 1
R 286 487254.66818025.0 287 487267.16818024.3 288 487279.66818023.7 1
R 1 483732.86818401.6 2 483745.26818400.0 3 483757.66818398.4 1
R 4 483770.06818396.8 5 483782.46818395.3 6 483794.86818393.9 1
haut
Modifier une fin de ligne en changeant un caractere - exemple 2 (awk)
#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
T 1
##### 1ere solution : utiliser "if"
awk '{
if(substr($0,80,1) == "0") {sub( ".$", "A" )} {print}
}' in.txt
##### 2eme solution : utiliser "la selection d'un pattern et sa negation"
awk '
$0 ~ /^R/ {gsub( /0$/, "A",$0 ) ; print}
$0 !~ /^R/ {print $0}
' in.txt
##### 3eme solution : utiliser "le tableau"
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 des 3 solutions
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
T 1
haut
Modifier tout caractere en maitrisant sa position (awk)
# Technique de capture : if - else if - else
# in.txt
H0104 STREAMER DETAILS MAL PORT STREAMER 1 0
H0105 OTHER DETAILS OEX Outer STBD TAILBUOY 1 1
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
T 1
awk '
{
# if ((length($0) != 80) && ($NF == 0)) {sub( ".$", "A" ) ; print}
if(substr($0,80,1) == "0") {sub( ".$", "A" ) ; print}
else if(substr($0,80,1) == "9") {a=substr($0,1,79) ; b=substr($0,80,1) ; b="J" ; print a""b}
else if((substr($0,62,1) == "1") && (substr($0,1,1) == "H")) {e=substr($0,1,61) ; f=substr($0,62,1) ; f="C" ; g=substr($0,63,17) ; print e""f""g}
# else if((substr($0,62,1) == "1") && ($0 ~ /^H/)) {e=substr($0,1,61) ; f=substr($0,62,1) ; f="C" ; g=substr($0,63,17) ; print e""f""g}
else
{print}
}
' in.txt
# resultat
H0104 STREAMER DETAILS MAL PORT STREAMER C 0
H0105 OTHER DETAILS OEX Outer STBD TAILBUOY C 1
R 283 487217.26818026.9 284 487229.76818026.3 285 487242.26818025.6 J
R 286 487254.66818025.0 287 487267.16818024.3 288 487279.66818023.7 J
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
T 1
haut
Ajouter un signe dans une colonne qui fera office de separateur (awk)
# in.txt
H0104 STREAMER DETAILS MAL PORT STREAMER 1 0
H0105 OTHER DETAILS OEX Outer STBD TAILBUOY 1 1
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
T 1
#!/bin/bash
# verifier la longueur des lignes
awk '{
if(length($0) == 80) {print "ok ligne a 80 colonnes"}
else
{print "attention cette ligne n a pas a 80 colonnes"}
}' test1.txt > verif-colonnes.txt
# chiffrer le nombre de lignes ayant 80 colonnes
# et celles qui n ont pas 80 colonnes
var1=`awk '$1 ~ /^ok/ {print $0}' verif-colonnes.txt | wc -l`
echo "nombre de lignes a 80 colonnes : " $var1
var2=`awk '$1 ~ /^attention/ {print $0}' verif-colonnes.txt | wc -l`
echo "nombre de lignes a moins de 80 colonnes : " $var2
# ajouter 1 blanc a chaque fin de ligne
awk '{
if(length($0) == 80) {print}
else
{print $0" "}
}' test1.txt | awk '{print substr($0,1,80)}' > test2.txt
# ajouter 1 separateur en colonne 78
awk '{
if ( length($0) ) {a=substr($0,1,77) ; b=substr($0,78,1) ; b="@" ; c=substr($0,79,2) ; print a""b""c}
else
{print}
}' test2.txt > test3.txt
# isoler les 2 parties de chaque cote du separateur
awk -F"@" '{print $2}' test3.txt | sed 's/0/B/g' > test3d.txt
awk -F"@" '{print $1}' test3.txt > test3g.txt
# recoller les 2 parties
paste test3g.txt test3d.txt | sed 's/\t/ /g' > test3gd.txt
# resultat
H0104 STREAMER DETAILS MAL PORT STREAMER 1 0
H0105 OTHER DETAILS OEX Outer STBD TAILBUOY 1 1
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 B
R 4 483770.06818396.8 5 483782.46818395.3 6 483794.86818393.9 B
T 1
haut
Un signe en bout de ligne fait joindre la ligne qui suit (awk + getline)
#in.txt
data4
data5
data6\
data7
awk '{
line = $0
#print line
#print substr(line, length(line),1)
#print substr(line, 1, length(line)-1)
if (substr(line, length(line),1) == "\\") # choisir ici le signe
i=getline
if (i > 0)
{line = line" "$0}
else
{printf("missing continuation on line %d\n" , NR)}
print line
}' in.txt | grep -v "missing continuation"
# resultat
data4
data5
data6\ data7
haut
Lire les 3 premiers caracteres de chaque ligne d'un fichier
# in.txt
123456
abcdef
#!/bin/bash
1_ methode en Bash
while read line
do
echo `expr "$line" : '\(...\)'`
done < in.txt
2_ methode en Awk
awk 'BEGIN{ FS=" "; OFS=" "}
{ if ( length($0) )
{ $0 = substr($0, 0, 3) }
else { $0 = "NA" }
print
}' in.txt
# resultat
123
abc
haut
Lire les 3 derniers caracteres de chaque ligne d'un fichier
# in.txt
123456
abcdef
#!/bin/bash
awk '{print substr( $0, length($0) - 2, length($0))}' in.txt
# resultat
456
def
haut
Effacer les 3 derniers caracteres de chaque ligne d'un fichier
# in.txt
123456789
abcdefghijk
line3 data123
#!/bin/bash
while read line
do
echo ${line::$((${#line}-3))}
done < in.txt
# resultat
123456
abcdefgh
line3 data
haut
En "AWK" : tester les tabulations cachees en fin de lignes
# tester les fins de lignes en "awk"
# tres utile pour deceler des tabulations cachees
# in.txt
data1
data2
data3/
data4 # une tabulation se trouve ici
#!/bin/bash
pattern="\t"
awk '{
line = $0
{e = substr(line, length(line), 1)}
#print e
if(e == "'"$pattern"'") {print e,"<-- ok pattern ici"}
else
{print "no"}
}' in.txt > out.txt # it's better to check the pattern in the file "out.txt"
# resultat
no
no
no
<-- ok pattern ici
haut
En "BASH" : tester les derniers caracteres en fin de lignes
# tester les fins de lignes en "bash"
# voit les derniers caracteres mais pas les tabulations de fin de lignes
# preferer employer "length" avec "awk"
#in.txt
data1
data2
data3/
data4
#!/bin/bash
pattern="/"
n=1
while read line
do
a=`expr "$line" : '.*\(.\)'`
echo $a > tmp.txt
if grep -q "$pattern" tmp.txt
then echo "line : " $n " : ok pattern"
else
echo "line : " $n " : no pattern - code retour = " $?
fi
let n=n+1
sleep 1
done < in.txt
# resultat
line : 1 : no pattern - code retour = 1
line : 2 : no pattern - code retour = 1
line : 3 : ok pattern
line : 4 : no pattern - code retour = 1
haut
Decouper un fichier a un pattern precis (le pattern est la fin du fichier decoupe)
# in.txt
Mr X
HSD
PIN = 12345
Mr Y
NGV
PIN = 45678
#!/bin/bash
awk 'BEGIN{ fn = "in1.txt" ; n = 1 }
{
print > fn
if ( substr($0, 1, 3) == "PIN" ) # "PIN" est la fin des fichiers
{ close (fn)
n++
fn = "in"n".txt"
}
}' in.txt
# resultat
# in1.txt # in2.txt
Mr X Mr Y
HSD NGV
PIN = 12345 PIN = 45678
haut
Decouper un fichier a un pattern precis (le pattern est le debut du fichier decoupe)
# in.txt
Mr X
HSD
PIN = 12345
Mr Y
NGV
PIN = 45678
#!/bin/bash
awk '/^Mr X|^Mr Y/ {close("add_"f) ; f++} # ecriture manuelle de tous les debuts de fichiers
{print $0 > "add_"f}' in.txt
# resultat
# add_1 # add_2
Mr X Mr Y
HSD NGV
PIN = 12345 PIN = 45678
haut
Decouper un fichier a un pattern precis (autre exemple)
# in.txt
100 a b
200 c d
300 e f
400 g h
#!/bin/bash
# 1_ diviser automatiquement toutes les 3 lignes
awk '{ print > ("std_" int((NR+2)/3)) ".txt"}' in.txt
#resultat : 2 fichiers crees: std_1.txt ; std_2.txt
# 2_ diviser en triant sur le 1er digit d'une colonne:
awk '{print > substr($1,1,1)".txt"}' in.txt
#oubien :
cat in.txt | while read line
do
echo "$line" >> std_`echo $line | cut -c1`.txt
done
#resultat : 4 fichiers crees: std_1.txt ; std_2.txt ; std_3.txt ; std_4.txt
haut
Decouper un fichier d'apres la forme de sa fin de ligne
# in.txt
z-0061 5172-821 3665
z-0061 5172-821 4754
z-0061 @@@ @@@ 810, 942,
z-0061 1860, 2428,
z-0061 2813
z-0061 @@@ @@@ 299, 303,
z-0061 515, 3880,
z-0061 4306
# le but est de creer un fichier a chaque fois que la ligne ne se termine pas par une virgule
# donc dans cet exemple il y aura creation de 4 fichiers
#!/bin/bash
# toutes les lignes ne se terminant pas par une virgule, y coller le signe %%
awk '$0 !~ /,$/ {print $0"%%"}
$0 ~ /,$/ {print}
' in.txt > inter1.txt
# preceder ce signe %% par un saut de ligne pour l'ecrire sur la ligne d'apres
sed 's/%%/\n%%/g' inter1.txt > inter2.txt
# supprimer le saut de ligne qui suit ce signe %%
sed -e :a -e '/%%$/N ; s_\n__ ; ta' inter2.txt > inter3.txt
# ajouter ce signe devant la 1ere ligne
awk 'NR==1 {print "%%"$0}
NR!=1 {print}' inter3.txt > inter4.txt
# coupe le fichier a la rencontre du signe %%
awk '
/^%%/{close("add_"f);f++} # ne pas separer
{print $0 > "add_"f}
' inter4.txt
# resultat
add_1
%%z-0061 5172-821 3665
# add_2
%%z-0061 5172-821 4754
# add_3
%%z-0061 @@@ @@@ 810, 942,
z-0061 1860, 2428,
z-0061 2813
# add_4
%%z-0061 @@@ @@@ 299, 303,
z-0061 515, 3880,
z-0061 4306
haut
Inserer une ligne avant ou apres un pattern (en AWK et en BASH)
# in.txt
data1
data2
pattern1
data3
data4
pattern2
data5
data6
# 1_ en AWK
# 1a_ marquer 1 trait avant le pattern
awk '{
if ($1 ~ /pattern/) {print "-----------\n"$0}
else
print
}' in.txt
# resultat
data1
data2
-----------
pattern1
data3
data4
-----------
pattern2
data5
data6
###################
# 1b_ marquer 1 trait apres le pattern
awk '{
if ($1 ~ /pattern/) {print $1"\n-----------"}
else
print
}' in.txt
# resultat
data1
data2
pattern1
-----------
data3
data4
pattern2
-----------
data5
data6
#######################
#######################
# 2_ en BASH
# 2a_ marquer 1 trait avant le pattern
word="pattern"
while read line
do
if [[ "$line" =~ "$word" ]]
then echo $line | sed '/'$word'/{
h;s//%%%/ ;H;x
}' | sed 's/'$word'./----------/g' | sed 's/%%%/'$word'/g'
else
echo "$line"
fi
done < in.txt
# resultat
data1
data2
----------
pattern1
data3
data4
----------
pattern2
data5
data6
# 2b_ marquer 1 trait apres le pattern
word="pattern"
while read line
do
echo "$line"
if [[ "$line" =~ "$word" ]]
then echo "----------"
fi
done < in.txt
# resultat
data1
data2
pattern1
----------
data3
data4
pattern2
----------
data5
data6
haut
Inserer un trait au changement d'un pattern
# in.txt
10 data1
10
11 data2
11
12 data3
12
# 1- methode courte (en awk)
awk 'BEGIN{OFS=FS=" "}
{if ($1 != var )
{var=$1;e="@"
print $0,e}
else
print $0
}' in.txt | sed -e '/@/i\----------------' | sed 's/@//g'
###########################
# 2- methode longue (avec un tableau) (en awk)
awk '{ f[NR]=$1 ; g[NR]=$0 }
END {
for (i=1; i<=NR; i++)
if (f[i+1] != f[i])
{print "@"f[i],g[i]}
else
{print f[i],g[i]}
}' in.txt | sed '/@/G' |
awk '
$0 ~ /^$/ {print "- ------------------"}
$0 !~ /^$/ {print $0}' | awk '{$1 = "" ; print $0}' | sed 's/^ //g'
###########################
# 3- avec une boucle while (en bash)
id2="z"
while read line
do
id=`echo $line | cut -d " " -f1`
[[ $id != $id2 ]] && id2=$id && echo "$line @" && continue
[[ $id == $id2 ]] && echo $line
done < in.txt | sed -e '/@/i\----------------' | sed 's/@//g'
###########################
# 4- avec une boucle for (en bash)
OLD_IFS=$IFS
IFS=$'\n'
id2="z"
for line in `cat in.txt`
do
id=`echo $line | cut -d " " -f1`
[[ $id != $id2 ]] && id2=$id && echo "$line @" && continue
[[ $id == $id2 ]] && echo $line
done | sed -e '/@/i\----------------' | sed 's/@//g'
IFS=$OLD_IFS
# resultat
10 data1
10
------------------
11 data2
11
------------------
12 data3
12
------------------
haut
Inserer une ligne avant des patterns listes dans un fichier
# fichier depart : FILE
data1
data2
pattern1
data3
data4
data5
pattern2
data6
data7
pattern3
data8
data9
pattern4
data10
data11
# fichier des patterns : PATTERN
pattern1
pattern2
pattern3
pattern4
#!/bin/bash
############
############ parametres pour la marche manuelle
FILE=z-test-add-before.txt # fichier depart
PATTERN=patterns.txt # fichier des patterns
insert="@@@@@@@@" # # ligne a inserer avant les patterns
AUTO=auto.sh
# changer 2 lignes (voir plus loin) dans la creation de $AUTO
############ fin des parametres pour la marche manuelle
############
variable=`cat $PATTERN`
set -- $variable
# 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 > tempw.txt # fichier temporaire
# rendre visibles les variables a l'exterieur
while read line;do eval $line;done < tempw.txt > /dev/null
# nombre de lignes du fichier
total=`sed -n '$=' $FILE`
echo "nb lignes du fichier de depart : " $total
# deleter l'ancien script de commande
rm $AUTO
############################
# creation du script de commande : $AUTO
echo "#!/bin/bash" >> $AUTO
echo "" >> $AUTO
echo "FILE=z-test-add-before.txt" >> $AUTO # changer ici manuellement
echo insert=\"@@@@@@@@\" >> $AUTO # changer ici manuellement
echo "total=\"`sed -n '$=' $FILE`\"" >> $AUTO
echo "N=1" >> $AUTO
echo "" >> $AUTO
echo "until [[ "\$N" -eq \$total ]]" >> $AUTO
echo "do" >> $AUTO
echo "S1="\$N"" >> $AUTO
echo "S2=\$(expr "\$N" + 1)" >> $AUTO
echo "N="\$S2"" >> $AUTO
echo "VAL1=\$(sed -n \"\$S1 p\" \$FILE)" >> $AUTO
echo "VAL2=\$(sed -n \"\$S2 p\" \$FILE)" >> $AUTO
# utilise le fichier des patterns comme ossature ($0) (et colle du texte avant et apres $0)
awk '
NR==1 {print "if [[ '\$VAL2' =~ \""$0"\" ]] ; then echo '\$VAL1' ; echo $insert "}
NR!=1 {print "elif [[ '\$VAL2' =~ \""$0"\" ]] ; then echo '\$VAL1' ; echo $insert "}
' $PATTERN >> $AUTO
echo "else" >> $AUTO
echo "echo "\$VAL1"" >> $AUTO # ne pas changer
echo "fi" >> $AUTO
echo "sleep 1" >> $AUTO
echo "done" >> $AUTO
################# fin de la creation de : $AUTO
# desactiver la commande suivante 'auto' pour executer la marche manuelle
bash $AUTO && exit
####################################
# marche manuelle :
N=1
until [ "$N" -eq $total ]
do
S1=$N
S2=`expr $N + 1`
N=$S2
VAL1=`sed -n "$S1 p" $FILE`
VAL2=`sed -n "$S2 p" $FILE`
if [[ $VAL2 =~ "$var1" ]] ; then echo $VAL1 ; echo $insert
elif [[ $VAL2 =~ "$var2" ]] ; then echo $VAL1 ; echo $insert
elif [[ $VAL2 =~ "$var3" ]] ; then echo $VAL1 ; echo $insert
elif [[ $VAL2 =~ "$var4" ]] ; then echo $VAL1 ; echo $insert
else
echo $VAL1
fi
sleep 1
done
# resultat :
data1
data2
@@@@@@@@
pattern1
data3
data4
data5
@@@@@@@@
pattern2
data6
data7
@@@@@@@@
pattern3
data8
data9
@@@@@@@@
pattern4
data10
data11
haut
Ajouter du texte sur une ligne ou apres une ligne
# in.txt
pattern
title1
data1
pattern
title2
data2
#!/bin/bash
# remplacer 'pattern' par '----------'
sed -e '/^pattern/ c\----------' in.txt > out1.txt
# ajouter '&&&' apres la ligne '---------'
sed -e '/----------/ a\&&& ' out1.txt > out2.txt
# supprimer le saut de ligne apres &&& pour coller les 2 lignes
sed '
/&&& /{
N
s/\n//
}' out2.txt > out3.txt
# resultat
----------
&&& title1
data1
----------
&&& title2
data2
haut
Inserer une ligne blanche selon un critere de longueur de ligne
# in.txt
data1 something1
data2
#!/bin/bash
maxlen=7
while read line
do
echo "$line"
len=${#line}
if [[ "$len" -gt "$maxlen" ]]
then echo # insertion d'une ligne blanche
fi
done < in.txt
exit
# resultat
data1 something1
data2
haut
Memoriser une chaine de caracteres pour l'inserer sur une autre ligne
in.txt
@0066),(3063) 3201,3217,3233,3249,3265,3281,3297,3313,3329,3345
@0066),(3063) 3361,3377,3393,3409,3425,3441,3457,3473,3489,3505
3521,3537,3553,3569,3585,3601,3617,3633,3649,3665,3681,3697,3713,3729,3745,3761,3777,3793,3809,3825)F
@0066),(2101) 2878,2894,2910,2926,2942,2958,2974,2990,3006,3022
@0066),(2101) 3038,3054,3070,3086,3102,3118,3134,3150,3166,3182
3198)F
#!/bin/bash
awk -F " " '
$0 ~ /^@/ {e=$1} {print}
$0 !~ /^@/ {print e,$0}
' in.txt | grep "@" | sed 's/@/(/1' | sed 's/) /),(/1'
#resultat
(0066),(3063) 3201,3217,3233,3249,3265,3281,3297,3313,3329,3345
(0066),(3063) 3361,3377,3393,3409,3425,3441,3457,3473,3489,3505
(0066),(3063) 3521,3537,3553,3569,3585,3601,3617,3633,3649,3665,3681,3697,3713,3729,3745,3761,3777,3793,3809,3825)F
(0066),(2101) 2878,2894,2910,2926,2942,2958,2974,2990,3006,3022
(0066),(2101) 3038,3054,3070,3086,3102,3118,3134,3150,3166,3182
(0066),(2101) 3198)F
haut
Capturer dans un fichier des patterns listes dans un 2eme fichier (exemple 1)
# file1 # =liste des patterns a capturer
capture1
capture3
# file2
line1 capture1 data1
line2 data2 1234 capture2
line3 data3 capture3
line4 capture4 data4
#!/bin/bash
if [ -e file3 ] ; then rm file3 ; fi
for i in `cat file1`
do
while read col1 reste
do
var=`echo $reste | awk '$0 ~ /'$i'/ { print }'`
echo $col1 $var
done < file2 >> file3
done
# regroupement des lignes
awk 'BEGIN{FS=OFS=" "}
!arr[$1] {arr[$1] = $0 ; next}
{arr[$1] = arr[$1] " " $2 " " $3 " " $4}
END {for (i in arr) {print arr[i]}
}' file3
# resultat
line1 capture1 data1
line2
line3 data3 capture3
line4
haut
Capturer dans un fichier des patterns listes dans un 2eme fichier (exemple 2)
# file1 # =liste des patterns a capturer
capture1
capture3
# file2
line1 capture1 data1
line2 data2 1234 capture2
line3 data3 capture3
line4 capture4 data4
# 1 ere methode (en bash)
#!/bin/bash
for i in `cat file1`
do
awk -F" " -v x=$i '
{ for ( j=1; j<=NF; j++ )
if ( $j == x ) print}' file2
done
# 2 eme methode (en awk)
#!/bin/bash
awk '{ if (NF == 1)
arr[$0]=$0
else
for ( i in arr )
for ( j=1; j<=NF; j++ )
if ( $j == i )
print
}' FS=" " file1 file2
# resultat
line1 capture1 data1
line3 data3 capture3
haut
Modifier dans un fichier des patterns listes dans un 2eme fichier
# file.txt
a data1
b data2
c data3
d data4
# except.txt
a
c
# 1_ MODIFIER
#!/bin/bash
awk 'BEGIN{FS=" "}
FNR==NR {ex[$1]; next}
{ $2 = ($1 in ex) ? "0" : $2; print }
' except.txt file.txt
# resultat
a 0
b data2
c 0
d data4
# 2_ DELETER
#!/bin/bash
awk 'BEGIN{FS=" "}
FNR==NR {ex[$1]; next}
!($1 in ex)
' except.txt file.txt
# resultat
b data2
d data4
haut
Stopper la lecture d'un fichier à un pattern liste dans un 2eme fichier
# break.txt
STOP
# in.txt
line1 data1
line2 data2
STOP
line3 data3
line4 data4
#!/bin/bash
for i in `cat break.txt`
do
while read line ; do [[ "$line" =~ "$i" ]] && break ; echo $line ; done < in.txt
done
# resultat
line1 data1
line2 data2
haut
Capturer un pattern a une position fixe sur une ligne
# in.txt
123 data
12345 data
#!/bin/bash
egrep '^.{4}data' in.txt
# resultat
123 data
haut
Capturer un pattern avec un depart, une longueur et une arrivee
# file.txt
go beyond finishing line
what do you say ?
to have a share in doing something = contribuer a faire qqch
#!/bin/bash
sed -n '/in.\{3\}ing/p' file.txt
# resultat
go beyond finishing line
to have a share in doing something = contribuer a faire qqch
haut
Capturer la premiere occurrence d'une serie de lignes ayant meme pattern
# in.txt
100 first line data1
100 second line data2
101 first line data3
101 second line data4
#!/bin/bash
cat in.txt | sort -k1 | awk 'x !~ $1 ; {x = $1}'
# 2eme syntaxe
cat in.txt | sort -k1 | awk 'x[$1]++ {next} {print}'
# 3eme syntaxe
cat in.txt | sort -k1 | awk '!_[$1]++ {print $0; next} {next}'
# resultat
100 first line data1
101 first line data3
haut
Selectionner des lignes d'un fichier par des caracteres d'une colonne
# in.txt
"I came to realize the true meaning of life" 74
"The shoes came untied" 76
"his face went red" 80
"your wish will come true" 82
"Melons come from a vine" 97
"Understanding comes from experience" 99
#!bin/bash
# 1_selection des patterns
while read special
do
# selection de 2 caracteres et prendre le dernier a droite
var1=`echo ${special::2} | sed 's/.*\(.\)$/\1/' | awk '$0 ~ /[a-z]/ {print}'`
echo $var1
done < in.txt | grep "." > in-patterns.txt
# 2_lecture des patterns qui selectionneront les lignes
while read special
do
while read minus
do
var2=`echo ${special::2} | sed 's/.*\(.\)$/\1/' | awk '$0 ~ /[a-z]/ {print}'`
if [[ $var2 = "$minus" ]] ; then echo $special ; fi
done < in-patterns.txt
done < in.txt
# resultat
"his face went red" 80
"your wish will come true" 82
haut
Une seule variable dans une seule boucle suffit pour la source et la cible
# une seule variable est necessaire pour capturer des patterns
# qui vont selectionner des lignes dans des fichiers dont les noms ne
# different que d'une lettre des noms des fichiers des patterns
#####
# les 2 fichiers sources (patterns)
# wyz1
pattern1
# wyz2
pattern2
#####
# les 2 fichiers cibles
# swyz1 (premier fichier)
data1
pattern1 line1 selected from swyz1
inter first
pattern1 line2 selected from swyz1
data
# swyz2 (deuxieme fichier)
data3
pattern2 line1 selected from swyz2
inter second
pattern2 line2 selected from swyz2
data
#####
# marquer les lignes contenant le pattern
for k in wyz*
do
vark=`cat $k`
awk '
$0 ~ /'$vark'/ {print $0" @@"}
$0 !~ /'$vark'/ {print $0}
' s$k > m$k # la lettre qui differe est le "s"
done
#####
# numeroter l'occurrence du marquage @@
for j in m*
do
awk '$0 ~ /@/ {i=i+1} {print $0,i}' $j |
awk '!f[$NF]++ {print $0 ; next} {sub($NF, "") ; print}' > n$j
done
#####
# selectionner la premiere occurrence @@
for k in nm*
do
grep -H -A1 "@@ 1" $k | sed 's/[:-]/ /g'
echo
done
# resultat
nmwyz1 pattern1 line1 selected from swyz1 @@ 1
nmwyz1 inter first
nmwyz2 pattern2 line1 selected from swyz2 @@ 1
nmwyz2 inter second
haut
Capture de lignes avec pattern de debut et de fin
in.txt
line1
data1
_start
data2
line5
_end
data3
line8
data4
#!/bin/bash
i=1
until [ $i -gt "10" ]
do
S=`grep -n "start" in.txt | awk -F":" '{print $1}'`
S=`expr $S + $i`
var=`sed -n "$S p" in.txt`
echo $var
if [[ $var =~ "end" ]] ; then break ; fi
let i=i+1
done
# resultat
data2
line5
_end
haut
Maitrise de la ligne et du champ pour reorganiser les champs
# in.txt
there's no harm in trying il n'y a pas de mal a essayer, on ne perd rien a essayer
he got into trouble for stealing apples il s'est fait attraper pour avoir vole des pommes
the strain of making polite conversation l'effort que ca demande de faire la conversation a quelqu'un
death finally released her from her suffering la mort a mis un terme a ses souffrances
they'll respond to the crisis by raising taxes ils repondront a la crise en augmentant les impots
########################## parametres
LISTE=in.txt # fichier entree a lire
########################## fin des parametres
# deleter resultats precedents
rm out-*.txt
# nombre de lignes a lire
nbline=`awk '{print NR}' $LISTE | sed -n '$p'`
# boucle sur les lignes
count=1
until [ "$count" -gt $nbline ]
do
# nb maxi de champs
nbchampsmax=`awk '{print NF}' $LISTE | sort -n | sed -n '$p'` # ; echo $nbchampsmax
# boucle sur les champs
field=1
until [ "$field" -gt "$nbchampsmax" ]
do
acount=`awk 'NR=='$count' {split( $0, d, " " ) ; if((d['$field'] ~ "ing") || (d['$field'] == "in") || (d['$field'] == "for")
|| (d['$field'] == "before") || (d['$field'] == "of") || (d['$field'] == "by") || (d['$field'] == "from")) print NR" " d['$field']}' $LISTE | grep -v "something"`
echo $acount >> out-"$count".txt
let field=field+1
done # fin boucle sur les champs
##################################
# info compteur de ligne
echo "line: " $count " / " $nbline
##################################
let count=count+1
done # fin boucle sur les lignes
# ajouter zeros aux noms < 10
for i in `seq 1 9`
do
mv out-$i.txt out-00$i.txt
done 2>dev>null
# ajouter zeros aux noms entre 10 et 99
for i in `seq 10 99`
do
mv out-$i.txt out-0$i.txt
done 2>dev>null
# supprimer lignes vides
cat out-*.txt | grep "." > result1.txt
# reorganiser les champs de chaque ligne
# regrouper
awk 'BEGIN {FS=OFS=" "}
!a[$1] {a[$1] = $0;next}
{a[$1] = a[$1] " " $2 " " $3 " " $4}
END {for(i in a) {print a[i]}
}' result1.txt | sort -n | awk '{print $1,$2,$3}' > result2.txt
# classement par ordre alphabetique des verbes
cat result2.txt | awk '{print $0" @"}' > result3.txt
paste result3.txt $LISTE > result4.txt
# nettoyer
cat result4.txt | sort -k3 | awk '$0 ~ $3 {sub( /[),?!(]/, "" ) ; print}' > result5.txt
# retirer des parentheses
awk '$0 ~ $3 {sub( /[)]/, "" ) ; print}' result5.txt > result5a.txt
# separer les verbes par des traits (sed '/@/G' --> ajoute 1 ligne blanche)
awk '{ f[NR]=$3 ; g[NR]=$0 }
END {
for (i=1; i<=NR; i++)
if (f[i+1] != f[i])
{print "%"f[i],g[i]}
else
{print f[i],g[i]}
}' result5a.txt | sed '/%/G' |
awk '
$0 ~ /^$/ {print "- - -------------------------------------"} # noter les 2 espaces au debut des pointilles
$0 !~ /^$/ {print $0}' | awk '{$1 = "" ; print $0}' > result6.txt
# habillage
awk '{$1 = "" ; print $0}' result6.txt > result6a.txt
awk -F"@" '{printf ("%-23s %-23s\n",$1,$2)}' result6a.txt > result7.txt
# resultat: result7.txt
of making the strain of making polite conversation l'effort que ca demande de faire la conversation a quelqu'un
-------------------------------------
by raising they'll respond to the crisis by raising taxes ils repondront a la crise en augmentant les impots
-------------------------------------
for stealing he got into trouble for stealing apples il s'est fait attraper pour avoir vole des pommes
-------------------------------------
from suffering death finally released her from her suffering la mort a mis un terme a ses souffrances
-------------------------------------
in trying there's no harm in trying il n'y a pas de mal a essayer ; on ne perd rien a essayer
-------------------------------------
haut
Marquer des groupes de patterns semblables (exemple simple)
# in.txt # in2.txt
100 first line data1 100 1
100 second line data2 101 2
101 first line data3
101 second line data4
# 1ere methode (avec 1 seul fichier)
awk '{if( $1 != var )
{var = $1 ; count++}
print $0, count}
' in.txt
# 2eme methode (avec 2 fichiers)
awk 'NR==FNR {arr[$1]=$2 ; next}
{print $0, arr[$1]}
' in2.txt in.txt
# resultat
100 first line data1 1
100 second line data2 1
101 first line data3 2
101 second line data4 2
haut
Marquer des groupes de patterns semblables (exemple plus complique)
# test.txt
#100 data 33 11
#100 data 33 11
#100 data 33 12
#100 data 33 12
#100 data 34 13
#100 data 34 13
#100 data 34 14
#100 data 34 14
#100 data 34 14
#101 data 74 15
#101 data 74 15
#101 data 74 16
#101 data 74 16
#2 data2
awk '{
if ( substr($0,1,1) == "1" )
{
if (substr($0,1,3) != first) {n = 0 }
if (substr($0,10,2) != second) {n = 0 }
if (substr($0,13,2) != third) {n++}
{
first = substr($0,1,3)
second = substr($0,10,2)
third = substr($0,13,2)
}
{ print $0,n }
}
else
{
if (substr($0,1,1) == "2") {print $0}
}
}' test.txt
# resultat
#100 data 33 11 1
#100 data 33 11 1
#100 data 33 12 2
#100 data 33 12 2
#100 data 34 13 1
#100 data 34 13 1
#100 data 34 14 2
#100 data 34 14 2
#101 data 74 15 1
#101 data 74 15 1
#101 data 74 16 2
#101 data 74 16 2
#2 data2
haut
Coller des valeurs a un pattern (exemple 1)
# a.txt
ALL 001 3 4
5 001 6 7
ALL 002 8 9
10 002 11 12
# b.txt
001 2027-2145
002 1820-1967
#!/bin/bash
awk 'NR==FNR { f[$1]=$2 ; next } /^ALL/ { print f[$2],$2,$3,$4 ; next }1' b.txt a.txt
# resultat
2027-2145 001 3 4
5 001 6 7
1820-1967 002 8 9
10 002 11 12
haut
Coller des valeurs a un pattern (exemple 2)
# filea.txt
5:John
4:Michel
9:Rachel
# fileb.txt
9
4
5
4
22
#!/bin/bash
cat fileb.txt | while read num
do
NAME=`awk -F ":" '$1=="'"$num"'" {print '$num' FS $2}' filea.txt`
[ -z $NAME ] && echo "$num":"NO MATCH FOUND" || echo $NAME
done
# resultat
9:Rachel
4:Michel
5:John
4:Michel
22:NO MATCH FOUND
haut
Coller des valeurs a un pattern (exemple 3)
# file1.txt
alex id23
aina id12
ciam id13
alot id34
brian id64
# file2.txt
id13 new1
id12 new2
id64 new3
# 1ere methode
#!/bin/bash
awk 'BEGIN{FS=" "}
NR==FNR{arr[$2]=$0 ; next}
$1 in arr && $0=arr[$1] FS $2
' file1.txt file2.txt
# 2eme methode
#!/bin/bash
awk 'BEGIN{FS=" "}
NR==FNR{arr[$1]=$2 ; next}
$2 in arr{print $0, arr[$2]}
' file2.txt file1.txt
# resultat
ciam id13 new1
aina id12 new2
brian id64 new3
haut
Remplacer des patterns par d'autres, contenus dans un 2eme fichier
# SOURCE
debitadsl link1
dslvalley link2
onelook link3
esl link4
breaking link5
larousse link6
merriam link7
# TARGET
To learn English : 0 0
a href=" esl "ESL Cyber Listening Lab ; 0 0
Tester DEBIT ADSL :
a href=" debitadsl "ici ;
Dictionary Search : OneLook (around 40 matching dictionaries) :
a href=" onelook "onelook.com
a href=" breaking "Breaking News English
Making English easily for learning :
a href=" dslvalley "ici
Dictionnaires anglais de mots - Traductions
a href=" larousse "Larousse English / French
Tester DSLvalley :
a href=" dslvalley "ici
Dictionnaires anglais de mots - Traductions
#!/bin/bash
########### parametres
# retirer le dernier retour chariot de SOURCE
# il faut detacher le code (l'entourer d' un espace) pour qu'il soit un champ
SOURCE=source.txt
TARGET=target.txt
OUT=result.txt
############ fin des parametres
# 1ere methode (la plus courte)
#-------------
awk 'NR==FNR {arr[$1]=$2 ; next}
{print $1,$2,arr[$3],$4,$5,$6,$7,$8,$9}
' $SOURCE $TARGET
-----------------------------
# 2eme methode
#-------------
while read line
do
if [[ $line =~ "href=" ]] ; then
var1=`echo $line | sed 's/\(.*"\)\( \)\(.*\)\( \)\(".*\)/\3/'` # ; echo $var1
var2=`grep "$var1" $SOURCE | cut -d" " -f2` # ; echo $var2
echo $line | sed 's/'$var1'/'$var2'/g'
else
echo $line
fi
sleep 1
done < $TARGET
-----------------------------
# 3eme methode
#-------------
while read line
do
if ! [[ $line =~ "href=" ]] ; then echo $line
else
while read col1 col2
do
if [[ $line =~ "href=" ]] ; then echo $line |
awk '$0 ~ /'$col1'/ {sub( "'$col1'", "'$col2'" ) ; print}'
else
echo
fi
done < $SOURCE
fi
sleep 1
done < $TARGET # > $OUT
# resultat (syntaxe detruite : les "0" ne sont pas aux bonnes colonnes)
To learn English : 0 0
a href=" link4 "ESL Cyber Listening Lab ; 0 0
Tester DEBIT ADSL :
a href=" link1 "ici ;
Dictionary Search : OneLook (around 40 matching dictionaries) :
a href=" link3 "onelook.com
a href=" link5 "Breaking News English
Making English easily for learning :
a href=" link2 "ici
Dictionnaires anglais de mots - Traductions
a href=" link6 "Larousse English / French
Tester DSLvalley :
a href=" link2 "ici
Dictionnaires anglais de mots - Traductions
haut
Un titre de paragraphe devient marqueur (en utilisant 'split')
# in.txt
entry one
100 first line data1
100 second line data2
entry two
101 first line data3
101 second line data4
#!/bin/bash
awk '{if( $1 == "entry" ) {e = $2}
else
{split( $0, d, " " ) ; print e, d[1], d[2], d[3], d[4]}
}' in.txt
# resultat
one 100 first line data1
one 100 second line data2
two 101 first line data3
two 101 second line data4
haut
Un titre de paragraphe devient marqueur (sans utiliser 'split')
# in.txt
@ accept
data
3line
@ agree
data
line6
@ believe
3data
9line
#!/bin/bash
awk '{
if($0 ~ /^@/) {e=$0 ; print substr(e,1,3),e}
else
{print}
}' in.txt | sed 's/@ /@/1' | sed 's/@/***/1' > inter.txt
awk '$1 ~ /\*\*\*a/ {i=i+1} {print $0,i}' inter.txt |
awk '!a[$NF]++ {print $0 ; next} { sub($NF, "") ; print }' | sed 's/^ //g'
# resultat
***a @ accept 1
data
3line
***a @ agree 2
data
line6
***b @ believe
3data
9line
haut
Un champ d'une ligne devient titre de la ligne (sans utiliser 'split')
# FILE :
line1 data1 string
line2
line3 data2
line4 data3 pattern
line5
line6 data4
line7 data5 data
line8
line9 data6
end end end
#!/bin/bash
###################### parametres
FILE=in.txt
OUT=out.txt
# ajouter 1 ligne a la fin (manuellement) : end end end
# faire manuellement si pas possible en automatique
PATTERNS=in-patterns.txt
############################# fin des parametres
# fichiers des patterns en automatique
awk '{print $3}' $FILE | grep "." > $PATTERNS
# deleter actions precedentes
rm $OUT
# script
N=1
# nombre de lignes du fichier des patterns
total=`sed -n '$=' $PATTERNS`
until [ "$N" -eq $total ]
do
S1=$N
S2=`expr $N + 1`
N=$S2
VAL1=`sed -n "$S1 p" $PATTERNS`
VAL2=`sed -n "$S2 p" $PATTERNS`
echo $VAL1 ; echo $VAL2 ; echo
while read line
do
set -- $line
if [[ "$3" == "$VAL1" ]] ; then w1=`echo $3` ; echo $w1 $line | awk '{if($NF = "$VAL1") {$NF=""} {print}}' ; fi
if [[ "$3" != "$VAL1" ]] && [[ "$3" != "$VAL2" ]] ; then echo $w1 $line ; fi
if [[ "$3" == "$VAL2" ]] ; then exit ; fi
done < $FILE | grep "^$VAL1" >> $OUT # boucle dans $FILE
done # boucle dans $PATTERNS
# resultat : $OUT
string line1 data1
string line2
string line3 data2
pattern line4 data3
pattern line5
pattern line6 data4
data line7 data5
data line8
data line9 data6
haut
Repeter un nombre de fois (valeur en colonne 2), un pattern situe en colonne 1
#!/bin/bash
####### parametres
IN=in.txt
SLEEP=0
OUT=out.txt
############ fin des parametres
# IN
# a 2
# b 4
# c 3
while read col1 col2
do
counter=1
until [ $counter -gt $col2 ]
do
echo $col1 "$counter"
let counter=counter+1
done
sleep $SLEEP
done < $IN > $OUT
# OUT
# a 1
# a 2
# b 1
# b 2
# b 3
# b 4
# c 1
# c 2
# c 3
haut
Occurrences d'un pattern (syntaxe courte)
#!/bin/bash
# fichier in.txt
# -----
# 1001 1
# 2001 2
# 3001 3
# -----
# 4001 4
# 5001 5
# 6001 6
# 7001 7
# -----
# 8001 8
# 9001 9
# 10001 10
# marquer l'occurence d'un pattern
awk '{
if($1 ~ /^-----/) {i=i+1 ; print $0" tape "i}
else
{print}
}' in.txt
# resultat
# ----- tape 1
# 1001 1
# 2001 2
# 3001 3
# ----- tape 2
# 4001 4
# 5001 5
# 6001 6
# 7001 7
# ----- tape 3
# 8001 8
# 9001 9
# 10001 10
haut
Occurrences d'un pattern
Recherche sur la lettre "a"
# in.txt
a data-one.txt
a data-two.txt
a data-three.txt
b data-four.txt
b data-five.txt
#!/bin/bash
awk '$1 ~ /a/ { i=i+1 } END {print i}' in.txt
# resultat
3
haut
Occurrences d'un pattern - precision de sa position (exemple 1)
# $IN
@ heighten
transitive verb conjugaison
1. [make higher - building, ceiling, shelf] conjugaison relever, conjugaison rehausser
2. [increase - effect, fear, pleasure] conjugaison augmenter, conjugaison intensifier
@ heighten
intransitive verb conjugaison
[fear, pleasure] conjugaison augmenter, conjugaison monter
######### parametres
pattern="conjugaison"
IN=in.txt
######### fin des parametres
awk 'BEGIN{count=0}
{
for(i=1;i<=NF;i++)
{
if($i == "'$pattern'")
{print "line " NR " in field " i " data : "$0
count++
}
}
}
END {
print "\n Found " count " instances of : " "'$pattern'"
}' $IN
# resultat
line 2 in field 3 data : transitive verb conjugaison
line 3 in field 8 data : 1. [make higher - building, ceiling, shelf] conjugaison relever, conjugaison rehausser
line 3 in field 10 data : 1. [make higher - building, ceiling, shelf] conjugaison relever, conjugaison rehausser
line 4 in field 7 data : 2. [increase - effect, fear, pleasure] conjugaison augmenter, conjugaison intensifier
line 4 in field 9 data : 2. [increase - effect, fear, pleasure] conjugaison augmenter, conjugaison intensifier
line 7 in field 3 data : intransitive verb conjugaison
line 8 in field 3 data : [fear, pleasure] conjugaison augmenter, conjugaison monter
line 8 in field 5 data : [fear, pleasure] conjugaison augmenter, conjugaison monter
Found 8 instances of : conjugaison
haut
Occurrences d'un pattern - precision de sa position (exemple 2)
Recherche sur le chiffre "0" en colonne 80
# in.txt
H0104 STREAMER DETAILS MAL PORT STREAMER 1 0
H0105 OTHER DETAILS OEX Outer STBD TAILBUOY 1 1
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
T 1
#!/bin/bash
awk 'BEGIN{count=0}
{
for(i=1;i<=NF;i++)
{
if((substr($i,1,1) == "0") && (substr($0,80,1) == "0"))
{print "line " NR " in field " i " colonne 80"
count++
}
}
}
END {
print
print "Found " count " instances of it"
}' in.txt
# resultat
line 5 in field 8 colonne 80
line 6 in field 8 colonne 80
Found 2 instances of it
haut
Capturer ou deleter des lignes dont le mot en colonne 1 a une autre occurrence sur la ligne
# in.txt
hang let drop or droop
hang example: hang one's head in shame
hang of meat, in order to get a gamey taste
happen example: i happen to have just what you need!
happen come to pass
hold be pertinent or relevant or applicable
hold have room for; hold without crowding
hold keep in mind or convey as a conviction or view
# in-verbe.txt
hang
happen
hold
# 1_ en BASH (utilise 2 fichiers)
# but du script : deleter les lignes ayant 2 occurrences
# un fichier resultat est cree : out.txt (a cause de la double redirection)
# deleter les anciennes actions
rm out.txt
# script
while read line
do
while read verb
do
var1=`echo $line | awk '{f[j]=$0} {for(i=1;i<=NF;i++) if($i ~ /'$verb'/) {j++}} END {print $1,j}'`
# printer la ligne si l'occurrence du pattern est egal a 1
if [[ `echo $var1 | cut -d" " -f2` == "1" ]] ; then echo $line >> out.txt ; fi
done < in-verbe.txt
done < in.txt
# out.txt
hang let drop or droop
hang of meat, in order to get a gamey taste
happen come to pass
hold be pertinent or relevant or applicable
hold keep in mind or convey as a conviction or view
###########################
###########################
# 2_ en AWK (utilise 1 fichier)
# but du script : capturer les lignes ayant 2 occurrences
# in.txt
hang let drop or droop
hang example: hang one's head in shame
hang of meat, in order to get a gamey taste
------------------
happen example: i happen to have just what you need!
happen come to pass
------------------
hold be pertinent or relevant or applicable
hold have room for; hold without crowding
hold keep in mind or convey as a conviction or view
# script
awk '{
if (length($0) > 0) {e=$1}
if (e ~ /-/) {next} {f=$1} {$1=""} {h=$0}
n=split (h, tab, " ")
for (k=1; k<=n; k++)
{if (f == tab[k]) print f" "h}
}' in.txt
# resultat
hang example: hang one's head in shame
happen example: i happen to have just what you need!
hold have room for; hold without crowding
haut
Marquer les numeros des occurrences a partir d'une liste de patterns
# pattern.txt
a
b
# in.txt
a data-one.txt
a data-two.txt
a data-three.txt
b data-four.txt
b data-five.txt
#!/bin/bash
# deleter les actions precedentes
if [ -e out.txt ] ; then rm out.txt ; fi
for j in `cat pattern.txt`
do
awk '$1 ~ /'$j'/ {i=i+1} {print $0,i}' in.txt |
awk '!f[$NF]++ {print $0 ; next} {sub($NF, "") ; print}' |
awk '$NF !~ /t/ {print}' >> out.txt
done
# out.txt
a data-one.txt 1
a data-two.txt 2
a data-three.txt 3
b data-four.txt 1
b data-five.txt 2
haut
Deleter les occurrences repetees dans une colonne, et ne garder que la 1ere
# in.txt
a data-one.txt
a data-two.txt
a data-three.txt
b data-four.txt
b data-five.txt
#!/bin/bash
awk -F" " '!f[$1]++ {print $0 ; next}
{sub( $1, "" ) ; print}' in.txt
# resultat
a data-one.txt
data-two.txt
data-three.txt
b data-four.txt
data-five.txt
haut
Occurrences d'un caractere dans plusieurs fichiers
# fichier z1.txt
data1
data2
123 234 3451 456 567 678 7891
123 234 0001 456 567 555 7891
123 234 9991 456 567 666 7891
123 234 8881 456 567 777 7891
123 234 7771 456 567 888 7891
123 234 6661 456 567 999 7891
# fichier z2.txt
data3
data4
124 234 3452 457 567 672 7890
124 234 0002 457 567 552 7890
124 234 9992 457 567 662 7890
124 234 8881 457 567 772 7890
124 234 7771 457 567 882 7890
124 234 6661 457 567 992 7890
# capture du 4eme caractere de la colonne 3
for i in `ls z*.txt`
do
awk '{print substr($3,4,1)}' $i>y-$i
done
# supprimer les lignes vides
for i in `ls y-z*.txt`
do
sed '/^$/d' $i > x$i
done
# frequence du caractere
for j in `ls xy-z*.txt`
do
awk '{
for (i=1; i<=NF; i++)
mot[$i]++ # mot[$i]=mot[$i]+1
}
END {
for (i in mot)
print i " -->",mot[i]" occurrences"
}' $j > v$j
done
# marquer nom du fichier devant chaque ligne
for i in vxy-z*.txt
do
seq=`ls $i | cut -c5-10`
awk '{print seq" : ",$0}' seq=${seq} $i
echo "----"
done
# resultat
z1.txt : 1 --> 6 occurrences
----
z2.txt : 1 --> 3 occurrences
z2.txt : 2 --> 3 occurrences
----
haut
Afficher toutes les occurrences d'un titre
# but : afficher toutes les occurrences d'un titre (vtr oubien vi)
# in.txt
acquaint LAR vtr @ acquaint transitive verb
acquaint LAR 1. [ inform ] aviser, renseigner
acquaint LAR 2. [ familiarize ]
act LAR vi @ act intransitive verb
act LAR 1. [ take action ] agir
act LAR 2. [ serve ]
act LAR 3. [ behave ] agir, se comporter
adapt LAR vtr @ adapt transitive verb
adapt LAR 1. [ adjust ] adapter, ajuster
adapt LAR 2. [ book, play ] adapter
adapt WR vi (change) s'adapter
adapt WR (to situation) s'adapter
#!/bin/bash
while read line
do
if [[ `echo $line|awk '{print $3}'` =~ "vtr" ]] ; then e=`echo $line|awk '{print $3}'` ; echo $line
elif [[ `echo $line|awk '{print $3}'` != "vtr" ]] && [[ `echo $line|awk '{print $3}'` != "vi" ]]
then f=`echo $line|awk -F"LAR" '{print $1}'` ; g=`echo $line|awk -F"LAR" '{print $2}'` ; echo $f" LAR "$e $g
if [[ `echo $line|awk '{print $3}'` =~ "vi" ]] ; then $e="" ; break ; fi
elif [[ `echo $line|awk '{print $3}'` =~ "vi" ]]
then e=`echo $line|awk '{print $3}'` ; echo $line
else
echo "no"
fi
done < in.txt | awk '{a=$1 ; b=$2 ; c=$3 ; $1=$2=$3="" ; m=$0 ; printf ("%-12s %-5s %-5s %-15s\n",a,b,c,m)}'
# resultat
acquaint LAR vtr @ acquaint transitive verb
acquaint LAR vtr 1. [ inform ] aviser, renseigner
acquaint LAR vtr 2. [ familiarize ]
act LAR vi @ act intransitive verb
act LAR vi 1. [ take action ] agir
act LAR vi 2. [ serve ]
act LAR vi 3. [ behave ] agir, se comporter
adapt LAR vtr @ adapt transitive verb
adapt LAR vtr 1. [ adjust ] adapter, ajuster
adapt LAR vtr 2. [ book, play ] adapter
adapt WR vi (change) s'adapter
adapt WR vi (to situation) s'adapter
haut
Addition d'une constante aux chiffres d'une colonne
# But du script : ajouter une constante (=480) aux 2 colonnes de droites
# on estime a 8 le nombre maxi de valeurs par ligne
# intervention manuelle au paste3.txt (ajout de zero a 1 champ vide)
# in.txt
a @ 67,132 @ 0 @ 102,230 @ 0
b @ 67,227 @ 0 @ 102,230 @ 439
c @ 67,132,227 @ 0 @ 102,230 @ 439,469
d @ 132 @ 0 @ 102,230 @ 0
e @ 0 @ 352 @ 102,230 @ 259,439
#!/bin/bash
########## parametres
ADD=480
########## fin des parametres
# separer par @@ les 2 colonnes de droite ou sera ajoute 480
awk -F"@" '{printf ("%-10s %-30s %-30s %-30s %-30s\n",$1,$2,$3," @@ "$4,$5)}' in.txt > inter1.txt
# conserver les 3 colonnes de gauche
awk -F"@@" '{print $1}' inter1.txt > inter2-col1.txt
# traitement sur les 2 colonnes de droite
awk -F"@@" '{print $2}' inter1.txt > inter2-col2.txt
###################
# 1ere colonne de droite
awk '{print $1}' inter2-col2.txt > inter2-col2a.txt
# ajouter 480 a toutes les valeurs (on estime a 8 le nombre maxi de valeurs par ligne)
awk -F"," '{print $1+'$ADD',$2+'$ADD',$3+'$ADD',$4+'$ADD',$5+'$ADD',$6+'$ADD',$7+'$ADD',$8+'$ADD'}' inter2-col2a.txt | sed 's/480//g' | sed 's/ /,/g' | sed 's/[,]*$//g' > inter2-col2a2.txt
###################
# 2eme colonne de droite
awk '{print $2}' inter2-col2.txt > inter2-col2b.txt
# ajouter 480 a toutes les colonnes
awk -F"," '{print $1+'$ADD',$2+'$ADD',$3+'$ADD',$4+'$ADD',$5+'$ADD',$6+'$ADD',$7+'$ADD',$8+'$ADD'}' inter2-col2b.txt | sed 's/480//g' | sed 's/ /,/g' | sed 's/[,]*$//g' > inter2-col2b2.txt
########################
paste inter2-col1.txt inter2-col2a2.txt inter2-col2b2.txt > paste1.txt
# habillage
sed 's/\t/ /g' paste1.txt | awk '{printf ("%-10s %-30s %-30s %-30s %-30s\n",$1,$2,$3,$4,$5)}'> paste2.txt
# paste3 fait manuellement (ajouter zero a un champ vide)
awk '{print " ("$1"),("$2","$3","$4","$5"),F1.0,"}' paste3.txt > paste4.txt
# resultat
(a),(67,132,0,582,710,0),F1.0,
(b),(67,227,0,582,710,919),F1.0,
(c),(67,132,227,0,582,710,919,949),F1.0,
(d),(132,0,582,710,0),F1.0,
(e),(0,352,582,710,739,919),F1.0,
haut
Deleter des lignes semblables consecutives
# in.txt
Apercu complet du demarrage de Windows
Apercu complet du demarrage de Windows
Apercu complet du demarrage de Windows
Apercu complet du demarrage de Windows
background-color: #e1ddc3
background-color: #e1ddc3
background-color: #e1ddc3
#!/bin/bash
awk '{
#lignes mises en tableau
f[NR] = $0}
END {
for(i=1;i<=NR;i++)
#si ligne 'i+1' est egale a 'i' :
if (f[i+1] == f[i])
#ajouter 1 marqueur
{print f[i]," %%"}
else
#sinon lire la ligne sans marqueur
{print f[i]}
}' in.txt | grep -v "%%$"
# resultat
Apercu complet du demarrage de Windows
background-color: #e1ddc3
haut
Incrementer des lignes consecutives de format identique, le compteur est mis a zero ensuite
# in.txt
title1
sentence one
sentence two
sentence three
[example 1]
title2
sentence four
sentence five
title3
[example 2]
#!/bin/bash
# ajouter un signe devant les lignes qu'on veut incrementer
sed 's/^ [a-z]/%% &/g' in.txt > inter1.txt
# incrementer les consecutives ; remettre a zero ensuite
awk '{
if($0 ~ /^%%/) {i=i+1} {print i,$0}
if($0 !~ /^%%/) {i=""}
}' inter1.txt | awk '($0 ~ /^[1-9]/) && ($1 ~ /[1-9]/) && ($2 !~ /%%/) {$1=""} {print}'
# resultat
title1
1 %% sentence one
2 %% sentence two
3 %% sentence three
[example 1]
title2
1 %% sentence four
2 %% sentence five
title3
[example 2]
haut
Joindre un signe avec la ligne suivante (exemple 1)
# in.txt
data 123:
line2
data 456:
line4
sed -e :a -e '/:$/N ; s_\n__ ; ta' in.txt | sed 's/:/ /g'
# resultat
data 123 line2
data 456 line4
haut
Joindre un signe avec la ligne suivante (exemple 2)
# in.txt
data 123:
line2
data 456:
line4
awk '{
while ( $0 ~ /\:$/ )
{getline record
$0 = $0 " " record}
print $0
}' in.txt | sed 's/://g'
# resultat
data 123 line2
data 456 line4
haut
Joindre un signe avec la ligne suivante (exemple 3)(awk + getline)
#in.txt
data4
data5
data6\
data7
awk '{
line = $0
#print line
#print substr(line, length(line),1)
#print substr(line, 1, length(line)-1)
if (substr(line, length(line),1) == "\\") # choisir ici le signe
i=getline
if (i > 0)
{line = line" "$0}
else
{printf("missing continuation on line %d\n" , NR)}
print line
}' in.txt | grep -v "missing continuation"
# resultat
data4
data5
data6\ data7
haut
Joindre un signe au bout de la ligne precedente (exemple 1)
# in.txt
data 123
=line2
data 456
=line4
=line5
sed -e :a -e '$!N ; s/\n=/ / ; ta' -e 'P;D' in.txt
# resultat
data 123 line2
data 456 line4 line5
haut
Joindre un signe au bout de la ligne precedente (exemple 2)
# in.txt
data 123
=line2
data 456
=line4
=line5
awk 'END { print r }
r && !/^=/ { print r ; r = "" }
{ r = r ? r $0 : $0 }
' in.txt | sed 's/=/ /g'
# resultat
data 123 line2
data 456 line4 line5
haut
Joindre un signe au bout de la ligne precedente sauf si cette derniere se termine par @ (exemple 3)
# in.txt
data 123
=line2
data 456@
=line4
=line5
awk 'END { print r }
r ~ /@$/ || !/^=/ { print r ; r = "" }
{ r = r ? r $0 : $0 }
' in.txt | sed 's/=/ /g' | sed 's/^ //g'
# resultat
data 123 line2
data 456@
line4 line5
haut
Un signe en debut de ligne 1, fait joindre la ligne 2 a la suite de la 1
# in.txt
@ arise
intransitive verb
1. [appear, happen] survenir, se presenter
2. [result] resulter
###### parametres
SIGNE="@"
###### fin des parametres
awk '
$0 ~ /^'$SIGNE'/ {e=$0 ; getline record ; f=e" "record}
{if( $1 == "'$SIGNE'" )
print f
else
print
}' in.txt
# resultat
@ arise intransitive verb
1. [appear, happen] survenir, se presenter
2. [result] resulter
haut
Les lignes qui commencent par un signe collent les suivantes a leur fin si elles ne possedent pas ce signe
# in.txt (ajouter un blanc a la fin des lignes)
data 123
@line2
@data 456
line4
line5
awk 'NR > 1 && /^@/ {print ""}
{printf $0}
END {print ""}
' in.txt
# resultat
data 123
@line2
@data 456 line4 line5
haut
Printer les lignes du fichier2 qui manquent dans le fichier1
# ina.txt
accept
access
accomplish
accumulate
# inb.txt
accept
access
accommodate
accomplish
accord
accumulate
#!/bin/bash
comm -23 inb.txt ina.txt 2>dev
# resultat
accommodate
accord
haut
Comparer 2 fichiers : identiques ou differents
#!/bin/bash
# a.txt
data1
data2
# b.txt
data1
data2
data3
if cmp a.txt b.txt &> /dev/null
then echo "a et b identiques"
else echo "a et b differents"
fi
# resultat
a et b differents
haut
Intersection de 2 fichiers : lignes uniques et communes
# PREREQUIS : verifier que les fichiers a comparer ne comportent pas
# la sequence suivante : " >" car elle provoquera une erreur dans le script.
# in1.txt
keep me advised of your progress
these problems are currently being investigated
until further notice
i visit him less than i should
# in2.txt
keep me advised of your progress
a lot of people are addicted to sugar
until further notice
the hectic pace of everyday life
we are relying on good weather
#!/bin/bash
ARGS=2 # 2 arguments attendus par le script
E_MAUVAISARGS=65
E_ILLISIBLE=66
if [ $# -ne "$ARGS" ]
then
echo "usage: `basename $0` fichier1 fichier2"
exit $E_MAUVAISARGS
fi
if [[ ! -r "$1" || ! -r "$2" ]]
then
echo "les 2 fichiers a comparer doivent etre lisibles"
exit $E_ILLISIBLE
fi
# lignes uniques de chaque fichier
diff --side-by-side <(sort $2) <(sort $1) | egrep " >| \|" | sed 's_ >_@@@@@_g' |
sed 's_ |_@@@@@_g' | sed 's_\(.*\)\(@@@@@\)\(.*\)_\3_g' | sed 's/\t//g' | awk '{print "lignes uniques a '$1': "$0}' > tmp1.txt
diff --side-by-side <(sort $1) <(sort $2) | egrep " >| \|" | sed 's_ >_@@@@@_g' |
sed 's_ |_@@@@@_g' | sed 's_\(.*\)\(@@@@@\)\(.*\)_\3_g' | sed 's/\t//g' | awk '{print "lignes uniques a '$2': "$0}' >> tmp1.txt
# lignes communes
comm <(sort $1) <(sort $2) | awk '$0 ~ /^\t\t/ {print}' | sed 's/\t\t/lignes communes: /g' >> tmp1.txt
# habillage
grep "lignes uniques a "$1":" tmp1.txt | wc -l | awk '{print " _ "$0" lignes uniques a '$1':"}' > tmp2.txt
cat tmp1.txt | grep "lignes uniques a "$1":" | sed 's/lignes uniques a '$1': //g' >> tmp2.txt
echo >> tmp2.txt
grep "lignes uniques a "$2":" tmp1.txt | wc -l | awk '{print " _ "$0" lignes uniques a '$2':"}' >> tmp2.txt
cat tmp1.txt | grep "lignes uniques a "$2":" | sed 's/lignes uniques a '$2': //g' >> tmp2.txt
echo >> tmp2.txt
grep "lignes communes:" tmp1.txt | wc -l | awk '{print " _ "$0" lignes communes:"}' >> tmp2.txt
cat tmp1.txt | grep "lignes communes:" | sed 's/lignes communes: //g' >> tmp2.txt
cat temp2.txt
# resultat
_ 2 lignes uniques a in1.txt
i visit him less than i should
these problems are currently being investigated
_ 3 lignes uniques a in2.txt
a lot of people are addicted to sugar
the hectic pace of everyday life
we are relying on good weather
_ 2 lignes communes
keep me advised of your progress
until further notice
haut
Un titre de paragraphe est capture a un pattern
# in.txt
entry 1
data1
entry 2
data2
#!/bin/bash
# 1ere syntaxe ( capture du titre de paragraphe )
awk '/^entry/ {cnt=1} cnt -- > 0' in.txt
# 2eme syntaxe ( capture de la ligne blanche avant le titre )
awk 'NR==1 || cnt -- > 0 ; /^$/ {cnt=1}' in.txt
# resultat
entry 1
entry 2
haut
Operations entre lignes 'n+1' et 'n'
# in.txt
10
30
100
10
#!/bin/bash
FILE=in.txt
N=1
# nombre de lignes du fichier
total=`sed -n '$=' $FILE`
until [ "$N" -eq $total ]
do
S1=$N
S2=`expr $N + 1`
N=$S2
VAL1=`sed -n "$S1 p" $FILE`
VAL2=`sed -n "$S2 p" $FILE`
expr $VAL2 - $VAL1
done
# resultat
20
70
-90
haut
Supprimer des caracteres entre 2 bornes connues
# in.txt
<gpx>123<cmp>data1</cmp></gpx>
<gpx>456<cmp>data2</cmp></gpx>
# ^^^^^^^^^^^^^^^^ partie a supprimer
while read line
do
echo $line | sed 's_\(.*\)\(<cmp>\)\(.*\)\(</cmp>\)\(.*\)_\1\5_'
# ^^^^^ ^^^^^^
# 1 2 3 4 5
done < in.txt
#resultat
<gpx>123</gpx>
<gpx>456</gpx>
haut
Suppression de lignes doubles
# in.txt
data1
line
data2
line
#!/bin/bash
awk '!x[$0]++' in.txt
# resultat
data1
line
data2
haut
Derniere modification : Octobre 2014