En Bash, comment tester si une variable est définie en “-u” mode

Je viens de découvrir set -u en bash et il m'a aidé à trouver plusieurs inédits de bugs. Mais j'ai aussi un scénario où j'ai besoin de tester si une variable est définie avant le calcul de certaines valeur par défaut. Le meilleur que j'ai trouvé pour cela est la suivante:

if [ "${variable-undefined}" == undefined ]; then
    variable="$(...)"
fi

qui fonctionne (tant que la variable n'a pas la valeur de la chaîne undefined). Je me demandais si il y avait une meilleure façon?

InformationsquelleAutor Ramon | 2012-07-06
  1. 30

    Ce qui Ne fonctionne pas: Test de Chaînes de Longueur Nulle

    Vous pouvez tester undefined chaînes de plusieurs façons. En utilisant le standard de test conditionnel ressemble à ceci:

    # Test for zero-length string.
[ -z "$variable" ] || variable='foo'

    Cela ne fonctionnera pas avec set -u, cependant.

    Ce Qui Fonctionne: Cession Conditionnelle

    Alternativement, vous pouvez utiliser cession conditionnelle, ce qui est un plus Bash-like façon de le faire. Par exemple:

    # Assign value if variable is unset or null.
: "${variable:=foo}"

    En raison de la façon Bash gère l'expansion de cette expression, vous pouvez utiliser en toute sécurité avec cette set -u sans l'obtention d'un "bash: variable: unbound variable d'erreur".

    • La deuxième : 🙂
    • Ce n'est pas tout à fait répondre à la question qu'il ne fournit pas un moyen de tester une variable non définie, tout simplement une façon de le définir lors de il est. Si la logique est souhaitable, ce n'est pas aider.
    • Cette réponse semble être plus approprié pour simplement faire un test: unix.stackexchange.com/a/56846/18985
    • Cette question se réfère spécifiquement à l'attribution d'une valeur par défaut si la variable n'est pas définie; tandis qu'il y a valide les cas d'utilisation pour tester si une variable est définie, sans par la suite le fixer, cette question n'en a pas besoin.
    • ce n'est qu'à la tête de : faire ?
    • apparemment : est un alias de vrai: stackoverflow.com/questions/3224878/...
    • alors ... : $COMMAND permettrait d'évaluer à vrai quel que soit le résultat de la commande ? un peu comme - COMMAND avec les makefiles ?
    • De façon pragmatique, le premier : fournit la coquille un moyen d'effectuer des agrandissements que de définir des valeurs sans avoir à utiliser plus détaillé des constructions comme les [[ -z "$variable" ]] || variable='foo'. Vous avez également besoin d'elle dans les endroits où un simple commentaire ne serait pas analyser correctement, comme un vide d'action dans une instruction if-then comme if true; then; fi (qui soulève -bash: syntax error near unexpected token `;'), plutôt que de if true; then :; fi (qui fonctionne sans erreurs).

    InformationsquelleAutor Todd A. Jacobs
  2. 52

    C'est ce que j'ai trouvé qui fonctionne le mieux pour moi, tirant son inspiration de l'autre répond:

    if [ -z "${varname- }" ]; then
  ...
  varname=$(...)
fi
    • Meilleure réponse à la question à mon humble avis.
    • Quelqu'un peut m'expliquer pourquoi "${varname- }" et "${varname:- }" œuvres? Je suis surpris de voir les premiers travaux.
    • tldp.org/LDP/abs/html/parameter-substitution.html ${varname- } est une forme de ${varname-par défaut}. Si varname est pas de définir la valeur par défaut est renvoyée, dans ce cas, une chaîne vide.
    • Le colon, les versions gratuites sont décrites dans une phrase rapide dans la page de man, juste avant les différents opérateurs sont décrits. Il est facile de rater. ${varname:-foo} étend à foo si varname est unset ou définir une chaîne de caractères vide; ${varname-foo} étend uniquement à foo si varname n'est pas définie.
    • M'a sauvé la construire aujourd'hui 😛
    • Ce ne peut pas toujours distinguer une variable qui est définie à la valeur vide contre une variable n'est pas définie.

    InformationsquelleAutor Ramon
  3. 7

    En bash 4.2 et versions plus récentes, il est de manière explicite à vérifier si une variable est définie, qui consiste à utiliser -v.
    L'exemple de la question pourrait alors être mis en œuvre comme ceci: 

    if [[ ! -v variable ]]; then
   variable="$(...)"
fi

    Voir http://www.gnu.org/software/bash/manual/bashref.html#Bash-Conditional-Expressions

    Si vous ne souhaitez définir la variable, si elle n'est pas déjà défini, vous êtes probablement mieux de faire quelque chose le long de ces lignes:

    variable="${variable-$(...)}"

    Notez que cela ne traite pas avec un définies, mais la variable vide.

    • Gardez à l'esprit que -v n'a pas été ajouté bash jusqu'à la version 4.2.
    • merci, mise à jour de la réponse en conséquence
    InformationsquelleAutor Felix Leipold
  4. 5

    Les réponses ci-dessus ne sont pas dynamiques, par exemple, comment le test est variable avec le nom "dummy" est-il défini? Essayez ceci:

    is_var_defined()
{
    if [ $# -ne 1 ]
    then
        echo "Expected exactly one argument: variable name as string, e.g., 'my_var'"
        exit 1
    fi
    # Tricky.  Since Bash option 'set -u' may be enabled, we cannot directly test if a variable
    # is defined with this construct: [ ! -z "$var" ].  Instead, we must use default value
    # substitution with this construct: [ ! -z "${var:- }" ].  Normally, a default value follows the
    # operator ':-', but here we leave it blank for empty (null) string.  Finally, we need to
    # substitute the text from $1 as 'var'.  This is not allowed directly in Bash with this
    # construct: [ ! -z "${$1:- }" ].  We need to use indirection with eval operator.
    # Example: $1="var"
    # Expansion for eval operator: "[ ! -z ${$1:- } ]" -> "[ ! -z ${var:- } ]"
    # Code  execute: [ ! -z ${var:- } ]
    eval "[ ! -z ${$1:- } ]"
    return $?  # Pedantic.
}

    Connexes: Comment vérifier si une variable est définie en Bash?

    • Ne serait-il pas préférable d'utiliser [[ -n $var ]] ou [[ $var ]] au lieu de [ ! -z "$var" ]? Aussi pour info Bash a un support pour la variable d'indirection depuis la v2, donc il n'est pas nécessaire pour les eval ici. E. g. is_var_defined(){ if (( $# != 1 )); then echo "Expected exactly one argument: variable name as string, e.g., 'my_var'" >&2; return 1; fi; [[ -n ${!1:- } ]]; }
    InformationsquelleAutor kevinarpe
  5. 1

    Au début de votre script, vous pouvez définir vos variables avec une valeur vide

    variable_undefined=""

    Puis

    if [ "${variable_undefined}" == "" ]; then
    variable="$(...)"
fi
    • Les tirets ne sont pas valides nom de la variable de caractères. C'est une partie de l'paramètre d'extension de la syntaxe que l'OP est l'aide.
    • Ensuite, il est préférable de tester avec -z pour vérifier si la taille de la chaîne est égale à zéro
    • vous ne pouvez pas développer une variable non définie dans set -u mode afin de le lancer à travers test -z, d'où cette question.
    • Merci pour l'information
    • J'aime cette façon de contourner le problème, car il vous oblige à "déclarer" vos variables en haut de votre script.
    • Cela ne fonctionne pas lorsque vous avez besoin d'utiliser des variables d'environnement définies par d'autres processus.

    InformationsquelleAutor Luc M
  6. 1

    Malheureusement [[ -v variable ]] n'est pas pris en charge dans les anciennes versions de bash (au moins pas dans la version 4.1.5 j'ai sur Debian Squeeze)

    Vous pouvez utiliser une sous-shell comme ceci :

    if (true $variable)&>/dev/null; then
    variable="$(...)"
fi
    InformationsquelleAutor efa
  7. 0
    if [ "${var+SET}" = "SET" ] ; then
    echo "$var = ${var}"
fi

    Je ne sais pas comment loin en arrière ${var+valeur} est pris en charge, mais ça marche au moins aussi loin que 4.1.2. Les versions plus anciennes n'ont pas ${var+valeur}, ils n'avaient que ${var:+valeur}. La différence est que ${var:+valeur} sera seulement évaluer la "valeur" si $var est définie à une non vide chaîne, tandis que ${var+valeur} permettra également d'évaluer la "valeur" si $var est vide.

    Sans [[ -v var ]] ou ${var+valeur} je pense que vous auriez à utiliser une autre méthode. Probablement un shell interne est exécuté test a été décrit dans une précédente réponse:

    if ( set -u; echo "$var" ) &> /dev/null; then
    echo "$var = ${var}
fi

    Si votre shell processus de "set-u" active déjà ça va être actif dans le shell interne est exécuté aussi bien sans la nécessité d'établir un "u" à nouveau, mais y compris dans le shell interne est exécuté de commande permet à la solution de fonctionne aussi si le parent n'a pas eu les "u" est activé.

    (Vous pouvez aussi utiliser un autre processus comme "printenv" ou "env" pour tester la présence de la variable, mais ça ne fonctionne que si la variable est exporté.)

    InformationsquelleAutor George