pour vérifier la non-nulle/non-zéro variable de chaîne, c'est à dire si le jeu, utiliser

if [ -n "" ]

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

Voici comment tester si un paramètre est hors fonction , ou vide ("Null") ou avec une valeur :

+--------------------+----------------------+-----------------+-----------------+
|                    |       parameter      |     parameter   |    parameter    |
|                    |   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 |
+--------------------+----------------------+-----------------+-----------------+

Source: POSIX: Paramètre d'Extension :

Dans tous les cas illustré avec "substitut", l'expression est remplacée par la valeur indiquée. Dans tous les cas montrés avec "assign", paramètre est assignée cette valeur, qui remplace l'expression.

il y a plusieurs façons de le faire avec l'une d'entre elles:

if [ -z "" ]

cela succède si 1 $est nul ou unset

alors que la plupart des techniques indiquées ici sont correctes, bash 4.2 supporte un test réel pour la présence d'une variable ( man bash ), 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

pour voir si une variable est non vide, j'utilise

if [[ $var ]]; then ...       # `$var' expands to a nonempty string

les essais opposés si une variable est soit débranchée, soit vide:

if [[ ! $var ]]; then ...     # `$var' expands to the empty string (set or not)

Pour voir si une variable est définie (vide ou non vide), j'utilise

if [[ ${var+x} ]]; then ...   # `var' exists (empty or nonempty)
if [[ ${1+x} ]]; then ...     # Parameter 1 exists (empty or nonempty)

essais opposés si une variable est désactivée:

if [[ ! ${var+x} ]]; then ... # `var' is not set at all
if [[ ! ${1+x} ]]; then ...   # We were called with no arguments

je trouve toujours la table POSIX dans le autre réponse lent à grok, donc voici mon avis sur elle:

   +----------------------+------------+-----------------------+-----------------------+
   |   if VARIABLE is:    |    set     |         empty         |        unset          |
   +----------------------+------------+-----------------------+-----------------------+
 - |  ${VARIABLE-default} | $VARIABLE  |          ""           |       "default"       |
 = |  ${VARIABLE=default} | $VARIABLE  |          ""           | $(VARIABLE="default") |
 ? |  ${VARIABLE?default} | $VARIABLE  |          ""           |       exit 127        |
 + |  ${VARIABLE+default} | "default"  |       "default"       |          ""           |
   +----------------------+------------+-----------------------+-----------------------+
:- | ${VARIABLE:-default} | $VARIABLE  |       "default"       |       "default"       |
:= | ${VARIABLE:=default} | $VARIABLE  | $(VARIABLE="default") | $(VARIABLE="default") |
:? | ${VARIABLE:?default} | $VARIABLE  |       exit 127        |       exit 127        |
:+ | ${VARIABLE:+default} | "default"  |          ""           |          ""           |
   +----------------------+------------+-----------------------+-----------------------+

noter que chaque groupe (avec et sans deux points précédents) a le même ensemble et unset cas, de sorte que la seule chose qui diffère est la façon dont les cas vides sont traités.

avec les deux points précédents, le vide et unset cas sont identiques, donc je voudrais utiliser ceux où possible (i.e. utiliser := , pas seulement = , parce que le cas vide est incohérent).

rubriques:

• set signifie VARIABLE est non-vide ( VARIABLE="something" )
• vide signifie VARIABLE est vide / nul ( VARIABLE="" )
• hors fonction signifie VARIABLE n'existe pas ( unset VARIABLE )

valeurs:

• $VARIABLE le résultat est la valeur initiale de la variable.
• "default" signifie le résultat de la chaîne de remplacement fournie.
• "" signifie que le résultat est nul (un chaîne.)
• exit 127 signifie que le script cesse d'exécuter avec le code de sortie 127.
• $(VARIABLE="default") le résultat est la valeur originale de la variable et la chaîne de remplacement fournie est assignée à la variable pour une utilisation future.

sur une version moderne de Bash (4.2 ou plus tard je pense; Je ne sais pas pour sûr), je voudrais essayer ceci:

if [ ! -v SOMEVARIABLE ] #note the lack of a $ sigil
then
    echo "Variable is unset"
elif [ -z "$SOMEVARIABLE" ]
then
    echo "Variable is set to an empty string"
else
    echo "Variable is set to some string"
fi

if [ "" != "" ]; then
  echo $1 is set
else
  echo $1 is not set
fi

bien que pour les arguments, il est normalement préférable de tester$#, qui est le nombre d'arguments, à mon avis.

if [ $# -gt 0 ]; then
  echo $1 is set
else
  echo $1 is not set
fi

Lire la section" Parameter Expansion "de la page de manuel bash . L'extension des paramètres ne fournit pas de test général pour une variable en cours de définition, mais il y a plusieurs choses que vous pouvez faire à un paramètre si il n'est pas défini.

par exemple:

function a {
    first_arg=${1-foo}
    # rest of the function
}

définit first_arg égal à s'il est assigné, sinon il utilise la valeur"foo". Si a doit absolument prendre un seul paramètre, et aucun bon défaut existe, Vous pouvez sortir avec un message d'erreur quand aucun paramètre n'est donné:

function a {
    : ${1?a must take a single argument}
    # rest of the function
}

(Notez l'utilisation de : comme valeur null commande, qui développe les valeurs de ses arguments. Nous ne voulons rien faire avec dans cet exemple, il suffit de sortir s'il n'est pas défini)

Vous voulez quitter si c'est unset

ça a marché pour moi. Je voulais que mon script sorte avec un message d'erreur si un paramètre n'était pas défini.

#!/usr/bin/env bash

set -o errexit

# Get the value and empty validation check all in one
VER="${1:?You must pass a version of the format 0.0.0 as the only argument}"

cela retourne avec une erreur quand il est lancé

peek@peek:~$ ./setver.sh
./setver.sh: line 13: 1: You must pass a version of the format 0.0.0 as the only argument

Chèque uniquement, pas de sortie Vide et Unset sont INVALIDES

essayez cette option si vous voulez juste vérifier si la valeur set=VALID ou unset/empty=INVALID.

TSET="good val"
TEMPTY=""
unset TUNSET

if [ "${TSET:-}" ]; then echo "VALID"; else echo "INVALID";fi
# VALID
if [ "${TEMPTY:-}" ]; then echo "VALID"; else echo "INVALID";fi
# INVALID
if [ "${TUNSET:-}" ]; then echo "VALID"; else echo "INVALID";fi
# INVALID

Ou, Même à court de tests ;-)

[ "${TSET:-}"   ] && echo "VALID" || echo "INVALID"
[ "${TEMPTY:-}" ] && echo "VALID" || echo "INVALID"
[ "${TUNSET:-}" ] && echo "VALID" || echo "INVALID"

Chèque uniquement, pas de sortie - vide n'est pas VALIDE

Et c'est la réponse à la question. Utilisez ceci si vous voulez juste vérifier si la valeur set/empty=VALID ou unset=INVALID.

NOTE, LE" 1 "dans"..-1}" est insignifiant, il peut être n'importe quoi (comme x)

TSET="good val"
TEMPTY=""
unset TUNSET

if [ "${TSET+1}" ]; then echo "VALID"; else echo "INVALID";fi
# VALID
if [ "${TEMPTY+1}" ]; then echo "VALID"; else echo "INVALID";fi
# VALID
if [ "${TUNSET+1}" ]; then echo "VALID"; else echo "INVALID";fi
# INVALID

essais courts

[ "${TSET+1}"   ] && echo "VALID" || echo "INVALID"
[ "${TEMPTY+1}" ] && echo "VALID" || echo "INVALID"
[ "${TUNSET+1}" ] && echo "VALID" || echo "INVALID"

je dédie cette réponse à @mklement0 (commentaires) qui m'a mis au défi de répondre à la question avec précision.

référence http://pubs.opengroup.org/onlinepubs/9699919799/utilities/V3_chap02.html#tag_18_06_02

pour vérifier si une variable est définie avec une valeur non vide, utilisez [ -n "$x" ] , comme d'autres l'ont déjà indiqué.

la Plupart du temps, c'est une bonne idée de traiter une variable qui a une valeur vide de la même manière qu'une variable n'est pas définie. Mais vous pouvez distinguer les deux si vous avez besoin de: [ -n "${x+set}" ] ( "${x+set}" se dilate à set si x est défini et à la chaîne vide si x est désactivé).

pour vérifier si un paramètre a été passé, test $# , qui est le nombre de paramètres passés à la fonction (ou au script, lorsqu'il n'est pas dans une fonction) (Voir réponse de Paul ).

dans bash vous pouvez utiliser -v dans le [[ ]] builtin:

#! /bin/bash -u

if [[ ! -v SOMEVAR ]]; then
    SOMEVAR='hello'
fi

echo $SOMEVAR

pour ceux qui cherchent à vérifier s'ils ne sont pas désactivés ou vides dans un script avec set -u :

if [ -z "${var-}" ]; then
   echo "Must provide var environment variable. Exiting...."
   exit 1
fi

le contrôle régulier [ -z "$var" ] échouera avec var; unbound variable si set -u mais [ -z "${var-}" ] se dilate pour vider la chaîne si var est désactivé sans défaut.

Vous pouvez le faire:

function a {
        if [ ! -z "" ]; then
                echo ' is set'
        fi
}

Les réponses ci-dessus ne fonctionnent pas lorsque Bash option set -u est activé. En outre, ils ne sont pas dynamiques, par exemple, comment tester est variable avec le nom "mannequin" est 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  as 'var'.  This is not allowed directly in Bash with this
    # construct: [ ! -z "${:-}" ].  We need to use indirection with eval operator.
    # Example: ="var"
    # Expansion for eval operator: "[ ! -z ${:-} ]" -> "[ ! -z ${var:-} ]"
    # Code  execute: [ ! -z ${var:-} ]
    eval "[ ! -z ${:-} ]"
    return $?  # Pedantic.
}

Related: En Bash, comment tester si une variable est définie en "-u" mode

L'utilisation de [[ -z "$var" ]] est la façon la plus facile de savoir si une variable a été définie ou non, mais cette option -z ne distingue pas entre une variable non définie et une variable définie à une chaîne vide:

$ set=''
$ [[ -z "$set" ]] && echo "Set" || echo "Unset" 
Unset
$ [[ -z "$unset" ]] && echo "Set" || echo "Unset"
Unset

il est préférable de le vérifier en fonction du type de variable: variable env, paramètre ou variable régulière.

pour une variable env:

[[ $(env | grep "varname=" | wc -l) -eq 1 ]] && echo "Set" || echo "Unset"

Pour un paramètre (par exemple, pour vérifier l'existence de paramètre ):

[[ $# -ge 5 ]] && echo "Set" || echo "Unset"

pour une variable régulière (utilisant une fonction auxiliaire, pour le faire de manière élégante):

function declare_var {
   declare -p "" &> /dev/null
   return $?
}
declare_var "var_name" && echo "Set" || echo "Unset"

Notes:

• $# : ça dit le nombre de paramètres de position.
• declare -p : vous donne la définition de la variable passée comme paramètre. Si c' existe, renvoie 0, sinon, retourne 1 et affiche un message d'erreur.
• $? : vous donne le code d'état de la dernière commande exécutée.

dans un shell, vous pouvez utiliser l'opérateur -z qui est vrai si la longueur de la chaîne est zéro.

un simple one-liner pour définir la valeur par défaut MY_VAR si elle n'est pas définie, sinon vous pouvez éventuellement afficher le message:

[[ -z "$MY_VAR" ]] && MY_VAR="default"
[[ -z "$MY_VAR" ]] && MY_VAR="default" || echo "Variable already set."

Ma voie préférée est celle-ci:

$var=10
$if ! ${var+false};then echo "is set";else echo "NOT set";fi
is set
$unset var
$if ! ${var+false};then echo "is set";else echo "NOT set";fi
NOT set

donc fondamentalement, si une variable est définie, elle devient "une négation du résultat false "(ce qui sera true = "est défini").

et, si elle est désactivée, elle deviendra "une négation du résultat true "(comme le résultat vide évalue à true ) (ainsi se terminera comme étant false = "Non défini").

if [[ ${1:+isset} ]]
then echo "It was set and not null." >&2
else echo "It was not set or it was null." >&2
fi

if [[ ${1+isset} ]]
then echo "It was set but might be null." >&2
else echo "It was was not set." >&2
fi

j'ai trouvé un (beaucoup) meilleur code pour faire cela si vous voulez vérifier quelque chose dans $@ .

if [[  = "" ]]
then
  echo ' is blank'
else
  echo ' is filled up'
fi

pourquoi tout cela? Tout dans $@ existe dans Bash, mais par défaut c'est vide, donc test -z et test -n ne pouvaient pas vous aider.

Update: vous pouvez également compter le nombre de caractères dans un paramètre.

if [ ${#1} = 0 ]
then
  echo ' is blank'
else
  echo ' is filled up'
fi

[[ $foo ]]

ou

(( ${#foo} ))

ou

let ${#foo}

ou

declare -p foo

if [[ ${!xx[@]} ]] ; then echo xx is defined; fi

j'ai toujours l'utiliser, basée sur le fait qu'il semble facile d'être compris par quelqu'un qui voit le code pour la première fois:

if [ "$variable" = "" ]
    then
    echo "Variable X is empty"
fi

et, si vous voulez vérifier si elle n'est pas vide;

if [ ! "$variable" = "" ]
    then
    echo "Variable X is not empty"
fi

C'est ça.

c'est Ce que j'utilise tous les jours:

#
# Check if a variable is set
#   param1  name of the variable
#
function is_set()
{
    [[ -n "" ]] && test -n "$(eval "echo "${+x}"")"
}

cela fonctionne bien sous Linux et Solaris jusqu'à bash 3.0.

bash-3.00$ myvar="TEST"
bash-3.00$ is_set myvar ; echo $?
0
bash-3.00$ mavar=""
bash-3.00$ is_set myvar ; echo $?
0
bash-3.00$ unset myvar
bash-3.00$ is_set myvar ; echo $?
1

si var peut être un tableau, alors le paramètre de substitution [ -z "${var+x}" ] est incorrect. Pour être vraiment sûr dans Bash vous devez utiliser syntaxe de tableau comme [ "${#var[@]}" = 0 ] , comme montré ci-dessous.

is-var-set () {
    results="${var+x}=${var+x}\t${#var[@]}=${#var[@]}"
    if [ -z "${var+x}" ] && [ "${#var[@]}" = 0 ]; then
        echo -e ": var's unset.\t$results"
    elif [ -n "${var+x}" ] && [ "${#var[@]}" != 0 ]; then
        echo -e ": var is set. \t$results"
    else
        echo -e ": Is var set? \t$results"
    fi
    unset var # so we don't have to do it everywhere else
}

Dans presque tous les cas, ils sont d'accord. La seule situation que j'ai trouvée où la méthode de tableau est plus précise est quand la variable est un tableau non vide avec la position 0 désactivé (par exemple, dans les tests 7 et A dessous.) Ce désaccord vient de $var étant raccourci pour ${var[0]} , donc [ -z "${var+x}" ] ne vérifie pas l'ensemble du tableau.

Voici mes cas de test.

unset var;      is-var-set 1 # var unset
var='';         is-var-set 2 # var[0] set to ''
var=foo;        is-var-set 3 # var[0] set to 'foo'
var=();         is-var-set 4 # var unset (all indices)
var=(foo);      is-var-set 5 # var[0] set to 'foo'
var=([0]=foo);  is-var-set 6 # var[0] set to 'foo'
var=([1]=foo);  is-var-set 7 # var[0] unset, but var[1] set to 'foo'
declare -a var; is-var-set 8 # var empty, but declared as an array
declare -A var; is-var-set 9 # var empty, but declared as an associative array
declare -A var  # Because is-var-set() conveniently unsets it
var=([xz]=foo); is-var-set A # var[xz] set to 'foo', but var's otherwise empty
declare -a var  # Demonstrate that Bash knows about var, even when there's
declare -A var; is-var-set B # apparently no way to just _check_ its existence

Voici la sortie.

1: var's unset. ${var+x}=       ${#var[@]}=0
2: var is set.  ${var+x}=x      ${#var[@]}=1
3: var is set.  ${var+x}=x      ${#var[@]}=1
4: var's unset. ${var+x}=       ${#var[@]}=0
5: var is set.  ${var+x}=x      ${#var[@]}=1
6: var is set.  ${var+x}=x      ${#var[@]}=1
7: Is var set?  ${var+x}=       ${#var[@]}=1
8: var's unset. ${var+x}=       ${#var[@]}=0
9: var's unset. ${var+x}=       ${#var[@]}=0
A: Is var set?  ${var+x}=       ${#var[@]}=1
./foo.sh: line 26: declare: var: cannot convert indexed to associative array
B: var's unset. ${var+x}=       ${#var[@]}=0

en somme:

• ${var+x} la syntaxe d'expansion des paramètres fonctionne aussi bien que la syntaxe du tableau ${#var[@]} dans la plupart des cas, comme la vérification des paramètres aux fonctions. La seule façon que ce cas pourrait briser est si une future version de Bash ajoute un moyen de passer des tableaux à des fonctions sans convertir des contenus à des arguments individuels.
La syntaxe du tableau
• est requise pour les tableaux non vides (associatifs ou non) avec l'élément 0 unset.
• aucune syntaxe n'explique ce qui se passe si declare -a var a été utilisé sans assigner même une valeur nulle quelque part dans le tableau. Bash distingue encore le cas quelque part (comme vu dans le test B ci-dessus), donc cette réponse n'est pas infaillible. Heureusement Bash convertit les variables d'environnement exportées en chaînes lors de l'exécution d'un programme/script, de sorte que tous les problèmes avec les variables déclarées-mais-unset seront contenus dans un seul script, au moins s'il ne s'agit pas de trouver d'Autres scripts.

si vous souhaitez tester qu'une variable est liée ou non, cela fonctionne bien, même après avoir activé l'option nounset:

set -o noun set

if printenv variableName >/dev/null; then
    # variable is bound to a value
else
    # variable is unbound
fi

j'aime fonctions auxiliaires pour masquer le brut détails de bash. Dans ce cas, cela ajoute encore plus de grossièreté (cachée):

# The first ! negates the result (can't use -n to achieve this)
# the second ! expands the content of varname (can't do ${$varname})
function IsDeclared_Tricky
{
  local varname=""
  ! [ -z ${!varname+x} ]
}

parce que j'ai d'abord eu des bugs dans cette implémentation (inspiré par les réponses de Jens et Lionel), j'ai trouvé une solution différente:

# Ask for the properties of the variable - fails if not declared
function IsDeclared()
{
  declare -p  &>/dev/null
}

je trouve que c'est plus simple, plus bashy et plus facile à comprendre/rappelez-vous. Le cas d'essai montre qu'il est équivalent:

function main()
{
  declare -i xyz
  local foo
  local bar=
  local baz=''

  IsDeclared_Tricky xyz; echo "IsDeclared_Tricky xyz: $?"
  IsDeclared_Tricky foo; echo "IsDeclared_Tricky foo: $?"
  IsDeclared_Tricky bar; echo "IsDeclared_Tricky bar: $?"
  IsDeclared_Tricky baz; echo "IsDeclared_Tricky baz: $?"

  IsDeclared xyz; echo "IsDeclared xyz: $?"
  IsDeclared foo; echo "IsDeclared foo: $?"
  IsDeclared bar; echo "IsDeclared bar: $?"
  IsDeclared baz; echo "IsDeclared baz: $?"
}

main

le cas d'essai montre également que local var fait Non déclare var (sauf si suivi de"="). Pendant un certain temps j'ai pensé que j'avais déclaré des variables de cette façon, juste pour découvrir maintenant que j'ai simplement exprimé mon intention... C'est un non-op, je suppose.

Isdclared_tricky xyz: 1

Isdclared_tricky foo: 1

Isdclared_tricky bar: 0

Isdclared_tricky baz: 0

Isdéclaré xyz: 1

1

Barre marquée: 0

IsDeclared baz: 0

BONUS: cas d'utilisation

j'utilise principalement ce test pour donner (et retourner) des paramètres aux fonctions dans un un peu "élégant" et sûr (ressemblant presque à un interface...):

#auxiliary functions
function die()
{
  echo "Error: "; exit 1
}

function assertVariableDeclared()
{
  IsDeclared "" || die "variable not declared: "
}

function expectVariables()
{
  while (( $# > 0 )); do
    assertVariableDeclared ; shift
  done
}

# actual example
function exampleFunction()
{
  expectVariables inputStr outputStr
  outputStr="$inputStr world!"
}

function bonus()
{
  local inputStr='Hello'
  local outputStr= # remove this to trigger error
  exampleFunction
  echo $outputStr
}

bonus

S'il est appelé avec toutes les variables requires déclaré:

Bonjour tout le monde!

else:

erreur: variable non déclarée: outputStr

fonctions pour vérifier si la variable est déclarée /désactivée

y compris vide $array=()

Les fonctions suivantes test si le prénom existe comme variable

# The first parameter needs to be the name of the variable to be checked.
# (See example below)

var_is_declared() {
    { [[ -n ${!1+anything} ]] || declare -p  &>/dev/null;}
}

var_is_unset() {
    { [[ -z ${!1+anything} ]] && ! declare -p  &>/dev/null;} 
}

• par un premier test si la variable est (non)définie, l'appel à déclarer peut être évité, si ce n'est pas nécessaire.
• Si toutefois contient le nom d'un vide $array=() , l'appel à déclarer ferait en sorte que nous obtenions le bon résultat
• il n'y a jamais beaucoup de données passées à /dev/null car declate n'est appelé que si la variable est désactivée ou un tableau vide.

ces fonctions seraient testées comme indiqué dans les conditions suivantes:

a;       # is not declared
a=;      # is declared
a="foo"; # is declared
a=();    # is declared
a=("");  # is declared
unset a; # is not declared

a;       # is unset
a=;      # is not unset
a="foo"; # is not unset
a=();    # is not unset
a=("");  # is not unset
unset a; # is unset

.

pour plus de détails

et a test script voir ma réponse à la question "Comment puis-je vérifier si une variable existe dans bash?" .



Remarque: l'usage similaire de declare -p , comme il est également indiqué par Peregring-lk 's réponse , est vraiment une coïncidence. Sinon je l'aurait, bien sûr, crédité de!

case "" in
 "") echo "blank";;
 *) echo "set"
esac