Vérifiez le nombre d'arguments passés à un script Bash

Je voudrais que mon script Bash pour imprimer un message d'erreur si l'argument du nombre n'est pas respecté.

J'ai essayé le code suivant:

#!/bin/bash
echo Script name: $0
echo $# arguments 
if [$# -ne 1]; 
    then echo "illegal number of parameters"
fi

Pour une raison inconnue, j'ai l'erreur suivante:

test: line 4: [2: command not found

Ce que je fais mal?

Vous ne devriez pas le nom de votre script test. C'est le nom d'une norme de commande Unix, vous ne voulez pas d'ombre.
Toujours utiliser des espaces autour de '[' ('[[') ou '(' ('((') dans les cas énoncés dans bash.
Pour ajouter à @zoska commentaire, il vous faut un espace avant [ parce qu'il est implémenté comme une commande, essayez " qui ['.
le meilleur exemple est donné sur le lien ci-dessous: stackoverflow.com/questions/4341630/...
sûrement le nommant test est bien tant qu'il n'est pas sur le CHEMIN?
Oui, c'est vrai. Mais il ne faut pas oublier que si il le met dans le CHEMIN, ça ne marchera pas. Éviter d'utiliser le nom contourne ce problème.
Vous avez sans doute aussi envie de sortir avec un code de sortie non nulle après l'impression d'un message si le programme est lancé avec illégale d'un certain nombre de paramètres. Ce lien suggère que certaines personnes utiliser la commande "exit 64', où 64 signifie "ligne de commande utilisation de l'erreur". stackoverflow.com/a/1535733/1102730
Quelques commentaires. Assurez-vous de mettre de l'espace entre les crochets. bash est pointilleux à ce sujet. et assurez-vous que #!/bin/bash en haut du fichier, parce que certains système par défaut pour les plus âgés bourne shell /bin/sh qui est pas certains de la syntaxe du shell bash, mais assez similaire à déconner avec votre tête.

InformationsquelleAutor Naftaly | 2013-09-02

913

Comme toute autre commande simple, [ ... ] ou test nécessite des espaces entre ses arguments.
```
if [ "$#" -ne 1 ]; then
    echo "Illegal number of parameters"
fi
```
Ou
```
if test "$#" -ne 1; then
    echo "Illegal number of parameters"
fi
```
Lors de Bash, préférez l'utilisation de [[ ]] plutôt comme il ne fait pas de couper un mot et le nom de chemin d'expansion de ses variables citant peut-être pas nécessaire, sauf s'il fait partie d'une expression.
```
[[ $# -ne 1 ]]
```
Il a aussi quelques autres fonctionnalités comme non cotées condition de regroupement, de modèle correspondante (extended motif de correspondance avec extglob) et l'expression rationnelle correspondant.

L'exemple suivant vérifie si les arguments sont valables. Il permet à un seul argument ou deux.
```
[[ ($# -eq 1 || ($# -eq 2 && $2 == <glob pattern>)) && $1 =~ <regex pattern> ]]
```
Pour pure expressions arithmétiques, à l'aide de (( )) pour certains peut-être encore mieux, mais ils sont encore possibles dans [[ ]] avec ses opérateurs arithmétiques comme -eq, -ne, -lt, -le, -gt, ou -ge en plaçant l'expression est une chaîne unique argument:
```
A=1
[[ 'A + 1' -eq 2 ]] && echo true  ## Prints true.
```
Qui devrait être utile si vous avez besoin de le combiner avec d'autres fonctions de [[ ]] ainsi.

Références:
- OP: Gardez à l'esprit que [ est juste une autre commande, c'est à dire, essayer which [.
- Les commandes peuvent être intégrés, et peut-être pas. En bash, [ est un builtin, tandis que [[ est un mot-clé. Dans les vieilles coquilles, [ n'est pas encore intégrée. Des commandes comme [ naturellement co-exister en tant qu'une commande externe dans la plupart des systèmes, mais les commandes internes sont priorisés par le shell, à moins que vous dérivation avec command ou exec. Vérifiez que le shell de la documentation sur la façon dont ils évaluent. Prendre note de leur différence, et comment ils peuvent se comporter différemment dans chaque coquille.
InformationsquelleAutor konsolebox
62

Il pourrait être une bonne idée d'utiliser expressions arithmétiques si vous êtes à jongler avec les chiffres.
```
if (( $# != 1 )); then
    echo "Illegal number of parameters"
fi
```
InformationsquelleAutor Aleks-Daniel Jakimenko-A.
34

Sur []: !=, =, == ... sont chaîne opérateurs de comparaison et -eq, -gt ... sont arithmétique les chiffres binaires.

Je voudrais utiliser:
```
if [ "$#" != "1" ]; then
```
Ou:
```
if [ $# -eq 1 ]; then
```
- == est en fait une fonctionnalité non documentée, qui passe pour travailler avec GNU test. Il a également passe pour travailler avec FreeBSD test, mais peut fonctionne pas sur foo test. Le que standard de comparaison est = (juste pour info).
- Il est documenté sur le coup de l'homme entrée: Lorsque l' == et != les opérateurs sont utilisés, la chaîne à droite de l'opérateur est considéré comme un motif et appariés selon les règles décrites ci-dessous en vertu de Pattern Matching. Si l'option shell nocasematch est activé, le match est effectuée sans tenir compte de la casse des caractères alphabétiques. La valeur de retour est 0 si la chaîne correspond à (==) ou ne correspond pas (!=) le motif, et 1 sinon. Une partie du motif peut être cité pour le forcer à être appariés comme une chaîne de caractères.
- C'est exactement ce que Carpetsmoker dit: peut de travail dans certaines implémentations (et en effet, il fonctionne en Bash), mais il n'est pas conforme à POSIX. Par exemple, pour fail avec dash: dash -c '[ 1 == 1 ]'. POSIX ne précise =, et pas ==.
InformationsquelleAutor jhvaras
29

Si vous êtes seulement intéressés par puisage si un argument est absent, Paramètre De Substitution est grande:
```
#!/bin/bash
# usage-message.sh

: ${1?"Usage: $0 ARGUMENT"}
#  Script exits here if command-line parameter absent,
#+ with following error message.
#    usage-message.sh: 1: Usage: usage-message.sh ARGUMENT
```
- n'est-ce pas chargé avec bashisms?
- Serait-il question?
- Pourriez-vous expliquer un peu comment ça fonctionne?
- Je peux si vous avez des questions spécifiques, mais lié à l'article l'explique mieux que je peux.
InformationsquelleAutor Pat
12

Une simple chemise qui fonctionne peut être fait en utilisant:
```
[ "$#" -ne 1 ] && ( usage && exit 1 ) || main
```
Cela revient à:
1. test de la fête de la variable pour la taille de paramètres $# pas est égal à 1 (le nombre de sous-commandes)
2. si vrai, alors l'appel utilisation de la fonction de() et de sortie d'état 1
3. autre appel de la fonction main ()
Pense à noter:
- d'utilisation() peut seulement être simple echo "$0: params"
- principale peut être un long script
- Si vous avez un autre ensemble de lignes après la ligne, ce serait faux depuis exit 1 ne s'appliqueraient que dans le contexte du shell interne est exécuté rendant simplement synonyme de ( usage; false ). Je ne suis pas un fan de cette façon de simplification quand il s'agit des options d'analyse, mais vous pouvez utiliser { usage && exit 1; } à la place. Ou probablement juste { usage; exit 1; }.
- sortie 1 ) travaille pour ksh, zsh, bash, et de revenir à bash 2.0. Le {...} la syntaxe est récente à 4,0+ de bash. Ne m'obtenez pas le mal, si d'une manière qui fonctionne bien pour vous, alors l'utiliser mais n'oubliez pas de ne pas tout le monde utilise la même mise en œuvre de bash que vous faites et nous devrions code de normes de posix pas bashisms.
- Je ne suis pas sûr de ce que vous dites. {...} est une commune de la syntaxe et est disponible pour la plupart, si pas tous les shells basé sur sh, même ceux âgés de coquilles non à la suite de normes de POSIX.
InformationsquelleAutor Dwight Spencer
2

Découvrez cette bash triche, elle peut aider beaucoup.

Pour vérifier la longueur des arguments passés en, vous utilisez "$#"

Pour utiliser le tableau des arguments passés en, vous utilisez "$@"

Un exemple de vérification de la longueur, et l'itération serait:
```
myFunc() {
  if [[ "$#" -gt 0 ]]; then
    for arg in "$@"; do
      echo $arg
    done
  fi
}

myFunc "$@"
```
Ce stage m'a aidé, mais manquait un peu de choses pour moi et ma situation. Espérons que cela aide quelqu'un.

InformationsquelleAutor Nick Hall

Dans le cas où vous voulez être sur le côté sécuritaire, je vous recommande d'utiliser getopts.

Voici un petit exemple:

    while getopts "x:c" opt; do
      case $opt in
        c)
          echo "-$opt was triggered, deploy to ci account" >&2
          DEPLOY_CI_ACCT="true"
          ;;
            x)
              echo "-$opt was triggered, Parameter: $OPTARG" >&2 
              CMD_TO_EXEC=${OPTARG}
              ;;
            \?)
              echo "Invalid option: -$OPTARG" >&2 
              Usage
              exit 1
              ;;
            :)
              echo "Option -$OPTARG requires an argument." >&2 
              Usage
              exit 1
              ;;
          esac
        done

voir plus de détails ici par exemple http://wiki.bash-hackers.org/howto/getopts_tutorial

InformationsquelleAutor IsaacE

0

Ici un simple chemises pour vérifier si un seul paramètre est donné sinon quitter le script:
```
[ "$#" -ne 1 ] && echo "USAGE $0 <PARAMETER>" && exit
```
InformationsquelleAutor panticz.de
-1

Vous devez ajouter des espaces entre les conditions de test:
```
if [ $# -ne 1 ]; 
    then echo "illegal number of parameters"
fi
```
J'espère que cette aide.

InformationsquelleAutor Fabricio

Vous devez vous connecter pour publier un commentaire.

Références: