Comment vérifier si une variable est définie dans Bash ?

Question

Comment savoir si une variable est définie dans Bash ?

Par exemple, comment vérifier si l'utilisateur a donné le premier paramètre à une fonction ?

function a {
    # if $1 is set ?
}

Answer 1

(Habituellement) La bonne manière

if [ -z ${var+x} ]; then echo "var is unset"; else echo "var is set to '$var'"; fi

où ${var+x} est un expansion des paramètres qui ne vaut rien si var n'est pas défini, et remplace la chaîne x autrement.

Digression de citations

Les guillemets peuvent être omis (nous pouvons donc dire ${var+x} au lieu de "${var+x}" ) parce que cette syntaxe et cette utilisation garantissent qu'il ne se développera que vers quelque chose qui ne nécessite pas de guillemets (puisqu'il se développe soit en x (qui ne contient pas de coupure de mots et n'a donc pas besoin de guillemets), ou à rien (ce qui donne comme résultat [ -z ] qui, comme par hasard, donne la même valeur (vrai) que celle de [ -z "" ] le fait aussi)).

Cependant, bien que les guillemets puissent être omis en toute sécurité, et que cela n'ait pas été immédiatement évident pour tous (ce n'était même pas évident pour le premier auteur de cette explication de citations qui est aussi un important codeur Bash), il serait parfois préférable d'écrire la solution entre guillemets comme suit [ -z "${var+x}" ] au coût très faible d'une pénalité de vitesse O(1). Le premier auteur a également ajouté ce commentaire à côté du code utilisant cette solution en donnant l'URL de cette réponse, qui inclut maintenant aussi l'explication de la raison pour laquelle les guillemets peuvent être omis en toute sécurité.

(Souvent) De la mauvaise façon

if [ -z "$var" ]; then echo "var is blank"; else echo "var is set to '$var'"; fi

Cette méthode est souvent erronée car elle ne fait pas la distinction entre une variable qui n'est pas définie et une variable qui est définie par une chaîne vide. En d'autres termes, si var='' alors la solution ci-dessus produira le message "var is blank".

La distinction entre unset et "set to the empty string" est essentielle dans les situations où l'utilisateur doit spécifier une extension, ou une liste supplémentaire de propriétés, et que le fait de ne pas les spécifier entraîne par défaut une valeur non vide, alors que le fait de spécifier la chaîne vide devrait faire que le script utilise une extension vide ou une liste de propriétés supplémentaires.

Cette distinction n'est toutefois pas indispensable dans tous les cas de figure. Dans ces cas [ -z "$var" ] sera très bien.

Answer 2

Pour vérifier si une variable de type chaîne est non nulle/non zéro, c'est-à-dire si elle est définie, utilisez

if [ -n "$1" ]

C'est le contraire de -z . Je me retrouve à utiliser -n plus que -z .

Vous l'utiliseriez comme :

if [ -n "$1" ]; then
  echo "You supplied the first parameter!"
else
  echo "First parameter not supplied."
fi

Answer 3

Voici comment tester si un paramètre est non activé o empty ("Null") o défini avec une valeur :

+--------------------+----------------------+-----------------+-----------------+
|   Expression       |       parameter      |     parameter   |    parameter    |
|   in script:       |   Set and Not Null   |   Set But Null  |      Unset      |
+--------------------+----------------------+-----------------+-----------------+
| ${parameter:-word} | substitute parameter | substitute word | substitute word |
| ${parameter-word}  | substitute parameter | substitute null | substitute word |
| ${parameter:=word} | substitute parameter | assign word     | assign word     |
| ${parameter=word}  | substitute parameter | substitute null | assign word     |
| ${parameter:?word} | substitute parameter | error, exit     | error, exit     |
| ${parameter?word}  | substitute parameter | substitute null | error, exit     |
| ${parameter:+word} | substitute word      | substitute null | substitute null |
| ${parameter+word}  | substitute word      | substitute word | substitute null |
+--------------------+----------------------+-----------------+-----------------+

Fuente: POSIX : Expansion des paramètres :

Dans tous les cas indiqués par "substitute", l'expression est remplacée par la valeur indiquée. Dans tous les cas indiqués par "assign", le paramètre se voit attribuer cette valeur, qui remplace également l'expression.

Pour montrer cela en action :

+--------------------+----------------------+-----------------+-----------------+
|   Expression       |  FOO="world"         |     FOO=""      |    unset FOO    |
|   in script:       |  (Set and Not Null)  |  (Set But Null) |     (Unset)     |
+--------------------+----------------------+-----------------+-----------------+
| ${FOO:-hello}      | world                | hello           | hello           |
| ${FOO-hello}       | world                | ""              | hello           |
| ${FOO:=hello}      | world                | FOO=hello       | FOO=hello       |
| ${FOO=hello}       | world                | ""              | FOO=hello       |
| ${FOO:?hello}      | world                | error, exit     | error, exit     |
| ${FOO?hello}       | world                | ""              | error, exit     |
| ${FOO:+hello}      | hello                | ""              | ""              |
| ${FOO+hello}       | hello                | hello           | ""              |
+--------------------+----------------------+-----------------+-----------------+

Answer 4

Bien que la plupart des techniques énoncées ici soient correctes, bash 4.2 supporte un test réel pour la présence d'une variable ( coup d'homme ), plutôt que de tester la valeur de la variable.

[[ -v foo ]]; echo $?
# 1

foo=bar
[[ -v foo ]]; echo $?
# 0

foo=""
[[ -v foo ]]; echo $?
# 0

Notamment, cette approche ne provoquera pas d'erreur lorsqu'elle est utilisée pour vérifier la présence d'une variable non définie dans le fichier set -u / set -o nounset contrairement à de nombreuses autres approches, comme l'utilisation du mode [ -z .

Answer 5

Il existe de nombreuses façons d'y parvenir, dont les suivantes :

if [ -z "$1" ]

Cela réussit si $1 est nul ou non défini.