Comment dire si une chaîne de caractères n'est pas définie dans un script shell bash?

~> if [ -z $FOO ]; then echo "EMPTY"; fi
EMPTY
~> FOO=""
~> if [ -z $FOO ]; then echo "EMPTY"; fi
EMPTY
~> FOO="a"
~> if [ -z $FOO ]; then echo "EMPTY"; fi
~> 

- z fonctionne aussi pour les variables non définies. Pour distinguer entre un non défini et un défini, vous utiliseriez les choses énumérées ici ou, avec des explications plus claires, ici .

Cleanest way utilise l'expansion comme dans ces exemples. Pour obtenir toutes vos options, consultez la section expansion des paramètres du manuel.

mot alternatif:

~$ unset FOO
~$ if test ${FOO+defined}; then echo "DEFINED"; fi
~$ FOO=""
~$ if test ${FOO+defined}; then echo "DEFINED"; fi
DEFINED

valeur par défaut:

~$ FOO=""
~$ if test "${FOO-default value}" ; then echo "UNDEFINED"; fi
~$ unset FOO
~$ if test "${FOO-default value}" ; then echo "UNDEFINED"; fi
UNDEFINED

bien sûr, vous utiliserez l'un d'eux différemment, en mettant la valeur que vous voulez au lieu de la valeur par défaut et en utilisant l'extension directement, si approprié.

Advanced bash scripting guide, 10.2. Substitution De Paramètre:

• ${var+blahblah}: si var est défini, 'blahblah' est remplacé par expression, sinon null est substitué
• ${var-blahblah}: si var est défini, il est lui-même substitué, sinon
• $ {var?blahblah}: si var est défini, il est substitué, sinon le fonction existe avec' blahblah ' comme message d'erreur.

pour baser votre logique de programme sur le fait que la variable $mystr est définie ou non, vous pouvez faire ce qui suit:

isdefined=0
${mystr+ export isdefined=1}

maintenant, si isdefined=0 alors la variable n'était pas définie, si isdefined=1 la variable était définie

cette façon de vérifier les variables est meilleure que la réponse ci-dessus parce qu'elle est plus élégante, lisible, et si votre shell bash a été configuré pour faire une erreur sur l'utilisation de variables non définies (set -u) , le script se terminera prématurément.

autres choses utiles:

pour avoir une valeur par défaut de 7 assignée à $mystr si elle n'était pas définie, et la laisser intacte sinon:

mystr=${mystr- 7}

pour imprimer un message d'erreur et quitter la fonction si la variable n'est pas définie:

: ${mystr? not defined}

attention ici que je utilisé': 'afin de ne pas avoir le contenu de $mystr exécuté comme une commande au cas où il serait défini.

Un résumé des tests.

[ -n "$var" ] && echo "var is set and not empty"
[ -z "$var" ] && echo "var is unset or empty"
[ "${var+x}" = "x" ] && echo "var is set"  # may or may not be empty
[ -n "${var+x}" ] && echo "var is set"  # may or may not be empty
[ -z "${var+x}" ] && echo "var is unset"
[ -z "${var-x}" ] && echo "var is set and empty"

https://stackoverflow.com/a/9824943/14731 contient une meilleure réponse (qui est plus lisible et fonctionne avec set -o nounset activé). Cela fonctionne à peu près comme ceci:

if [ -n "${VAR-}" ]; then
    echo "VAR is set and is not empty"
elif [ "${VAR+DEFINED_BUT_EMPTY}" = "DEFINED_BUT_EMPTY" ]; then
    echo "VAR is set, but empty"
else
    echo "VAR is not set"
fi

la façon explicite de vérifier si une variable est définie serait:

[ -v mystr ]

une autre option: le" tableau des indices de liste "expansion :

$ unset foo
$ foo=
$ echo ${!foo[*]}
0
$ foo=bar
$ echo ${!foo[*]}
0
$ foo=(bar baz)
$ echo ${!foo[*]}
0 1

le seul moment où cette extension vers la chaîne vide est quand foo est désactivé, donc vous pouvez le vérifier avec la chaîne conditionnelle:

$ unset foo
$ [[ ${!foo[*]} ]]; echo $?
1
$ foo=
$ [[ ${!foo[*]} ]]; echo $?
0
$ foo=bar
$ [[ ${!foo[*]} ]]; echo $?
0
$ foo=(bar baz)
$ [[ ${!foo[*]} ]]; echo $?
0

devrait être disponible dans n'importe quelle version de bash > = 3.0

ne pas jeter ce vélo encore plus loin, mais a voulu ajouter

shopt -s -o nounset

est quelque chose que vous pouvez ajouter au haut d'un script, qui fera une erreur si les variables ne sont pas déclaré n'importe où dans le script. Le message que vous voyez est unbound variable , mais comme d'autres le mentionnent, il n'attrapera pas de chaîne vide ou de valeur nulle. Pour s'assurer que n'importe quelle valeur individuelle n'est pas vide, nous pouvons tester une variable comme il est étendu avec ${mystr:?} , également connu sous le signe de dollar expansion, qui serait une erreur avec parameter null or not set .

Le Bash Manuel de Référence est une source d'information faisant autorité sur bash.

Voici un exemple de test d'une variable pour voir si elle existe:

if [ -z "$PS1" ]; then
        echo This shell is not interactive
else
        echo This shell is interactive
fi

(de section 6.3.2 .)

notez que l'espace blanc après l'ouverture [ et avant le ] est pas optionnel .

Conseils pour les utilisateurs de Vim

j'ai eu un script qui avait plusieurs déclarations comme suit:

export VARIABLE_NAME="$SOME_OTHER_VARIABLE/path-part"

mais je voulais qu'ils s'en remettent à toutes les valeurs existantes. Alors je les ai réécrits pour qu'ils ressemblent à ceci:

if [ -z "$VARIABLE_NAME" ]; then
        export VARIABLE_NAME="$SOME_OTHER_VARIABLE/path-part"
fi

j'ai pu automatiser cela dans vim en utilisant un regex rapide:

s/\vexport ([A-Z_]+)\=("[^"]+")\n/if [ -z "$" ]; then\r  export =\rfi\r/gc

Ceci peut être appliqué en sélectionnant les lignes visuellement, puis en tapant : . La barre de commande pré-popule avec :'<,'> . Coller la commande ci-dessus et appuyer sur Entrée.

testé sur cette version de Vim:

VIM - Vi IMproved 7.3 (2010 Aug 15, compiled Aug 22 2015 15:38:58)
Compiled by root@apple.com

les utilisateurs de Windows peuvent vouloir des fins de ligne différentes.

voici ce que je pense être une façon beaucoup plus claire de vérifier si une variable est définie:

var_defined() {
    local var_name=
    set | grep "^${var_name}=" 1>/dev/null
    return $?
}

utilisez - le comme suit:

if var_defined foo; then
    echo "foo is defined"
else
    echo "foo is not defined"
fi

l'appel sans aucun argument.. il affiche tous les vars définis..

le dernier sur la liste seront ceux définis dans votre script..

donc vous pourriez pipe sa production à quelque chose qui pourrait comprendre ce que les choses sont définies et ce qui n'est pas