Discussion :

[KuBi4K]

Salut à tous,


Je dois faire un script ksh qui doit faire la chose suivante.

1 - prendre en paramètres d'entrée un fichier
2 - compter les lignes de ce fichier
3 - sélectionner une partie de chaque ligne, qui sont des chiffres, et en faire la somme.



Vu comme ça, de loin, je m'étais dit "Ok, ça à l'air tout ballot", même si je suis pas spécialisé dans ça.

Hop, après quelques rafraichissements et des lectures de man et autres docs, j'arrive à faire les étapes 1- et 2-.


Par contre, à l'étape 3-, là ça part en sucette et je pige pas bien pourquoi.


Pour le moment, j'ai ça

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
#!/bin/ksh
echo "Nom du fichier traité: $1"
 
typeset var ligne
#typeset var montant
 
NBLIGNE=`awk 'END {print NR}' $1`
 
echo $NBLIGNE
 
cat $1 | while read ligne
 
do
        test=$ligne
        echo $test | cut -c 76-91
done

Le fichier en entrée contient des lignes formatées de la même façon.

Voici son contenu

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
EBC_INIT000001  E0593105111   U593              200206001                  000000000000000 000000000000000                                                                                                                                         
EBC_INIT000001  E0593105111   U593              200212001                  000000000000000 000000000028862                                                                                                                                         
EBC_INIT000001  E0593105111   U593              200306001                  000000000028862 000000000158512                                                                                                                                         
EBC_INIT000001  E0593105111   U593              200506001                  000000000158512 000000009353118                                                                                       000000000158512                                   
EBC_INIT000001  E0593105111   U593              200602001                  000000009353118 000000009353118                                    000000009353118                                                                                      
EBC_INIT000001  E0593105111   U593              200603001                  000000009353118 000000009353118                                    000000009353118                                                                                      
EBC_INIT000001  E0593105112   U593              200206001                  000000031310329 000000031100564                                                                                                                                         
EBC_INIT000001  E0593105112   U593              200212001                  000000031310329 000000031056610                                                                                                                                         
EBC_INIT000001  E0593105112   U593              200306001                  000000031056610 000000002018306                                                                                                                                         
EBC_INIT000001  E0593105112   U593              200312001                  000000031056610 000000001823567                                                                                                                                         
EBC_INIT000001  E0593105112   U593              200406001                  000000001823567 000000001823567                                                                                       000000002018306                                   
EBC_INIT000001  E0593105112   U593              200412001                  000000001823567 000000001823567                                                                                       000000001823567                                   
EBC_INIT000001  E0593105112   U593              200506001                  000000001823567 000000000000000                                                                                       000000001823567                                   
EBC_INIT000001  E0593105112   U593              200512001                  000000001823567 000000000000000                                                                                       000000001823567                                   
EBC_INIT000001  E0593105113   U593              200206001                  000000000000000 000000000209765                                                                                                                                         
EBC_INIT000001  E0593105113   U593              200212001                  000000000000000 000000000000000                                                                                                                                         
EBC_INIT000001  E0593105113   U593              200306001                  000000000000000 000000028908654                                                                                                                                         
EBC_INIT000001  E0593105113   U593              200312001                  000000000000000 000000029103393                                                                                                                                         
EBC_INIT000001  E0593105113   U593              200406001                  000000029103393 000000000000000                                                                                       000000028908654                                   
EBC_INIT000001  E0593105113   U593              200412001                  000000029103393 000000000000000                                                                                       000000029103393                                   
EBC_INIT000001  E0593105113   U593              200506001                  000000000000000 000000000000000                                                                                       000000000000000                                   
EBC_INIT000001  E0593105113   U593              200512001                  000000000000000 000000000000000                                                                                       000000000000000                                   
EBC_INIT000001  E0593105310   U593              200212001                                  000000001174632                                                                                                                                         
EBC_INIT000001  E0593121992   U593              200702001                  000000000000000 000000000000000                                    000000000000000                                    000000000000000                                   

On m'a dit dans ma doc: "Extraits les caractères 91 à 106 de chaque ligne"
Déjà, allez savoir pourquoi, je sias pas comment sont comptés les espaces et/ou tabulation, mais en vrai, ce qui m'intéresse, c'est pas de 91 à 106, mais de 76 à 91 (d'où le cut -c 76-91)


Donc je lance mon script.

Et là:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
Nom du fichier traité: EBC_INIT_593.dat
24



00000000158512
00000009353118
00000009353118




00000002018306
00000001823567
00000001823567
00000001823567




00000028908654
00000029103393
00000000000000
00000000000000

Comme vous pouvez le constater, y a des trous et il manque des valeurs.

Il devrait y avoir au début

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
000000000000000
000000000028862
00000000158512

Or, on passe directement à

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

00000000158512 

Idéalement, ca devrait me donner ça

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
Nom du fichier traité: EBC_INIT_593.dat
24
000000000000000
000000000028862
000000000158512
000000009353118
000000009353118
000000009353118
000000031100564
000000031056610
000000002018306
000000001823567
000000001823567
000000001823567
000000000000000
000000000000000
000000000209765
000000000000000
000000028908654
000000029103393
000000000000000
000000000000000
000000000000000
000000000000000
000000001174632
000000000000000

Et en fait, ça me donne ça

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
Nom du fichier traité: EBC_INIT_593.dat
24



00000000158512
00000009353118
00000009353118




00000002018306
00000001823567
00000001823567
00000001823567




00000028908654
00000029103393
00000000000000
00000000000000

Donc voilà, je comprends pas.

Si quelqu'un à une idée, ca serait super.

[frp31]

ajoutes un

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

................................| grep -v ^$

ca devrait éliminier les lignes vides optenues.

[KuBi4K]

ajoutes un

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

................................| grep -v ^$

ca devrait éliminier les lignes vides optenues.

Alors j'ai fait ça et .... :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
 
Nom du fichier traité: EBC_INIT_593.dat
24
00000000158512
00000009353118
00000009353118
00000002018306
00000001823567
00000001823567
00000001823567
00000028908654
00000029103393
00000000000000
00000000000000

Effectivement, en gros c'est le résultat que j'avais avant, mais sans les gros vides. Cool.
Or c'est pas "virer les gros vides" qui m'intéressent, mais "les remplir avec ce qui devraient y avoir".

Car il me manque toujours ce qui est en italique ci-dessous

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
Nom du fichier traité: EBC_INIT_593.dat
24
000000000000000
000000000028862
000000000158512
000000009353118
000000009353118
000000009353118
000000031100564
000000031056610
000000002018306
000000001823567
000000001823567
000000001823567
000000000000000
000000000000000
000000000209765
000000000000000
000000028908654
000000029103393
000000000000000
000000000000000
000000000000000
000000000000000
000000001174632
000000000000000

En fait, ça a juste compressé en un seul bloc le résultat erroné et plein de trous de mon script.

:'(

[7not6]

je comprend pas car chez moi si je copie/col ton fichier fichier data dans data.txt
et si je fait juste en bash un " wc -l data.txt ; cat data.txt |cut -c 91-106 " j'obtient le bon resultat.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
 
 wc -l data.txt ; cat data.txt |cut -c 91-106
24 data.txt
 000000000000000
 000000000028862
 000000000158512
 000000009353118
 000000009353118
 000000009353118
 000000031100564
 000000031056610
 000000002018306
 000000001823567
 000000001823567
 000000001823567
 000000000000000
 000000000000000
 000000000209765
 000000000000000
 000000028908654
 000000029103393
 000000000000000
 000000000000000
 000000000000000
 000000000000000
 000000001174632
 000000000000000

[BlaireauOne]

Peut-être y a-t-il des caractères parasites non visibles
Pour voir si c'est le cas, essaye :

cat -A {nom_de_fichier}

ou

od -a {nom_de_fichier}

[KuBi4K]

ALors, j'ai testé vos trucs.

Et ça marche \o/

Mon code en est là.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
 
#!/bin/ksh
 
typeset var tmp
typeset -i montant=0
 
touch tmp.dat
 
NBLIGNE=`wc -l $1`
echo $NBLIGNE
 
cat -q $1 |cut -c 91-106 > tmp.dat
 
 
 
 
while read ligne
do
        tmp=`expr $ligne`
        montant=$tmp+$montant
done < tmp.dat
 
echo $montant
rm tmp.dat

En gros, je récupère ma colonne comme il faut, je transforme ça en numérique et j'en fais la somme.

Par contre, je me demandais si on pouvait pas optimiser le traitement.

Là, ok, c'est du temporaire, je fais des tests dessus, mais si vous regradez bien,

- je parcours mon fichier en entrée pour en extraire ce que je veux
- je copie le résultat extrait dans un tmp.dat
- j'additionne ce qu'il y a dans le tmp.dat
- j'affiche le montant.

En gros, je parcours 2 fois des fichiers: une fois le fichier en entrée ET je parcours le tmp.dat pour faire ma somme.

Est ce que je pourrais pas faire d'un coup, lors du parcours du fichier en entrée:

Extraction de la partie qui m'intéresse ET transformation en numérique ET faire mon addition puis passer passer à la ligne suivante ?

Ca me ferait qu'un parcours, sans avoir à faire une copie temporaire tmp.dat

[7not6]

une version en bash un peu bourrine , mais en une seule passe.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
 
#!/bin/bash
 
montant=0
NBLIGNE=0
 
cat $1 |cut -c 91-106| while read ligne;
do     
   NBLIGNE=$(($NBLIGNE+1))   
   montant=`expr $ligne + $montant`
   echo "lignes:$NBLIGNE montant:$montant" > fic.tmp   
done 
 
cat fic.tmp
rm fic.tmp

[BlaireauOne]

L'option -q de la commande cat, je ne connais pas

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
 
#!/bin/ksh
 
typeset -i total=0
NBLIGNE=`wc -l $1`
echo $NBLIGNE
 
for montant in `cat -q $1 |cut -c 91-106` 
do
	echo "* $montant"
	((total=total+montant))
done
echo "* $total"

[KuBi4K]

Salut !


Encore une fois, j'ai testé vos trucs et ça marche pas mal.


J'ai peaufiné mon script pour l'adapter à mes besoins et le tester en grandeurs natures.


Par contre, quand je lui balance des fichiers énormes à traiter, il me balance une erreur

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

integrite_fichiers.ksh[34]: no space

Alors, apparemment, ça vient pas du code en lui-même, mais par contre, je me demande si ça vient pas du fait que je me retrouve avec des montants de psychopathes, quand je traite un fichier de plusieurs milllions de lignes.

[BlaireauOne]

Salut !

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

integrite_fichiers.ksh[34]: no space

Alors, apparemment, ça vient pas du code en lui-même, mais par contre, je me demande si ça vient pas du fait que je me retrouve avec des montants de psychopathes, quand je traite un fichier de plusieurs milllions de lignes.

lance ton script avec l'option trace comme suit :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
sh -x nom_du_script

Pour te répondre, il est souhaitable de montrer la trace de la partie qui plante

[KuBi4K]

lance ton script avec l'option trace comme suit :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
sh -x nom_du_script

Pour te répondre, il est souhaitable de montrer la trace de la partie qui plante

comprends pas ce que tu veux que je te file....

Le log du sh -x, aka des milliers de lignes ?

[BlaireauOne]

comprends pas ce que tu veux que je te file....

Le log du sh -x, aka des milliers de lignes ?

integrite_fichiers.ksh[34]: no space : ça doit bien correspondre au résultat d' une instruction.
Si tu veux de l'aide, le minimum c'est de communiquer la trace de cette instruction

[MarcG]

quel est la ligne de code 34 ?

si tu utilise la solution avec un for cela peut être un trop grand nombre de ligne ! :
for i in $(cat .........)
le shell résout AVANT la boucle le cat et sur plusieurs milliers de ligne .... no space left !
donc preferer la forme
while read ligne
do
....
done < fichier
ou
cat fichier | while read ligne (uniquement si le "tampon" du pipe est de taille suffisante (voir ulimit -a)

[KuBi4K]

Salut, me revoilà après un petit RTT privé d'Internet :p

J'ai trouvé la solutiion à mon problème

J'utilisais

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

for montant in `cat -q $1 |cut -c 91-106`

proposé par BlaireauOne.

En fait, d'après ce que j'ai pu comprendre et de ce qu'a confirmé un collègue qui passait par là (il m'avait pas dit qu'il avait déjà fait du script Unix, le fourbe...), le problème venait du fait que pour la portion de code que j'ai cité, j'explosais la mémoire de la bécane.

Du coup, j'ai changé un peu, j'ai forcé la lecture ligne à ligne PUIS, le cut après.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
 
while read ligne
do
 
       ligne_lue=`echo "$ligne\n" | cut -c 91-106
 
done < $mon_fichier

Et là, ça marche \o/

Merci à tous et en route pour de nouvelles aventures !



EDIT: Confirmé par le reply précédent que j'avais pas vu, car page non rafraichie \o/

[xodblux]

Salut, j'ai pas lu à 100% tout le post, mais je voulais juste ajouter un petit point sur lequel j'ai buté cette semaine en voulant faire un script du genre.

Il y a une différence majeure quand on fait un echo d'une variable entre doublequote(") et quand on le fait sans.

En effet, si on met les doublequote, ca garde le formattage des tabulations et espaces, sinon ca tronque à un espace et dans ce dernier cas, lorsqu'on joint ca à un CUT sans avoir mis les doublequote, alors cela à un effet désastreux sur le résultat choisi...

C'est pour ca qu'il faut faire :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

ligne_lue=`echo "$ligne\n" | cut -c 91-106

et non un echo de $ligne sans les double quotes.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

ligne_lue=`echo $ligne\n | cut -c 91-106