Comparer des arguments

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:

---

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

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:

---

if [ $1 -lt $2 ]

---

et si les arguments sont égaux ?

Bonjour

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

Code:

---

if [ $1 -lt $2 ]

---

ou

Code:

---

if test $1 -lt $2

---

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

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

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

Code:

---

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

Citation:

---

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:

---

if [ $1 -lt $2 ]

---

et si les arguments sont égaux ?

---

ha oui pas bete je doit rajouté cette argument
merci

donc j'en suis a

Code:

---

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

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

et on soigne son indentation !

j'ai donc corriger

par contre un truc ou je capte pas

ce script

Code:

---

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:

---

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

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

Code:

---

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

---

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.

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

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:

---

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:

---

1 2 3 4

if test ! condition then action_a_faire fi

---

Solution3

Code:

---

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

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

donc j'ai terminé le scripts

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

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

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

Citation:

---

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

Citation:

---

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

Citation:

---

Envoyé par bosk1000

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

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

Citation:

---

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

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

Citation:

---

Envoyé par Flodelarab

mais la 6ème ligne est vraiment très crade. :lol:

---

Mais la 6° ligne est justement un but recherché dans l'instruction test ... && echo "test réussi" || echo "test échec"...

merci pour ces remarques

Citation:

---

Envoyé par Sve@r

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.

---

Effectivement j'ai modifié


par contre j'ai pas compris de quoi vous parler pour les "cmd"