comment vérifier si $1 et $2 sont nuls ?

Puisque c'est marqué bash je recommande d'utiliser l'option construction de test étendue ( [[...]] ) et oubliez les citations :

if [[ -z $1 && -z $2 ]]; then
...

À moins que vous ne souhaitiez sh /POSIX, il n'y a aucune raison de ne pas utiliser [[ ]] .

Ce qui suit fonctionne également,

if [ "$1" == "" && "$2" == ""]; then
    echo NULL
fi

_{Pour l'ancienne version de la réponse, voir la deuxième partie de cette réponse. Si vous voulez connaître les détails, lisez la suite.}

La cause du problème

Dans la question elle-même, il est rapporté que le PO voit too many arguments error qui, lorsqu'il est testé dans bash ne semble pas être le cas :

$ [ $1 != '' ] && [ $2 != '' ]
bash: [: !=: unary operator expected

Avec /bin/sh qui est en fait un lien symbolique vers /bin/dash sur Ubuntu, erreur signalée comme suit :

$ sh
$ [ $1 != '' ] && [ $2 != '' ]
sh: 1: [: !=: unexpected operator

Et le standalone /bin/test également :

$ /usr/bin/test $1 != ''  
/usr/bin/test: missing argument after ‘’

Sidenote : Si vous vous demandez ce qu'est la /usr/bin/test et pourquoi j'utilise bash y sh alors vous devez savoir que [ est un alias pour test qui existe aussi comme exécutable autonome ou plus communément - comme Shell intégré qui est ce que chaque Shell utilisera en premier. Comme pour if ils opèrent sur des statuts de sortie de commandes, d'où la raison pour laquelle [ y test sont des commandes, tout le reste étant des arguments pour ces commandes - un ordre incorrect de ces arguments de ligne de commande entraîne des erreurs.

Retour au sujet : il n'est pas clair comment OP a obtenu l'erreur sans rapport. Cependant, dans les 3 cas, le problème est le même - une variable non définie sera traitée comme vide, donc ce que le Shell voit avec ces variables non liées est

[ != '' ]

qui rompt la syntaxe qui test comprend. Vous vous souvenez de ce que j'ai dit à propos de l'ordre inapproprié des arguments de la ligne de commande ? D'où l'importance de la citation. Activons la sortie de diagnostic et voyons ce que Shell exécute :

$ set -x
# throws error
$ [ $1 != '' ] && [ $2 != '' ] 
+ '[' '!=' '' ']'
bash: [: !=: unary operator expected
# no error
$ [ "$1" != '' ] && [ "$2" != '' ] || echo null vars
+ '[' '' '!=' '' ']'
+ echo null vars
null vars

Meilleure façon de tester les variables non définies

Une approche très fréquente que vous voyez autour est la suivante :

 if [ "x$var1" == "x"  ] && [ "x$var2" == "x"  ];                                                                
 then
     echo "both variables are null"
 fi

Je cite Gilles :

Dans [ "x$1" = "x" ], le préfixe x garantit que x"$1" ne peut pas ressembler à un opérateur, et donc la seule façon dont le Shell peut analyser ce test est de traiter = comme un opérateur binaire.

On peut supposer que cela devrait être assez portable, puisque j'ai vu cela dans /bin/sh scripts. Il peut également être combiné comme dans

if [ "x${var1}${var2}" == "x" ]; then
    ...
fi

Bien sûr, nous pourrions utiliser -z Cependant, d'après les recherches effectuées dans certains shells, en particulier ksh88 (d'après Stéphane Chazelas ), cet indicateur est défectueux.

Voir aussi

• Performance de la commande de test dans différents Shell.
• [Opérateurs Bash \[ vs \[\[ vs ((](https://unix.stackexchange.com/questions/306111/what-is-the-difference-between-the-bash-operators-vs-vs-vs)

Je pense que le titre du message n'est pas exact, car l'intention dans le message était de vérifier si $1 et $2 ne sont pas nuls. Dans l'exemple donné, il manquait juste les guillemets doubles dans $1 et $2 pour que cela fonctionne. Les variables doivent être entre guillemets pour être développées lors de la comparaison de chaînes de caractères. Mais vérifier si $1 et $2 existent revient à vérifier si $2 existe, car il ne peut pas exister si $1 n'existe pas. La commande 'if' n'est pas non plus nécessaire dans ce cas, car 'test' renvoie un vrai/faux et utilise '&&' comme 'then' si le retour est 0/vrai :

[ "$2" != '' ] && commands...

Plus simple, avec -n (non nul) :

[ -n "$2" ] && commands...

"Vérifier si $1 et $2 sont nuls" serait la même chose que vérifier s'il n'y a pas de paramètre :

[ $# -eq 0 ] && commands...