[Bash] Fournir un pipe en paramètre à une fonction

Version imprimable

Salut !

J'essaie de créer une fonction toute bête qui à un moment exécute ce qu'on lui envoie :

Exemple :

Code:

function f() { $*; echo coucou; }

Mais je n'arrive pas à fournir à cette fonction le paramètre pipe : |

Voici mes tests :
Code:

1 2 f ls -l | wc -l 4
wc est executé après f ls -l, comme un pipe normal quoi
Code:

1 2 3 4 5 6 7 8 f ls -l \| wc -l f "ls -l | wc -l" f "ls -l \| wc -l" f 'ls -l | wc -l' f 'ls -l \| wc -l' ls: impossible d'accéder à |: Aucun fichier ou dossier de ce type ls: impossible d'accéder à wc: Aucun fichier ou dossier de ce type coucou
Je ne sais comment faire.

Avez vous une idée ?

Merci d'avance.

27/02/2013, 07h27
Sve@r
Salut
Faut que tu fournisses à f() le résultat de ls -l | wc -l, tout comme tu pourrais lui fournir le résultat de toute autre commande. Donc faut que ls -l | wc -l soit exécuté en sous-shell...
Code:

1 2 f $(ls -l | wc -l) f `ls -l | wc -l`
A+ 8-)
27/02/2013, 13h51
Invité

Quelle est la meilleure méthode à utiliser entre le dollar et le quote pour remplacer la commande par le résultat? C'est pour ma culture générale du shell ^_^
27/02/2013, 18h18
SmallFitz
Citation:
Envoyé par Sve@r

Salut
Faut que tu fournisses à f() le résultat de ls -l | wc -l, tout comme tu pourrais lui fournir le résultat de toute autre commande. Donc faut que ls -l | wc -l soit exécuté en sous-shell...

Code:

1 2 f $(ls -l | wc -l) f `ls -l | wc -l`

A+ 8-)
Merci pour ta réponse !

Malheureusement, ce n'est pas ce que je souhaite faire =P
Je voudrais que les paramètres que je lui envoie soient exécuté à un certain moment
DANS la fonction.
J'aimerais fournir à f une chaine de caractère composée d'un pipe.
Puis que f appelle cette chaine de caractère pour pouvoir exécuter tout ce qu'elle contient.

Ou est-ce impossible ?
27/02/2013, 18h36
N_BaH

Bonjour,

je vais te le dire gentiment : par souci de sécurité, ce n'est pas souhaitable.

expose plus en détail la raison pour laquelle tu penses devoir faire ainsi, on cherchera une solution plus sûre.
27/02/2013, 19h36
SmallFitz

Merci de me le dire gentiment ! :D

Ma fonction f est en fait une fonction qui va me permettre de chronométrer le temps
d'exécution de la commande que je lui passe en paramètre.
Pour cela elle utilise time et exécute 10.000 fois la commande.
Je compte comparer ainsi diverses commandes, pour savoir laquelle je dois utiliser.
Ca peut paraitre un peu pointu, mais c'est pourtant purement par curiosité.
Je débute en bash, mais je suis en vac et j'ai décidé de faire ces tests...
Alors oui, je pourrai me passer de cette fonction, et le faire à le répéter à chaque fois à la main... C'est juste moche.

Comme vous le voyez la sécurité je m'en tamponne un peu... =P
27/02/2013, 19h41
Sve@r
Citation:

Envoyé par Beginner.j

Quelle est la meilleure méthode à utiliser entre le dollar et le quote pour remplacer la commande par le résultat? C'est pour ma culture générale du shell ^_^

Salut
Les backquotes sont le standard Bourne Shell. Le $() a été amené avec les améliorations du Bourne Again Shell.
Donc si tu écris du shell sur (ou pour) de vieux Unix qui n'ont pas bash, tu devras te conformer au standard.

Le $() ; en dehors d'être aussi plus visible, est aussi plus utile pour imbriquer des sous-sous shell

Exemple: La factorielle récursive où tu programmes n * fact(n-1)
Code:

1 2 3 4 5 6 7 8 9 fact() { if test $1 -lt 2; then echo 1 return fi expr $1 \* $(fact $(expr $1 - 1)) } fact 5
Si tu dois l'écrire en Bourne Shell avec les backquotes, soit tu passes par une variable intermédiaire...
Code:

1 2 3 4 5 6 7 8 9 10 11 fact() { if test $1 -lt 2; then echo 1 return fi tmp=`expr $1 - 1` expr $1 \* `fact $tmp` } fact 7
Soit tu devras protéger les backquotes inférieures par un backslash
Code:

1 2 3 4 5 6 7 8 9 10 fact() { if test $1 -lt 2; then echo 1 return fi expr $1 \* `fact \`expr $1 - 1\`` } fact 9
Et s'il y a encore un sous-sous niveau tu devras alors mettre des backslash eux-mêmes protégés par des backslash et toujours ensuite 2 fois le nb e backslashes précédents + 1 ce qui devient vite illisible

Code:

result=`commande1 \`commande2 \\\`commande3 \\\\\\\`commande4\\\\\\\`\\\`\``

Alors qu'avec le dollar...

Code:

result=$(commande1 $(commande2 $(commande3 $commande4)))

Ce sont les seules différences que je vois à l'une ou l'autre méthode. Mais sinon rien question perfos...

Citation:

Envoyé par SmallFitz

Ma fonction f est en fait une fonction qui va me permettre de chronométrer le temps
d'exécution de la commande que je lui passe en paramètre.
Pour cela elle utilise time et exécute 10.000 fois la commande.
Je compte comparer ainsi diverses commandes, pour savoir laquelle je dois utiliser.
Alors oui, je pourrai me passer de cette fonction, et le faire à le répéter à chaque fois à la main... C'est juste moche.

A chaud (sans tester) je penserais à eval permettant de transformer une chaine en instruction shell
Code:

1 2 3 4 5 f() { eval $* } f "ls -l | wc -l"
Mais (en dehors de me prendre la main virtuelle de N_Bah dans la tronche virtuelle de mon égo), je ne sais pas trop comment eval va gérer le pipe...

Citation:

Envoyé par SmallFitz

Je débute en bash,

Tu es doué pour un débutant. Tes premiers essais étaient très bien pensés...

Citation:

Envoyé par SmallFitz

Comme vous le voyez la sécurité je m'en tamponne un peu... =P

C'est mal. On commence par prendre de mauvaises habitudes puis plus tard quand on se met à faire des choses plus sérieuses...:aie:
27/02/2013, 20h31
N_BaH
utilise des fonctions :
Code:

1 2 3 f() { $*;} ff() { ls $HOME | wc- l;} f ff

Alors reprenons.

Code:

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
ls -l | wc -l
40
 
function f { $*; }
 
f ls -l | wc -l
40
 
function f2 { echo "$FUNCNAME reçoit $# paramètre(s)."; $*; }
f2 ls -l | wc -l
41
 
f2 "ls -l | wc -l"
f2 reçoit 1 paramètre(s).
ls: impossible d'accéder à |: Aucun fichier ou dossier de ce type
ls: impossible d'accéder à wc: Aucun fichier ou dossier de ce type
 
function f3 { echo "$FUNCNAME reçoit $# paramètre(s) : $*"; eval $*; }
f3 "ls -l | wc -l"
f3 reçoit 1 paramètre(s) : ls -l | wc -l
40
 
function f_commande { ls -l | wc -l; }
f3 f_commande
f3 reçoit 1 paramètre(s) : f_commande
40
 
function f4 { echo "$FUNCNAME reçoit $# paramètre(s) : $*"; $*; }
f4 f_commande
f4 reçoit 1 paramètre(s) : f_commande
40

Je pense donc utiliser eval (évite de faire appel à une fonction à chaque tour de boucle).
Quoique, qu'est-ce qui est le plus rapide : eval ou l'appel de fonction ?
Ahah encore un truc à chronométrer :D

J'aurais découvert le mot clef eval, et je vois désormais les fonctions d'un oeil nouveau.

Merci beaucoup à vous deux ! =)

27/02/2013, 23h40
N_BaH

Citation:

Ahah encore un truc à chronométrer

tiens nous au courant :)

Citation:

Envoyé par N_BaH

tiens nous au courant :)

Avec plaisir ! =)

Le script utilisé :

Code:

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
48
49
50
51
52
53
54
55
 
#!/bin/bash
 
function chronoEval()
{
	echo "$FUNCNAME ($1 appels)..."
 
		declare -i i=0 
 
		time (
				while (( $i < $1 )); do
				{   
				eval $2 &> /dev/null  
				i=`expr $i + 1`
				}   
				done
		     )   
}
 
function chronoFonction()
{
	echo "$FUNCNAME ($1 appels)..."
 
		declare -i i=0 
 
		time (
				while (( $i < $1 )); do
				{   
				$2 &> /dev/null
				i=`expr $i + 1`
				}   
				done
		     )   
}
 
function fonction { pwd; }
 
function comparer 
{ 
	echo "Comparaison en répétant $1 fois chaque commande."
		chronoEval "$1" "pwd"
		chronoFonction "$1" fonction
}
 
date
 
comparer 1
comparer 10
comparer 100
comparer 1000
comparer 10000
comparer 100000
comparer 1000000
 
date

La sortie générée :

Code:

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
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
 
jeudi 28 février 2013, 00:53:44 (UTC+0100)
	Comparaison en répétant 1 fois chaque commande.
	chronoEval (1 appels)...
 
	real	0m0.003s
	user	0m0.000s
	sys	0m0.000s
	chronoFonction (1 appels)...
 
	real	0m0.003s
	user	0m0.000s
	sys	0m0.000s
	Comparaison en répétant 10 fois chaque commande.
	chronoEval (10 appels)...
 
	real	0m0.058s
	user	0m0.004s
	sys	0m0.000s
	chronoFonction (10 appels)...
 
	real	0m0.027s
	user	0m0.004s
	sys	0m0.000s
	Comparaison en répétant 100 fois chaque commande.
	chronoEval (100 appels)...
 
	real	0m0.267s
	user	0m0.000s
	sys	0m0.056s
	chronoFonction (100 appels)...
 
	real	0m0.266s
	user	0m0.024s
	sys	0m0.032s
	Comparaison en répétant 1000 fois chaque commande.
	chronoEval (1000 appels)...
 
	real	0m2.791s
	user	0m0.244s
	sys	0m0.348s
	chronoFonction (1000 appels)...
 
	real	0m2.650s
	user	0m0.232s
	sys	0m0.344s
	Comparaison en répétant 10000 fois chaque commande.
	chronoEval (10000 appels)...
 
	real	0m27.741s
	user	0m2.580s
	sys	0m3.376s
	chronoFonction (10000 appels)...
 
	real	0m26.343s
	user	0m2.532s
	sys	0m3.332s
	Comparaison en répétant 100000 fois chaque commande.
	chronoEval (100000 appels)...
 
	real	4m41.745s
	user	0m25.978s
	sys	0m34.434s
	chronoFonction (100000 appels)...
 
	real	4m58.060s
	user	0m25.750s
	sys	0m37.074s
	Comparaison en répétant 1000000 fois chaque commande.
	chronoEval (1000000 appels)...

Pas envie d'attendre 2x40 minutes pour poster le dernier !
Car ces résultats ne sont pas très fiables (voir la comparaison pour 10 exécutions).
J'ai du solliciter l'ordi à ce moment là.

Sinon dans l'ensemble je dirai que l'appel de fonction est plus rapide sur peu d'appel.
Mais dès qu'il y en a vraiment beaucoup, elle se fait distancer par eval.
Bizarre.
Qu'en pensez vous ?

je confirme tes résultats avec ton script, cependant je doute que ce soit l'emploi de l'une ou l'autre méthode qui pèse, car avec un script écrit correctement, j'obtiens des temps d'exécution de 0 à ±39 secondes (sur une machine qui n'est pas récente)

Code:

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
#!/bin/bash
 
chronoEval()
{
   echo "$FUNCNAME ($1 appels)..."
   time for ((i=0;i<$1;i++)); do eval $2 &>/dev/null; done
}
 
chronoFonction()
{
   echo "$FUNCNAME ($1 appels)..."
   time for ((i=0;i<$1;i++)); do $2 &>/dev/null; done
}
 
fonction()
{
   pwd 
}
 
comparer()
{
   echo "Comparaison en répétant $1 fois chaque commande."
   chronoEval "$1" "pwd"
   chronoFonction "$1" fonction
}
 
for ((i=1; i<=1000000;i*=10))
do
   comparer $i
done

à 1000000, l'usage d'une fonction l'emporte de 3 sec
...
?

Code:

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
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
$  ./compare
Comparaison en répétant 1 fois chaque commande.
chronoEval (1 appels)...
 
real    0m0.000s
user    0m0.000s
sys     0m0.000s
chronoFonction (1 appels)...
 
real    0m0.000s
user    0m0.000s
sys     0m0.000s
Comparaison en répétant 10 fois chaque commande.
chronoEval (10 appels)...
 
real    0m0.001s
user    0m0.000s
sys     0m0.000s
chronoFonction (10 appels)...
 
real    0m0.001s
user    0m0.000s
sys     0m0.000s
Comparaison en répétant 100 fois chaque commande.
chronoEval (100 appels)...
 
real    0m0.005s
user    0m0.004s
sys     0m0.000s
chronoFonction (100 appels)...
 
real    0m0.004s
user    0m0.000s
sys     0m0.004s
Comparaison en répétant 1000 fois chaque commande.
chronoEval (1000 appels)...
 
real    0m0.044s
user    0m0.028s
sys     0m0.012s
chronoFonction (1000 appels)...
 
real    0m0.043s
user    0m0.032s
sys     0m0.008s
Comparaison en répétant 10000 fois chaque commande.
chronoEval (10000 appels)...
 
real    0m0.388s
user    0m0.320s
sys     0m0.064s
chronoFonction (10000 appels)...
 
real    0m0.376s
user    0m0.332s
sys     0m0.040s
Comparaison en répétant 100000 fois chaque commande.
chronoEval (100000 appels)...
 
real    0m3.907s
user    0m3.144s
sys     0m0.744s
chronoFonction (100000 appels)...
 
real    0m4.794s
user    0m3.048s
sys     0m0.700s
Comparaison en répétant 1000000 fois chaque commande.
chronoEval (1000000 appels)...
 
real    0m40.697s
user    0m32.254s
sys     0m6.636s
chronoFonction (1000000 appels)...
 
real    0m37.282s
user    0m30.478s
sys     0m6.660s

par contre, pour 100000, la fonction a un coup de mou
...
?

28/02/2013, 11h26
SmallFitz
Citation:

je doute que ce soit l'emploi de l'une ou l'autre méthode qui pèse

Ca marche.

Citation:

car avec un script écrit correctement

Merci pour tes corrections, j'ai appris de nouvelles choses.

Citation:

j'obtiens des temps d'exécution de 0 à ±39 secondes

Je crois que tu fais référence à
Code:

1 2 3 Comparaison en répétant 10000 fois chaque commande. chronoEval 0m0.388s chronoFonction 0m0.376s
Du coup j'en viens à douter sur la lecture de la sortie de time...
Où commencent les secondes ?
0m3.907s <=> ?? Ca ne peut être 90s, les minutes auraient été incrémentées.
0m0.700s <=> ?? Même problème. Du coup je dirais que c'est 7s. Et le précédent 9s.
0m0.376s <=> 3s ??

Je ne sais ce que représentent les chiffres derrière, puisque time est censé afficher des temps en secondes...
28/02/2013, 11h50
N_BaH

lors de mon premier test, pour 1000000 avec eval, c'était 0m39.xxxs (je ne sais plus combien de millièmes), et ~36 secondes avec la fonction.

Ah ok ! Oula je m'étais emmêlé les pinceaux tout seul :D
Code:

1 2 3 4 5 6 7 8 9 $ time sleep 1 real 0m1.003s user 0m0.000s sys 0m0.000s $ time sleep 60 real 1m0.002s user 0m0.000s sys 0m0.000s
Merci encore pour tout.

04/03/2013, 15h48
jack-ft

Citation:

Envoyé par SmallFitz

Du coup j'en viens à douter sur la lecture de la sortie de time...
Où commencent les secondes ?

Moi, je dirais juste après le "m"!

0m3.907s <=> 0 minute et 3.907 seconde (près de 4 secondes)

0m0.700s <=> 0 minute et 0.700 seconde (soit 7/10 de seconde)

0m0.376s <=> 0 minute et 0.376 seconde (soit 376 millisecondes)
05/03/2013, 01h05
SmallFitz

Tu as raison !
Le test au dessus (avec les sleep) m'avait remis sur la voie.