Discussion :

[Liamm]

Bonjour,

J'ai un script "global" qui contient des sous-scripts :

Code :

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

1
2
3
4
5
6
#!/bin/bash
 
##########   Script : scriptGlobal.sh                        ##########
 
./p1union.sh  "~/Téléchargements/Valorisation intraday 20220000001.csv"     #ne marche pas !
./p1union.sh  ~/Téléchargements/Valorisation\ intraday\ 20220000002.csv     #ne marche pas non plus !

Le compte-rendu terminal donne :

Code :

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

1
2
3
4
5
6
cat: '~/Téléchargements/Valorisation': Aucun fichier ou dossier de ce type
cat: intraday: Aucun fichier ou dossier de ce type
cat: 20220000001.csv: Aucun fichier ou dossier de ce type
cat: /home/thierry/Téléchargements/Valorisation: Aucun fichier ou dossier de ce type
cat: intraday: Aucun fichier ou dossier de ce type
cat: 20220000002.csv: Aucun fichier ou dossier de ce type

¿ Comment faire pour prendre en paramètre les fichier de type : "Valorisation intraday 2022000000x.csv" ?

[disedorgue]

C'est plus le contenu du script qui nous interresse ici ...

En gros, tu dois avoir un truc du genre cat $1 au lieu de cat "$1" .

[Invité]

en effet.

pour expliquer le comportement du premier appel, sache que le tilde (~) n'est pas développé entre guillemets, il est donc transmis et utilisé tel quel par le script appelé.

20220000002 n'y aurait-il pas un zéro de trop ?
il ne serait pas superflu de systématiquement tester sur l'existence des fichiers utilisés...

[Sve@r]

Bonjour

Pour compléter la réponse de disedorgue, qui me semble très proche de la solution, il faut aussi regarder si le script en question traite ses arguments via "$*" ou "$@". Parce que c'est assez subtil mais si on appelle le script en lui passant "toto titi tata", alors $* contient "toto titi tata" (une grosse string) tandis que $@ contiendra, lui, "toto" "titi" "tata" (autant de strings individuelles).
Exemple 1

Code bash :

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

1
2
3
4
5
6
7
8
#!/bin/bash
 
for x in $*; do
	echo "via *=[$x]"
done
for x in $@; do
	echo "via @=[$x]"
done

On l'appelle en lui passant "a b c" "d e f" (littéralement, avec les guillemets) et ça ressort, pour les deux boucles, chaque lettre prise individuellement (les chaines ne sont pas prises en considération)

Exemple 2

Code bash :

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

1
2
3
4
5
6
7
8
#!/bin/bash
 
for x in "$*"; do
	echo "via *=[$x]"
done
for x in "$@"; do
	echo "via @=[$x]"
done

Pareil, on l'appelle en lui passant "a b c" "d e f" et ça ressort, pour la première boucle, "a b c d e f" (tant pis si on voulait les deux strings) tandis que pour la seconde boucle ça ressort parfaitement "a b c" puis "d e f".

Plus le tilde qui effectivement n'est pas traduit quand on le place entre guillemets (dans les guillemets, seuls sont traduits le dollar et le backslash donc tu peux remplacer "~" par "$HOME", ça ça marchera).

[Liamm]

Effectivement, il vous manque des informations pour pouvoir trouver une solution.

Ainsi je vais vous donner le début de mes deux scripts:

1/ Le début du script principal :

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
28
#!/bin/bash
 
##########   Script : p0dunion.sh                             ##########
#                                                                      #
# Autheur :              Liam                             #
# Date de creation :     01 juin 2022                                  #
# Date de modification : 24 juil 2022                                  #
#                                                                      #
########################################################################
# script (p) général (0) à la demande (d)                              #
# Valeurs communes parmi les cinq fichiers                             #
########################################################################
#
#Suppression du fichier cumul de la demande précédente:
rm f1union_cumul.csv
 
#création d'un fichier cumul:
./p1union.sh  ~/Téléchargements/"Valorisation intraday 20220000001.csv"
 
./p1union.sh  ~/Téléchargements/"Valorisation intraday 20220000002.csv"  
 
./p1union.sh  ~/Téléchargements/"Valorisation intraday 20220000003.csv"
 
./p1union.sh  ~/Téléchargements/"Valorisation_intraday 20220000004.csv" 
 
./p1union.sh  ~/Téléchargements/"Valorisation intraday 20220000005.csv" 
 
...

2/ Le début du script secondaire :

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
28
29
30
31
32
33
34
35
36
37
#!/bin/bash                   
 
ARG1=${1:?"Ce script nécessite 1 argument:  \
	   Fichier numero 1 : 'Valorisation intraday 20220000001.csv' \
	   Fichier numero 2 : 'Valorisation intraday 20220000002.csv' \
	   Fichier numero 3 : 'Valorisation intraday 20220000003.csv' \
	   Fichier numero 4 : 'Valorisation intraday 20220000004.csv' \
	   Fichier numero 5 : 'Valorisation intraday 20220000005.csv' "}
 
### Script: p1union.sh  $1='Valorisation intraday 2022000000x.csv'  ####
#
# Autheur :              Liam
# Date de creation :     01 Juin  2022
#
# . . .
#
# le fichier en entrée (arg1) est en codage ISO-8859-1
# 1/ Modification de caractères : é => e   è => e   à => a   . => (rien)
#
#Remarque : ne supprimer que le séparateur des milliers ...
#Remarque   ... et faire un iconv devrait marcher ...
#Remarque   ... et on conserverait ainsi les accents !
 
cat $1 | sed -e 's/\xe9/e/g' \
             -e 's/\xe8/e/g' \
             -e 's/\xe0/a/g' \
             -e 's/\xa0//g'  |
 
         cut -f1-2,5-11 -d";" > ftmp1union1.csv
 
# 3/ choisir le codage utf-8 :
# le grep ne marche que avec utf8:
#
iconv -f ISO-8859-1 -t UTF-8 ftmp1union1.csv -o ftmp1union2.csv
 
# 4/ Ajout par gawk :
# . . .

[Liamm]

Bravo donc à disedorgue !

Il fallait remplacer :

Code :

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

1
2
3
4
5
6
cat $1 | sed -e 's/\xe9/e/g' \
             -e 's/\xe8/e/g' \
             -e 's/\xe0/a/g' \
             -e 's/\xa0//g'  |
 
         cut -f1-2,5-11 -d";" > ftmp1union1.csv

par :

Code :

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

1
2
3
4
5
6
7
cat "$1" | sed -e 's/\xe9/e/g' \
               -e 's/\xe8/e/g' \
               -e 's/\xe0/a/g' \
               -e 's/\xa0//g'  |
 
           cut -f1-2,5-11 -d";" > ftmp1union1.csv

[Liamm]

Pour conclure,

¿ Comment expliqueriez-vous la différence (de comportement) entre $1 et "$1" ?

[Sve@r]

¿ Comment expliqueriez-vous la différence (de comportement) entre $1 et "$1" ?

Exactement de la même façon que tu expliquerais la différence de comportement si tu appelais ton script en lui passant mon fichier (il verrait deux noms distincts) ou en lui passant "mon fichier" (il n'en voit qu'un contenant un espace dans son nom). Que tu appelles ton script ou "cat" c'est la même syntaxe. Dans un cas tu lui demandes de traiter deux fichiers distincts et dans l'autre cas tu lui demandes de n'en traiter qu'un contenant un espace dans son nom. C'est pour ça qu'on quote toujours les variables dans ses scripts.

Accessoirement cat fichier |sed ... peut s'écrire sed ... fichier. De plus on essaye de ne pas travailler avec des fichiers temporaires (toujours long et quasiment toujours évitable) mais si c'est justement inévitable, alors on pense à les mettre dans "/tmp" qui est fait pour ça et à leur donner des noms uniques permettant d'éviter les collisions (si ton script est appelé plusieurs fois en parallèle), via par exemple la variable "$$" ; ou alors via les commandes "tempfile" ou "mktemp". Toutefois ici on peut l'éviter.
Et il n'y a pas de "h" à "auteur".

[Invité]

non, pas cat "$1" | sed. mais sed '...' "$1".

et pour le second fichier ?

[Liamm]

Merci Sve@r

- pour l’explication de "$1"

- pour cat fichier |sed ... est équivalent à sed ... fichier

- En ce qui concerne les fichiers temporaires, chacun de mes scripts en contient plein que je numérote ftmpxyy.csv où x est le n° de script et yy un numéro d'ordre;
cela me permet de "débuger" plus rapidement; et même s'ils sont nombreux, ils se ré-écrase à chaque passage.

- pour auteur (source : Wiktionnaire)

Étymologie

Du pseudo-latin author, la forme correcte étant auctor qui donne lieu à la forme aucteur.

Nom commun
Singulier Pluriel
autheur autheurs

autheur \o.tœʁ\ masculin (pour une femme, on dit : authrice)

(Archaïsme) Variante orthographique de auteur.
Voyage de l'autheur en la Nouvelle France avec sa famille. — (Samuel de Champlain, Voyages du sieur de Champlain, 1830)
C'est comme j'estime, d'une opinion tendre, respectueuse, qu'un grand et religieux autheur tient cette action, si necessairement obligée à la vergogne. — (Essais de Michel de Montaigne, Michel de Montaigne, Etienne de La Boétie, 1834)

mais je vais rafraîchir mon fichier pour le rajeunir en mettant Auteur.

[Flodelarab]

Bonjour

En gros, tu dois avoir un truc du genre cat $1 au lieu de cat "$1" .

cat $1 | sed -e ...

Ce n'est plus de la compétence technique. C'est de la magie noire. Trouver l'erreur exacte sur une commande qui ne devrait pas être, surtout venant d'une internaute habituée de ce forum, c'est époustouflant.

[Sve@r]

- En ce qui concerne les fichiers temporaires, chacun de mes scripts en contient plein que je numérote ftmpxyy.csv où x est le n° de script et yy un numéro d'ordre;
cela me permet de "débuger" plus rapidement; et même s'ils sont nombreux, ils se ré-écrase à chaque passage.

Ok, le but est checker les travaux intermédiaires, c'est une raison. Pense quand-même à les mettre dans "/tmp", ça ne coûte rien et ça laisse ton dossier de travail propre. Surtout que le fichier est créé à l'endroit où tu te trouves. Imagine que tu te trouves à un endroit où tu n'as pas le droit d'écrire quand tu lances le script...
De même ton script "global" lance à chaque fois "./script_X", sous-entendant que tu te trouveras à chaque fois à l'emplacement du script_X quand tu lances le global. Ca non plus ce n'est pas safe.
Si "global" et les "script_X" sont au même endroit, alors en récupérant le dirname("$0") dans le script global tu peux alors donner le chemin des scripts_X et ne plus dépendre de ton emplacement quand tu l'appelles.

Sinon une méthode pour éviter les fichiers temporaires: imaginons que tu veuilles lancer 3 commandes à suivre mais de sans les piper afin de pouvoir si besoin récupérer une des 3 pour la vérifier, voici une façon de faire

Code bash :

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

1
2
3
4
exec 3< <(commande 1)
exec 4< <(commande 2 0<&3)
exec 3< <(commande 3 0<&4)
cat 0<&3

Chaque "exec" va créer un canal (exactement comme les canaux 0, 1 et 2 bien connus des programmeurs shell), canal contenant tout ce que la commande a généré. Si à un moment donné tu veux vérifier un travail intermédiaire, tu peux très bien à ce moment là le renvoyer vers un log. Puis tout fonctionne et tu supprimes la ligne et au final tout le job se fait en mémoire.

Jolie explication pour "autheur". On sent que tu es enseignant