He visto a los scripts de Bash probar una cadena de longitud distinta de cero de dos maneras diferentes. La mayoría de los scripts usan la -nopción:

#!/bin/bash
# With the -n option
if [ -n "$var" ]; then
  # Do something when var is non-zero length
fi

Pero la opción -n no es realmente necesaria:

# Without the -n option
if [ "$var" ]; then
  # Do something when var is non-zero length
fi

Cual es la mejor manera?

Del mismo modo, cuál es la mejor manera de probar la longitud cero:

if [ -z "$var" ]; then
  # Do something when var is zero-length
fi

o

if [ ! "$var" ]; then
  # Do something when var is zero-length
fi

Editar: Esta es una versión más completa que muestra más diferencias entre [(aka test) y [[.

La siguiente tabla muestra que si una variable se cita o no, si usa corchetes simples o dobles y si la variable contiene solo un espacio son las cosas que afectan si el uso de una prueba con o sin -n/-zes adecuado para verificar una variable.

     | 1a    2a    3a    4a    5a    6a   | 1b    2b    3b    4b    5b    6b
     | [     ["    [-n   [-n"  [-z   [-z" | [[    [["   [[-n  [[-n" [[-z  [[-z"
-----+------------------------------------+------------------------------------
unset| false false true  false true  true | false false false false true  true
null | false false true  false true  true | false false false false true  true
space| false true  true  true  true  false| true  true  true  true  false false
zero | true  true  true  true  false false| true  true  true  true  false false
digit| true  true  true  true  false false| true  true  true  true  false false
char | true  true  true  true  false false| true  true  true  true  false false
hyphn| true  true  true  true  false false| true  true  true  true  false false
two  | -err- true  -err- true  -err- false| true  true  true  true  false false
part | -err- true  -err- true  -err- false| true  true  true  true  false false
Tstr | true  true  -err- true  -err- false| true  true  true  true  false false
Fsym | false true  -err- true  -err- false| true  true  true  true  false false
T=   | true  true  -err- true  -err- false| true  true  true  true  false false
F=   | false true  -err- true  -err- false| true  true  true  true  false false
T!=  | true  true  -err- true  -err- false| true  true  true  true  false false
F!=  | false true  -err- true  -err- false| true  true  true  true  false false
Teq  | true  true  -err- true  -err- false| true  true  true  true  false false
Feq  | false true  -err- true  -err- false| true  true  true  true  false false
Tne  | true  true  -err- true  -err- false| true  true  true  true  false false
Fne  | false true  -err- true  -err- false| true  true  true  true  false false

Si desea saber si una variable tiene una longitud distinta de cero, realice una de las siguientes acciones:

• cita la variable entre corchetes (columna 2a)
• usa -ny cita la variable entre corchetes (columna 4a)
• use corchetes dobles con o sin comillas y con o sin -n(columnas 1b - 4b)

Observe en la columna 1a que comienza en la fila etiquetada "dos" que el resultado indica que [está evaluando el contenido de la variable como si fueran parte de la expresión condicional (el resultado coincide con la aserción implícita en la "T" o "F" en la columna de descripción). Cuando [[se usa (columna 1b), el contenido variable se ve como una cadena y no se evalúa.

Los errores en las columnas 3a y 5a son causados ​​por el hecho de que el valor de la variable incluye un espacio y la variable no está entre comillas. Nuevamente, como se muestra en las columnas 3b y 5b, [[evalúa el contenido de la variable como una cadena.

En consecuencia, para las pruebas de cadenas de longitud cero, las columnas 6a, 5b y 6b muestran las formas correctas de hacerlo. También tenga en cuenta que cualquiera de estas pruebas se puede negar si la negación muestra una intención más clara que el uso de la operación opuesta. Por ejemplo: if ! [[ -n $var ]].

Si está utilizando [, la clave para asegurarse de que no obtenga resultados inesperados es citar la variable. Usando [[, no importa.

Los mensajes de error, que se están suprimiendo, son "operador unario esperado" u "operador binario esperado".

Este es el script que produjo la tabla anterior.

#!/bin/bash
# by Dennis Williamson
# 2010-10-06, revised 2010-11-10
# for http://stackoverflow.com/q/3869072
# designed to fit an 80 character terminal

dw=5    # description column width
w=6     # table column width

t () { printf '%-*s' "$w" " true"; }
f () { [[ $? == 1 ]] && printf '%-*s' "$w" " false" || printf '%-*s' "$w" " -err-"; }

o=/dev/null

echo '     | 1a    2a    3a    4a    5a    6a   | 1b    2b    3b    4b    5b    6b'
echo '     | [     ["    [-n   [-n"  [-z   [-z" | [[    [["   [[-n  [[-n" [[-z  [[-z"'
echo '-----+------------------------------------+------------------------------------'

while read -r d t
do
    printf '%-*s|' "$dw" "$d"

    case $d in
        unset) unset t  ;;
        space) t=' '    ;;
    esac

    [ $t ]        2>$o  && t || f
    [ "$t" ]            && t || f
    [ -n $t ]     2>$o  && t || f
    [ -n "$t" ]         && t || f
    [ -z $t ]     2>$o  && t || f
    [ -z "$t" ]         && t || f
    echo -n "|"
    [[ $t ]]            && t || f
    [[ "$t" ]]          && t || f
    [[ -n $t ]]         && t || f
    [[ -n "$t" ]]       && t || f
    [[ -z $t ]]         && t || f
    [[ -z "$t" ]]       && t || f
    echo

done <<'EOF'
unset
null
space
zero    0
digit   1
char    c
hyphn   -z
two     a b
part    a -a
Tstr    -n a
Fsym    -h .
T=      1 = 1
F=      1 = 2
T!=     1 != 2
F!=     1 != 1
Teq     1 -eq 1
Feq     1 -eq 2
Tne     1 -ne 2
Fne     1 -ne 1
EOF

Es mejor usar el más poderoso [[ en lo que respecta a Bash.

Casos habituales

if [[ $var ]]; then   # var is set and it is not empty
if [[ ! $var ]]; then # var is not set or it is set to an empty string

Las dos construcciones anteriores se ven limpias y legibles. Deberían ser suficientes en la mayoría de los casos.

Tenga en cuenta que no necesitamos citar las expansiones variables en el interior, [[ya que no hay peligro de división de palabras y pegadura .

Para evitar las quejas de Shellcheck sobre [[ $var ]]y [[ ! $var ]], podríamos usar la -nopción.

Casos raros

En el raro caso de que tengamos que hacer una distinción entre "estar configurado en una cadena vacía" frente a "no estar configurado en absoluto", podríamos usar estos:

if [[ ${var+x} ]]; then           # var is set but it could be empty
if [[ ! ${var+x} ]]; then         # var is not set
if [[ ${var+x} && ! $var ]]; then # var is set and is empty

También podemos usar la -vprueba:

if [[ -v var ]]; then             # var is set but it could be empty
if [[ ! -v var ]]; then           # var is not set
if [[ -v var && ! $var ]]; then   # var is set and is empty
if [[ -v var && -z $var ]]; then  # var is set and is empty

Publicaciones relacionadas y documentación

Hay muchas publicaciones relacionadas con este tema. Aquí hay algunos:

• ¿Cómo verificar si una variable está configurada en Bash?
• ¿Cómo verificar si existe una variable de entorno y obtener su valor?
• Cómo encontrar si una variable está vacía o no en Bash
• ¿Qué significa "más dos puntos" ("+:") en las expresiones de script de shell?
• ¿Es preferible el uso de corchetes dobles [[]] sobre corchetes individuales [] en Bash?
• ¿Cuál es la diferencia entre corchetes simples y dobles en Bash?
• Una excelente respuesta de mklement0 donde habla de [[vs[
• Bash Hackers Wiki - [vs[[

Aquí hay algunas pruebas más

Verdadero si la cadena no está vacía:

[ -n "$var" ]
[[ -n $var ]]
test -n "$var"
[ "$var" ]
[[ $var ]]
(( ${#var} ))
let ${#var}
test "$var"

Verdadero si la cadena está vacía:

[ -z "$var" ]
[[ -z $var ]]
test -z "$var"
! [ "$var" ]
! [[ $var ]]
! (( ${#var} ))
! let ${#var}
! test "$var"

La respuesta correcta es la siguiente:

if [[ -n $var ]] ; then
  blah
fi

Tenga en cuenta el uso de [[...]], que maneja correctamente la cita de las variables por usted.

Una forma alternativa y quizás más transparente de evaluar una variable de entorno vacía es usar ...

  if [ "x$ENV_VARIABLE" != "x" ] ; then
      echo 'ENV_VARIABLE contains something'
  fi

Use case/esacpara probar:

case "$var" in
  "") echo "zero length";;
esac