Comparer des arguments

**bosk1000** · 06/11/2014, 14h31

bonjour à tous

je suis débutant en script shell
je dois écrire mon 1er script
j'ai un exercice dont voici la base:
Ecrire un programme en Bourne Shell qui accepte indifféremment 0,1 ou 2 arguments numériques et les classer en ordre croissant, comme dans l'exemple suivant :
$ classe 26 13
13 est inférieur a 26
$ classe 11
Il manque un argument, entrer votre nombre : 89 (89 entré par l'utilisateur)
11 est inferieur a 89
$ classe
Il manque deux arguments.
Entrer le premier argument : 987 (987 entré par l'utilisateur)
Entrer le second argument : 23 (23 entré par l'utilisateur)
23 est inférieur a 987

donc je commence par comparer les 2 arguments

Code :

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

1
2
3
4
5
6
7
8
 
#!/bin/sh
#set -xv
  if [$1 -lt $2]; then 
	echo "$1 est plus petit que $2"
		else
			echo "$2 est plus petit que $1"
	fi

et j’obtiens :
$ ./test2.sh 12 88
./test2.sh: line 3: [12 : commande introuvable
88 est plus petit que 12

donc pourquoi ma comparaison ne fonctionne pas

merci

**N_BaH** · 06/11/2014, 15h09

les mots d'une phrase doivent être séparés par au moins un espace pour être lus correctement.
c'est pareil en shell !

Code :

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

if [ $1 -lt $2 ]

et si les arguments sont égaux ?

**Flodelarab** · 06/11/2014, 15h10

Bonjour

[ ] est un raccourci pour la commande test. tu comprends donc qu'il faut des espaces autour.

Code :

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

if [ $1 -lt $2 ]

ou

Code :

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

if test $1 -lt $2

le point virgule qui suit ne sert qu'à palier l'absence de retour à la ligne.

**bosk1000** · 06/11/2014, 15h28

ok merci
je comprend mes premières erreur

je vais donc continuer a travailler dessus
je vais certainement revenir avant la fin de la soirée pour poster la suite
et vous redemander de l'aide
merci beaucoup

**bosk1000** · 06/11/2014, 15h40

donc maintenant je cherche la condition si je n'ai qu'un argument ou pas d'argument

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
 
#!/bin/sh
#set -xv
	if [ $# -z ]
  then echo "il manque deux arguments"
	elif [ $2 -z ]
  then echo "il manque un argument"
		elif [ $1 -lt $2 ]
  then echo "$1 est plus petit que $2"
		else
			echo "$2 est plus petit que $1"
	fi

et la j'obtien pour aucun argument saisie
$ ./test2.sh
./test2.sh: line 3: [: 0 : opérateur unaire attendu
il manque un argument

et pour un argument
$ ./test2.sh 88
./test2.sh: line 3: [: 1 : opérateur unaire attendu
il manque un argument

qu'ai je donc raté ?
merci

**bosk1000** · 06/11/2014, 15h45

Envoyé par N_BaH

les mots d'une phrase doivent être séparés par au moins un espace pour être lus correctement.
c'est pareil en shell !

Code :

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

if [ $1 -lt $2 ]

et si les arguments sont égaux ?

ha oui pas bete je doit rajouté cette argument
merci

**bosk1000** · 06/11/2014, 15h49

donc j'en suis a

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
#!/bin/sh
#set -xv
	if [ $# -z ]
  then echo "il manque deux arguments"
		elif [ $1 -eq $2 ]
		then echo "$1 est égal à $2"
			elif [ $2 -z ]
			then echo "il manque un argument"
				elif [ $1 -lt $2 ]
				then echo "$1 est plus petit que $2"
					else
					echo "$2 est plus petit que $1"
	fi

et les résultats obtenus sont :

bosk@bosk-PC ~
$ ./test2.sh 88 88
./test2.sh: line 3: [: 2 : opérateur unaire attendu
88 est égal à 88

bosk@bosk-PC ~
$ ./test2.sh 88 12
./test2.sh: line 3: [: 2 : opérateur unaire attendu
./test2.sh: line 7: [: 12 : opérateur unaire attendu
12 est plus petit que 88

bosk@bosk-PC ~
$ ./test2.sh 88
./test2.sh: line 3: [: 1 : opérateur unaire attendu
./test2.sh: line 5: [: 88 : opérateur unaire attendu
il manque un argument

**disedorgue** · 06/11/2014, 16h02

Bonjour,
Dans ton premier test, c'est:
[ -z ... ] et non pas [ ... -z ]

Un petit détail aussi, on essaie de ne pas mélanger les type de vérifications:
on vérifie si le nombre d'arguments est respecté à part, puis ensuite on les exploite (mais bon, ça c'est pour la forme).

**N_BaH** · 06/11/2014, 16h06

et on soigne son indentation !

**bosk1000** · 06/11/2014, 17h48

j'ai donc corriger

par contre un truc ou je capte pas

ce script

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
 
#!/bin/sh
#set -xv
	if [ -z $# ]
		then echo "il manque deux arguments"
			elif [ $1 -eq $2 ]
			then echo "$1 est égal à $2"
				elif [  -z $2 ]
				then echo "il manque un argument"
					elif [ $1 -lt $2 ]
					then echo "$1 est plus petit que $2"
		else echo "$2 est plus petit que $1"
	fi

amene des erreurs
$ ./test2.sh 88
./test2.sh: line 5: [: 88 : opérateur unaire attendu
il manque un argument

bosk@bosk-PC ~
$ ./test2.sh
est égal à

bosk@bosk-PC ~
$ ./test2.sh 88 88
88 est égal à 88

bosk@bosk-PC ~
$ ./test2.sh 88 12
12 est plus petit que 88

alors que ce code

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
 
#!/bin/sh
#set -xv
		if [  -z $2 ]
			then echo "il manque un argument"
				elif [ -z $# ]
				then echo "il manque deux arguments"
					elif [ $1 -eq $2 ]
					then echo "$1 est égal à $2"
						elif [ $1 -lt $2 ]
						then echo "$1 est plus petit que $2"
		else echo "$2 est plus petit que $1"
	fi

est presque correct, il n'y a que le premier cas qui rate
bosk@bosk-PC ~
$ ./essai
il manque un argument

bosk@bosk-PC ~
$ ./essai 88
il manque un argument

bosk@bosk-PC ~
$ ./essai 88 88
88 est égal à 88

bosk@bosk-PC ~
$ ./essai 88 12
12 est plus petit que 88

**N_BaH** · 06/11/2014, 18h02

si tu tentes de comparer des termes avant de t'assurer qu'ils existent...

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/sh
 
test $# -gt 1 || { 
   echo "l'appel de ce script doit comporter _deux_ arguments numériques
$0 nombre_1 nombre_2"
   exit 1
}
if test $1 -gt $2
then
   echo "$1 est supérieur à $2"
elif test $1 -lt $2
then
   echo "$1 est inférieur à $2"
else
   echo "$1 et $2 sont égaux"
fi

**Flodelarab** · 06/11/2014, 18h10

S'il n'y a pas d'argument, il n'y en a pas 2. La première condition de ton deuxième script fonctionne et court-circuite le reste. Il faut inverser les conditions

Ton premier script a aussi un problème d'ordre dans les tests. La variable $2 est manquante, ce qui provoque une erreur.

**bosk1000** · 06/11/2014, 18h23

donc je dois bien positionner mon ordre d'argument

N_BaH si je comprend bien le code que tu m'a fait suivre

le premier test est pour vérifier qu'il y a plus d'un argument ?
mais pourquoi mettre || ?

**Sve@r** · 06/11/2014, 21h17

Bonjour

Il s'agit d'un raccourci syntaxique qui fonctionne généralement pour une instruction

Exemple: tu veux tester une "non condition" laquelle déclenchera une action à faire

Solution1

Code bash :

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

1
2
3
4
5
6
if test condition
then
    true   # Instruction neutre mais obligatoire car après "then" il faut au-moins une instruction
else
    action_a_faire
fi

Solution2

Code bash :

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

1
2
3
4
if test ! condition
then
    action_a_faire
fi

Solution3

Code bash :

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

test condition || action_a_faire

La solution1 date de l'époque préhistorique où on ne pouvait pas forcément inverser une condition (comme par exemple if ls -d fichier 1>/dev/null 2>&1 qui permettait de détecter l'existence d'un fichier et où l'inverse if ! ls -d fichier 1>/dev/null 2>&1 n'était pas possible).
N_Bah utilise la solution3 (instruction1 || instruction2 qui n'exécutera l'instruction 2 que si l'instruction 1 échoue) mais il la couple à un autre outil shell: les accolades, qui permettent de regrouper plusieurs instructions dans un seul bloc logique. Permis mais à utiliser avec modération si tu ne veux pas ensuite avoir un code illisible...

**bosk1000** · 06/11/2014, 22h19

Merci
Je progresse plus ici qu'en ayant lu tout le bouquin educatel...

donc j'ai terminé le scripts

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
#!/bin/sh
test $# -gt 1 || {
   echo "l'appel de ce script doit comporter _deux_ arguments numériques
$0 nombre_1 nombre_2"
if test $# -eq 1 
	then echo "saisir une valeur"
	read  arg2
	arg1=$1
 
	else test $# -eq 0 
		echo "saisir deux valeur"
		read  arg1 
		read  arg2 
fi	
if test $arg1 -gt $arg2
	then echo "$arg2 est inférieur à $arg1"
	elif test $arg1 -lt $arg2
		then echo "$arg1 est inférieur à $arg2"
			else echo "$arg1 et $arg2 sont égaux"
fi
	exit 1
}
 
if test $1 -gt $2
then
   echo "$2 est inférieur à $1"
elif test $1 -lt $2
then
   echo "$1 est inférieur à $2"
else
   echo "$1 et $2 sont égaux"
fi

et le résultat est correct

mais pour toute amélioration je suis à votre écoute

**Flodelarab** · 06/11/2014, 23h50

cmd1 || cmd2 => exécute cmd2 si cmd1 est fausse
cmd1 && cmd2 => exécute cmd2 si cmd1 est vraie

Et on peut empiler:
cmd1 && cmd2 || cmd3 && cmd4

Il en découle plusieurs comportements: (en vert les vrais, en rouge les faux, en noir les non-exécutés:
cmd1 && cmd2 || cmd3 && cmd4
cmd1 && cmd2 || cmd3 && cmd4
cmd1 && cmd2 || cmd3 && cmd4
cmd1 && cmd2 || cmd3 && cmd4
cmd1 && cmd2 || cmd3 && cmd4
cmd1 && cmd2 || cmd3 && cmd4
cmd1 && cmd2 || cmd3 && cmd4
cmd1 && cmd2 || cmd3 && cmd4

**Sve@r** · 07/11/2014, 08h03

Envoyé par bosk1000

Je progresse plus ici qu'en ayant lu tout le bouquin educatel...

C'est la différence. educatel ce sont des professeurs peut-être motivés mais qui restent des "non informaticiens". Ici, tu n'as que des gens qui en ont fait leur métier...

Envoyé par bosk1000

donc j'ai terminé le scripts

Mouais. S'il n'y en a qu'un seul, de "script", peut-être éviter alors les caractères inutiles...

Envoyé par bosk1000

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
#!/bin/sh
test $# -gt 1 || {
   echo "l'appel de ce script doit comporter _deux_ arguments numériques
$0 nombre_1 nombre_2"
if test $# -eq 1 
	then echo "saisir une valeur"
	read  arg2
	arg1=$1
 
	else test $# -eq 0 
		echo "saisir deux valeur"
		read  arg1 
		read  arg2 
fi	
if test $arg1 -gt $arg2
	then echo "$arg2 est inférieur à $arg1"
	elif test $arg1 -lt $arg2
		then echo "$arg1 est inférieur à $arg2"
			else echo "$arg1 et $arg2 sont égaux"
fi
	exit 1
}
 
if test $1 -gt $2
then
   echo "$2 est inférieur à $1"
elif test $1 -lt $2
then
   echo "$1 est inférieur à $2"
else
   echo "$1 et $2 sont égaux"
fi

mais pour toute amélioration je suis à votre écoute

Ben tu ne sentirais pas que t'as un peu fait tous tes tests 2 fois ? Une fois quand on saisit les arguments, et une seconde fois quand on les passe en paramètre. Et c'est quoi ce else test $# -eq 0 ??? C'est un test inutile vu que tu ne fais pas de choix selon son état. Surtout que t'es dans le cas où $# plus grand que 1 (la partie "||" qui suit le test) donc dans ce cas, $# ne peut pas être égal à 0 (quand je disais "... sinon code illisible !!!")

Si tu veux avoir un script "propre", essaye alors d'évaluer les situations dans l'ordre logique: d'abord l'action à faire si $# = 0, puis si $# = 1 puis sinon. Et une fois que t'as positionné arg1 et arg2 alors tu les évalues...

Envoyé par Flodelarab

Et on peut empiler:
cmd1 && cmd2 || cmd3 && cmd4

Oui mais celle-là je m'en méfie. Parce qu'elle peut produire un "effet de bord".
En effet, si cmd1 est fausse, l'expression étant fausse n'exécutera pas cmd2. L'état "faux" se propagera et ira provoquer l'exécution de cmd3 (puis cmd4 si cmd3 réussi). Et si cmd1 est vraie, cela ira alors exécuter cmd2.
Jusque là, c'est généralement ce qu'on voulait faire, style test truc && echo "ok" || echo "erreur".

Mais si jamais cmd2 renvoie elle-aussi un état "faux", alors cela se propagera aussi et ira provoquer l'exécution de cmd3 (puis aussi cmd4). Ce comportement tu l'as bien écrit dans ta 3° ligne mais il était important qu'on le connaisse en détail vu les dangers qu'il apporte. Remarque, le comportement de ta seconde ligne est lui- aussi super dangereux...

**Flodelarab** · 07/11/2014, 10h06

cmd1: je lave l'assiette
cmd2: j'égoutte l'assiette
cmd3: j'essuie l'assiette
cmd4: je mets l'assiette dans le placard.

Exemple qui fonctionne mais la 6ème ligne est vraiment très crade.