Discussion :

[SmallFitz]

Salut !

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

Exemple :

Code :

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

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

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

Voici mes tests :

Code :

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

1
2
f ls -l | wc -l
4

wc est executé après f ls -l, comme un pipe normal quoi

Code :

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

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.

[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 bash :

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

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

A+

[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 ^_^

[SmallFitz]

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 bash :

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

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

A+

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 ?

[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.

[SmallFitz]

Merci de me le dire gentiment !

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

[Sve@r]

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 bash :

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

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 bash :

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

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 bash :

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

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 bash :

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

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

Alors qu'avec le dollar...

Code bash :

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

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...

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 bash :

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

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...

Je débute en bash,

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

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...

[N_BaH]

utilise des fonctions :

Code :

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

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

[SmallFitz]

Alors reprenons.

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
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

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

Merci beaucoup à vous deux ! =)

[N_BaH]

Ahah encore un truc à chronométrer

tiens nous au courant

[SmallFitz]

tiens nous au courant

Avec plaisir ! =)

Le script utilisé :

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
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 :

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
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 ?

[N_BaH]

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 :

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
#!/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 :

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
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
...
?

[SmallFitz]

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

Ca marche.

car avec un script écrit correctement

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

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

Je crois que tu fais référence à

Code :

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

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...

[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.

[SmallFitz]

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

Code :

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

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.

[jack-ft]

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)

[SmallFitz]

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