¿Cómo puedo probar si una variable está vacía o contiene solo espacios?

La siguiente sintaxis bash verifica si paramno está vacía:

 [[ !  -z  $param  ]]

Por ejemplo:

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

No hay salida y está bien.

Pero cuando paramestá vacío excepto por uno (o más) caracteres de espacio, entonces el caso es diferente:

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

Se emite "No soy cero".

¿Cómo puedo cambiar la prueba para considerar variables que contienen solo caracteres de espacio como vacías?

Primero, tenga en cuenta que la -zprueba es explícitamente para:

la longitud de la cuerda es cero

Es decir, una cadena que contiene solo espacios no debería ser verdadera debajo -z, porque tiene una longitud distinta de cero.

Lo que desea es eliminar los espacios de la variable utilizando la expansión del parámetro de reemplazo de patrón :

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

Esto expande la paramvariable y reemplaza todas las coincidencias del patrón (un solo espacio) con nada, por lo que una cadena que solo tiene espacios se expandirá a una cadena vacía.

Lo esencial de cómo funciona eso es que ${var/pattern/string}reemplaza la primera combinación más larga de patterncon string. Cuando patterncomienza con /(como arriba), reemplaza todos los partidos. Como el reemplazo está vacío, podemos omitir el final /y el stringvalor:

$ {parámetro / patrón / cadena}

El patrón se expande para producir un patrón al igual que en la expansión de nombre de archivo. El parámetro se expande y la coincidencia más larga del patrón contra su valor se reemplaza con una cadena . Si el patrón comienza con '/', todas las coincidencias del patrón se reemplazan con una cadena . Normalmente solo se reemplaza el primer partido. ... Si la cadena es nula, se eliminan las coincidencias de patrón y se puede omitir el / patrón siguiente .

Después de todo eso, terminamos con ${param// }eliminar todos los espacios.

_{Tenga en cuenta que aunque está presente en ksh(donde se originó), zshy bash, esa sintaxis no es POSIX y no debe usarse en shscripts.}

La manera fácil de verificar que una cadena solo contenga caracteres en un conjunto autorizado es probar la presencia de caracteres no autorizados. Por lo tanto, en lugar de probar si la cadena solo contiene espacios, pruebe si la cadena contiene algún carácter que no sea espacio. En bash, ksh o zsh:

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

“Consiste solo en espacios” incluye el caso de una variable vacía (o no establecida).

Es posible que desee probar cualquier carácter de espacio en blanco. Utilícelo [[ $param = *[^[:space:]]* ]]para usar la configuración regional o cualquier lista explícita de caracteres de espacios en blanco que desee probar, por ejemplo, [[ $param = *[$' \t\n']* ]]para probar el espacio, la pestaña o la nueva línea.

Hacer coincidir una cadena con un patrón con el =interior [[ … ]]es una extensión ksh (también presente en bash y zsh). En cualquier estilo Bourne / POSIX, puede usar la caseconstrucción para hacer coincidir una cadena con un patrón. Tenga en cuenta que los patrones de shell estándar se utilizan !para negar un conjunto de caracteres, en lugar de ^como en la mayoría de las sintaxis de expresiones regulares.

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

Para probar los caracteres de espacios en blanco, la $'…'sintaxis es específica de ksh / bash / zsh; puede insertar estos caracteres en su script literalmente (tenga en cuenta que una nueva línea tendrá que estar entre comillas, ya que la barra invertida + nueva línea se expande a nada), o generarlos, por ejemplo

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

POSIXY:

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

Para diferenciar entre en blanco , no esté en blanco , vacío , unset :

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

[:blank:]es para los caracteres de espaciado horizontal (espacio y tabulación en ASCII, pero probablemente haya algunos más en su ubicación; algunos sistemas incluirán el espacio que no se rompe (donde esté disponible), otros no). Si también desea caracteres de espaciado vertical (como nueva línea o avance de formulario), reemplácelos [:blank:]por [:space:].

La única razón restante para escribir un script de shell, en lugar de un script en un buen lenguaje de script, es si la portabilidad extrema es una preocupación primordial. El legado /bin/shes lo único que puede estar seguro de que tiene, pero Perl, por ejemplo, es más probable que esté disponible multiplataforma que Bash. Por lo tanto, nunca escriba scripts de shell que utilicen funciones que no sean realmente universales , y tenga en cuenta que varios proveedores de Unix propietarios congelaron su entorno de shell antes de POSIX.1-2001 .

Hay una forma portátil de hacer esta prueba, pero debe usar tr:

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

(El valor predeterminado de $IFS, convenientemente, es un espacio, una pestaña y una nueva línea).

(La printfconstrucción en sí es muy portátil, pero confiar en ella es mucho menos molesta que descubrir qué variante echotiene).

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

Para probar si la variable está vacía o contiene espacios, también puede usar este código:

${name:?variable is empty}

Para probar si una variable no está definida, está vacía (tiene un valor nulo) o contiene solo espacios:

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

Explicación:

• La expansión de ${param%%[! ]*}elimina desde el primer no espacio hasta el final.
• Eso deja solo los espacios principales.
• La próxima expansión elimina los espacios iniciales de la variable.
• Si el resultado está vacío, entonces la variable estaba vacía para empezar.
• O, si la variable no estaba vacía, la eliminación de los espacios iniciales la hacía vacía.
• Si el resultado está vacío -z, entonces echo empty.

Lo anterior es compatible con POSIX y se ejecuta en cualquier descendiente Bourne.

Si desea extender eso a las pestañas también, incluya una pestaña explícita:

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

o use una variable con los caracteres que necesita eliminar:

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

o puede usar alguna "expresión de clase de caracteres" POSIX (en blanco significa espacio y tabulación):

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

Pero eso fallará en mksh, lksh y posh.

Prueba esto:

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

zero