Comment savoir si une chaîne n'est pas définie dans un script shell Bash

Si je veux vérifier la chaîne nulle, je le ferais

[ -z $mystr ]

mais que faire si je veux vérifier si la variable a été définie? Ou n'y a-t-il pas de distinction dans les scripts Bash?

Je pense que la réponse que vous recherchez est implicite (sinon énoncée) par la réponse de Vinko , bien qu'elle ne soit pas énoncée simplement. Pour distinguer si VAR est défini mais vide ou non défini, vous pouvez utiliser:

if [ -z "${VAR+xxx}" ]; then echo VAR is not set at all; fi
if [ -z "$VAR" ] && [ "${VAR+xxx}" = "xxx" ]; then echo VAR is set but empty; fi

Vous pouvez probablement combiner les deux tests de la deuxième ligne en un seul avec:

if [ -z "$VAR" -a "${VAR+xxx}" = "xxx" ]; then echo VAR is set but empty; fi

Cependant, si vous lisez la documentation d'Autoconf, vous constaterez qu'ils ne recommandent pas de combiner les termes avec « -a» et recommandent d'utiliser des tests simples séparés combinés avec &&. Je n'ai pas rencontré de système présentant un problème; cela ne veut pas dire qu'ils n'existaient pas (mais ils sont probablement extrêmement rares de nos jours, même s'ils n'étaient pas aussi rares dans un passé lointain).

Vous pouvez trouver les détails de ceux-ci, ainsi que d'autres extensions de paramètres de shell connexes , la commande testou[ et les expressions conditionnelles dans le manuel Bash.

J'ai récemment été interrogé par e-mail sur cette réponse avec la question:

Vous utilisez deux tests, et je comprends bien le second, mais pas le premier. Plus précisément, je ne comprends pas la nécessité d'une expansion variable

if [ -z "${VAR+xxx}" ]; then echo VAR is not set at all; fi

Cela ne ferait-il pas la même chose?

if [ -z "${VAR}" ]; then echo VAR is not set at all; fi

Bonne question - la réponse est «Non, votre alternative plus simple ne fait pas la même chose».

Supposons que j'écris ceci avant votre test:

VAR=

Votre test dira "VAR n'est pas du tout défini", mais le mien dira (par implication car il ne fait écho à rien) "VAR est défini mais sa valeur peut être vide". Essayez ce script:

(
unset VAR
if [ -z "${VAR+xxx}" ]; then echo JL:1 VAR is not set at all; fi
if [ -z "${VAR}" ];     then echo MP:1 VAR is not set at all; fi
VAR=
if [ -z "${VAR+xxx}" ]; then echo JL:2 VAR is not set at all; fi
if [ -z "${VAR}" ];     then echo MP:2 VAR is not set at all; fi
)

La sortie est:

JL:1 VAR is not set at all
MP:1 VAR is not set at all
MP:2 VAR is not set at all

Dans la deuxième paire de tests, la variable est définie, mais elle est définie sur la valeur vide. C'est la distinction que font les notations ${VAR=value}et ${VAR:=value}. Idem pour ${VAR-value}et ${VAR:-value}, et ${VAR+value}et ${VAR:+value}, et ainsi de suite.

Comme Gili le souligne dans sa réponse , si vous utilisez bashl' set -o nounsetoption, la réponse de base ci-dessus échoue unbound variable. On y remédie facilement:

if [ -z "${VAR+xxx}" ]; then echo VAR is not set at all; fi
if [ -z "${VAR-}" ] && [ "${VAR+xxx}" = "xxx" ]; then echo VAR is set but empty; fi

Ou vous pouvez annuler l' set -o nounsetoption avec set +u( set -uéquivalent à set -o nounset).

~> 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 également pour les variables non définies. Pour faire la distinction entre un indéfini et un défini, vous utiliseriez les éléments listés ici ou, avec des explications plus claires, ici .

La manière la plus propre est d'utiliser l'expansion comme dans ces exemples. Pour obtenir toutes vos options, consultez la section Extension des paramètres du manuel.

Autre mot:

~$ 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 utiliseriez l'un de ceux-ci différemment, en mettant la valeur souhaitée au lieu de «valeur par défaut» et en utilisant l'expansion directement, le cas échéant.

Guide de création de scripts bash avancé, 10.2. Substitution de paramètres:

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

pour baser la logique de votre programme sur la définition ou non de la variable $ mystr, 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 a été définie

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

Autres trucs 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 j'ai utilisé ':' pour ne pas faire exécuter le contenu de $ mystr en tant que 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 (une qui est plus lisible et fonctionne avec set -o nounsetactivé). 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 manière explicite de vérifier une variable en cours de définition serait:

[ -v mystr ]

une autre option: l'extension "list array index" :

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

le seul moment où cela se développe en chaîne vide est quand foon'est pas défini, vous pouvez donc 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

pour ne pas jeter ce vélo encore plus loin, mais je voulais ajouter

shopt -s -o nounset

est quelque chose que vous pouvez ajouter en haut d'un script, ce qui entraînera une erreur si les variables ne sont déclarées nulle part dans le script. Le message que vous voyez est unbound variable, mais comme d'autres le mentionnent, il n'attrapera pas une chaîne vide ou une valeur nulle. Pour nous assurer qu'aucune valeur individuelle n'est vide, nous pouvons tester une variable au fur et à mesure qu'elle est développée avec ${mystr:?}, également appelée expansion du signe dollar, ce qui entraînerait une erreur avec parameter null or not set.

Le manuel de référence de Bash est une source d'informations 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 la section 6.3.2 .)

Notez que l'espace après l'ouverture [et avant le ]n'est pas facultatif .

Conseils pour les utilisateurs de Vim

J'avais 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 ressembler à ceci:

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

J'ai pu automatiser cela dans vim en utilisant une expression régulière rapide:

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

Cela peut être appliqué en sélectionnant visuellement les lignes pertinentes, puis en les tapant :. La barre de commandes pré-remplit avec :'<,'>. Collez la commande ci-dessus et appuyez 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 Windows peuvent souhaiter des fins de ligne différentes.

Voici ce que je pense être un moyen beaucoup plus clair de vérifier si une variable est définie:

var_defined() {
    local var_name=$1
    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

Une version plus courte pour tester une variable non définie peut simplement être:

test -z ${mystr} && echo "mystr is not defined"

call set sans aucun argument .. il affiche tous les vars définis ..
les derniers sur la liste seraient ceux définis dans votre script ..
ainsi vous pourriez diriger sa sortie vers quelque chose qui pourrait comprendre ce qui est défini et ce qui ne l'est pas