Discussion :

[big1]

Bonjour,

Voici le script:

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
 
supprimer_les_zeros_du_debut () # Supprime les zéros éventuels au début
{                     # à partir des arguments donnés.
  x=${1#0}
  return ${1#0}       # Le "1 correspond à "$1", argument donné.
                      # Le "0" correspond à ce qui doit être supprimé de "$1".
 
 
}
supprimer_les_zeros_du_debut 0012
echo "return:$?"
echo x:$x

Le résultat de return et la valeur de x ne sont pas les mêmes à la sortie de fonction:

Code :

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

1
2
3
 
return:12
x:012

Une explication?

D'avance merci.

[disedorgue]

Bonjour,

Return retourne un entier et ensuite le shell le transcode en chaine de caractère au besoin (ici pour echo) tandis que la valeur de x est une chaine de caractère et non pas un entier.

[Flodelarab]

Bonjour

Il ne faut pas confondre :

• la sortie standard (canal 1)
• la sortie d'erreur (canal 2)
• la valeur de retour de la fonction (0: tout est bon; 1 ou +: erreur)

Ici, ton return 12 veut dire que le code s'est arrêté avec l'erreur code 12 ... est-ce vraiment ce que tu veux ?
Si tu veux juste un résultat, écris sur la sortie :

Code :

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

echo ${1#0}

Le code de sortie sera 0 (tout a fonctionné) et le résultat sera "012"

[big1]

Bonjour,
Merci pour vos réponses.
Je fais un programme avec une fonction à l’intérieure qui traite une chaine de caractère (enlève les zéros):

Code :

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

1
2
3
4
5
6
7
8
9
10
11
 
supprimer_les_zeros_du_debut () # Supprime les zéros éventuels au début
{                     # à partir des arguments donnés.
  ....${1#0}
  .....
......
 
}
supprimer_les_zeros_du_debut 0012
....
....

Comment je récupère le résultat ?
D'avance merci.

[becket]

Peut être comme ceci :

Code :

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

1
2
3
4
5
6
7
8
 
i=00000012
maSuperFonction( )
{
        echo ${1#0}
}
i=$(maSuperFonction $i)
echo $i

[Flodelarab]

À noter:

• Les fonctions ont une sortie standard.
• Les boucles for ont une sortie standard.
• Les boucles while ont une sortie standard.
• etc

Exemple :

Code :

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

1
2
3
4
5
6
7
8
9
10
$ for ((i=1;i<10;i++));do echo "Voici le nombre $i"; done | while read mot1 mot2 mot3 nombre reste;do echo $nombre; done
1
2
3
4
5
6
7
8
9

Il n'y aucun "Voici" dans la console !

.

Comment je récupère le résultat ?

• Soit tu ne fais rien. Les fonctions ne sont pas des espaces protégés.
  

  Code :

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

  1
  2
  3
  4
  5
  $ toto=0
  $ mafonction() { toto=7; }
  $ mafonction
  $ echo $toto
  7

• Soit tu l'écris sur la sortie standard de la fonction et tu utilises une substitution de commande $( )
  

  Code :

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

  1
  2
  3
  4
  5
  6
  7
  $ toto=0
  $ mafonction() { echo 7; }
  $ mafonction
  7
  $ toto=$(mafonction)
  $ echo $toto
  7

• Soit tu l'écris sur la sortie standard de la fonction et tu reprends cette sortie dans une conduite.
  

  Code :

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

  1
  2
  3
  4
  5
  6
  7
  8
  9
  $ mafonction() { echo -e "16548\n2684687\n3dfgf7\nfini !"; }
  $ mafonction
  16548
  2684687
  3dfgf7
  fini !
  $ mafonction | grep --color 7
  2684687
  3dfgf7

• Soit tu l'écris sur la sortie standard de la fonction et tu rediriges vers un fichier pour stockage.
  

  Code :

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

  1
  2
  3
  4
  5
  6
  7
  $ toto=0
  $ mafonction() { echo 7; }
  $ mafonction
  7
  $ mafonction > monfichier.txt
  $ cat monfichier.txt
  7

• Soit tu l'écris sur la sortie standard de la fonction et tu utilises une substitution de processus <( )
  

  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
  38
  39
  40
  41
  42
  43
  44
  45
  46
  47
  $ echo -e "1\n1\n1\n1\n2\n2\n2\n3\n4\n5\n5\n6\n7"
  1
  1
  1
  1
  2
  2
  2
  3
  4
  5
  5
  6
  7
  $ echo -e "1\n2\n2\n3\n3\n4\n4\n4\n5\n6\n7\n8\n9"
  1
  2
  2
  3
  3
  4
  4
  4
  5
  6
  7
  8
  9
  $ comm <(echo -e "1\n1\n1\n1\n2\n2\n2\n3\n4\n5\n5\n6\n7") <(echo -e "1\n2\n2\n3\n3\n4\n4\n4\n5\n6\n7\n8\n9")
                  1
  1
  1
  1
                  2
                  2
  2
                  3
          3
                  4
          4
          4
                  5
  5
                  6
                  7
          8
          9

  Pour plus d'infos sur cette comparaison de fichiers:
  

  Code :

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

  man comm

[becket]

Code :

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

1
2
3
4
5
 
toto=0
mafonction() { toto=7; }
mafonction
echo $toto

Le bucher !!!

Plus sérieusement, une fonction ( même en bash ) à vocation à être ré-utilisée, c'est pour cette raison qu'il faut éviter de modifier une variable qui n'est serait pas locale

[jack-ft]

Plus sérieusement, une fonction ( même en bash ) à vocation à être ré-utilisée, c'est pour cette raison qu'il faut éviter de modifier une variable qui n'est serait pas locale

En théorie, je suis d'accord que c'est mieux lorsqu'une fonction est... disons fonctionnelle (c'est-à-dire qu'elle retourne un résultat, soit comme code de retour, soit sur la sortie standard).

Mais des fois, c'est pas commode, notamment lorsqu'il faudrait retourner plusieurs résultats.

Je crois qu'on peut quand même éviter le bûcher si on fait une fonction qui sert à initialiser ou remettre à zéro un groupe de variables clairement désignées:

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
reset_env() {
  the_a=''
  the_b=0
  the_c=$1
  the_d=$((the_c + 1))
  the_p=$$
}
reset_env 5
echo "a: '$the_a' b: '$the_b' c: '$the_c' d: '$the_d' p: '$the_p'"
a: '' b: '0' c: '5' d: '6' p: '1181'
 
reset_env 6
echo "a: '$the_a' b: '$the_b' c: '$the_c' d: '$the_d' p: '$the_p'"
a: '' b: '0' c: '6' d: '7' p: '1181'

Cette fonction a pour vocation d'être réutilisée dans un script chaque fois qu'on veut réinitialiser un ensemble cohérent de valeurs.

Évidemment, il serait possible de le faire sous forme fonctionnelle, avec quelque chose comme:

Code :

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

1
2
3
4
5
6
7
reset_env() {
  echo -e "\n0\n$1\n$(($1+1))\n$$"
}
reset_env 6 | { read the_a; read the_b; read the_c; read the_d; read the_p
echo "a: '$the_a' b: '$the_b' c: '$the_c' d: '$the_d' p: '$the_p'"
}
a: '' b: '0' c: '6' d: '7' p: '19767'

Je vous laisse imaginer comment écrire avec les accolades if test $the_d -eq 10; then reset_env 0; fi...

[disedorgue]

Des fois, les références sont pratiques (en bash) :

Code :

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

1
2
3
4
5
6
$ mafct () { echo $1 ; declare -n x=$1 ; x="bar" ;}
$ var=foo
$ mafct var
var
$ echo $var
bar