Comment puis-je tester si une variable est vide ou ne contient que des espaces?

La syntaxe bash suivante vérifie si elle paramn'est pas vide:

 [[ !  -z  $param  ]]

Par exemple:

param=""
[[ !  -z  $param  ]] && echo "I am not zero"

Pas de sortie et c'est bien.

Mais quand paramest vide sauf pour un (ou plusieurs) espace, le cas est différent:

param=" " # one space
[[ !  -z  $param  ]] && echo "I am not zero"

"Je ne suis pas zéro" est sorti.

Comment puis-je modifier le test pour considérer les variables qui ne contiennent que des espaces, vides?

Tout d'abord, notez que le -ztest est explicitement pour:

la longueur de la chaîne est zéro

Autrement dit, une chaîne ne contenant que des espaces ne doit pas être vraie sous -z, car elle a une longueur non nulle.

Ce que vous voulez, c'est supprimer les espaces de la variable à l'aide de l' extension de paramètre de remplacement de modèle :

[[ -z "${param// }" ]]

Cela développe la paramvariable et remplace toutes les correspondances du modèle (un seul espace) par rien. Ainsi, une chaîne contenant uniquement des espaces sera développée en une chaîne vide.

La façon dont cela fonctionne est de ${var/pattern/string}remplacer le premier match le plus long de patternavec string. Quand patterncommence par /(comme ci-dessus), il remplace toutes les correspondances. Comme le remplacement est vide, nous pouvons omettre le final /et la stringvaleur:

$ {paramètre / modèle / chaîne}

Le modèle est développé pour produire un modèle comme dans l’extension de nom de fichier. Le paramètre est développé et la correspondance la plus longue du motif avec sa valeur est remplacée par une chaîne . Si motif commence par '/', toutes les correspondances de motif sont remplacées par une chaîne . Normalement, seul le premier match est remplacé. ... Si string est null, les correspondances de modèle sont supprimées et le modèle / suivant peut être omis.

Après tout cela, on finit par ${param// }supprimer tous les espaces.

_{Notez que, bien qu’elle soit présente dans ksh(où elle a son origine), zshet bashque cette syntaxe n’est pas POSIX, elle ne doit pas être utilisée dans les shscripts.}

Le moyen le plus simple de vérifier qu’une chaîne ne contient que des caractères d’un ensemble autorisé consiste à vérifier la présence de caractères non autorisés. Ainsi, au lieu de vérifier si la chaîne contient uniquement des espaces, vérifiez si la chaîne contient un caractère autre que l'espace. En bash, ksh ou zsh:

if [[ $param = *[!\ ]* ]]; then
  echo "\$param contains characters other than space"
else
  echo "\$param consists of spaces only"
fi

«Ne contient que des espaces» inclut le cas d'une variable vide (ou non définie).

Vous voudrez peut-être tester n'importe quel caractère d'espacement. Utilisez-le [[ $param = *[^[:space:]]* ]]pour utiliser les paramètres régionaux ou la liste explicite de caractères d'espaces que vous souhaitez tester, par exemple [[ $param = *[$' \t\n']* ]]pour tester l'espace, la tabulation ou la nouvelle ligne.

Faire correspondre une chaîne avec un motif à l' =intérieur [[ … ]]est une extension ksh (également présente dans bash et zsh). Dans n'importe quel style Bourne / POSIX, vous pouvez utiliser la caseconstruction pour faire correspondre une chaîne à un modèle. Notez que les modèles de shell standard utilisent !pour nier un jeu de caractères, plutôt que ^dans la plupart des syntaxes d'expression régulières.

case "$param" in
  *[!\ ]*) echo "\$param contains characters other than space";;
  *) echo "\$param consists of spaces only";;
esac

Pour tester les caractères d'espacement, la $'…'syntaxe est spécifique à ksh / bash / zsh; vous pouvez insérer ces caractères dans votre script de manière littérale (notez qu'un retour à la ligne doit être placé entre guillemets, car la barre oblique inverse + le trait nouveau est réduit à néant), ou les générer, par exemple

whitespace=$(printf '\n\t ')
case "$param" in
  *[!$whitespace]*) echo "\$param contains non-whitespace characters";;
  *) echo "\$param consists of whitespace only";;
esac

POSIXly:

case $var in
  (*[![:blank:]]*) echo '$var contains non blank';;
  (*) echo '$var contains only blanks or is empty or unset'
esac

Pour différencier les espaces vides , non vides , vides et non définis :

case ${var+x$var} in
  (x) echo empty;;
  ("") echo unset;;
  (x*[![:blank:]]*) echo non-blank;;
  (*) echo blank
esac

[:blank:]est pour les caractères d'espacement horizontal (espace et tabulation en ASCII, mais il y en a probablement quelques autres dans vos paramètres régionaux; certains systèmes incluent l'espace insécable (le cas échéant), d'autres non). Si vous souhaitez également utiliser des caractères d'espacement vertical (comme une nouvelle ligne ou un saut de formulaire), remplacez-le [:blank:]par [:space:].

La seule raison qui reste pour écrire un script shell plutôt qu'un script dans un bon langage de script est si la portabilité extrême est une préoccupation primordiale. L'héritage /bin/shest la seule chose dont vous pouvez être certain, mais Perl, par exemple, est plus susceptible d'être disponible sur plusieurs plates-formes que Bash. Par conséquent, n'écrivez jamais de scripts shell utilisant des fonctionnalités qui ne sont pas vraiment universelles - et gardez à l'esprit que plusieurs fournisseurs Unix propriétaires ont gelé leur environnement shell avant POSIX.1-2001 .

Il existe un moyen portable de faire ce test, mais vous devez utiliser tr:

[ "x`printf '%s' "$var" | tr -d "$IFS"`" = x ]

(La valeur par défaut $IFS, commodément, est un espace, un onglet et une nouvelle ligne.)

(La fonction printfintégrée est elle-même assez portable, mais il est beaucoup plus simple de s'y fier que de déterminer quelle variante echovous avez.)

if [[ -n "${variable_name/[ ]*\n/}" ]]
then
    #execute if the the variable is not empty and contains non space characters
else
    #execute if the variable is empty or contains only spaces
fi

Pour tester si la variable est vide ou contient des espaces, vous pouvez également utiliser ce code:

${name:?variable is empty}

Pour tester si une variable est non définie, vide (a une valeur nulle) ou ne contient que des espaces:

 [ -z "${param#"${param%%[! ]*}"}" ] && echo "empty"

Explication:

• L'expansion de ${param%%[! ]*}supprime du premier non-espace à la fin.
• Cela ne laisse que les espaces principaux.
• L'extension suivante supprime les espaces de début de la variable.
• Si le résultat est vide, la variable était vide pour commencer.
• Ou, si la variable n'était pas vide, la suppression des espaces en tête la rendait vide.
• Si le résultat est vide -z, alors écho empty.

Ce qui précède est compatible POSIX et s’applique à n’importe quel descendant de Bourne.

Si vous souhaitez étendre cela aussi aux onglets, incluez un onglet explicite:

 [ -z "${param#"${param%%[!     ]*}"}" ] && echo "empty"

ou utilisez une variable avec les caractères à supprimer:

 var=$' \t'   # in ksh, bash, zsh
 [ -z "${param#"${param%%[!$var]*}"}" ] && echo "empty"

ou vous pouvez utiliser une "expression de classe de caractère" POSIX (vide signifie espace et tabulation):

 [ -z "${param#"${param%%[![:blank:]]*}"}" ] && echo "empty"

Mais cela échouera dans mksh, lksh et chic.

Essaye ça:

$ [[ -z \`echo $n\` ]] && echo zero

zero