¿Cómo puedo probar si un comando genera una cadena vacía?

_{Anteriormente, la pregunta preguntaba cómo verificar si hay archivos en un directorio. El siguiente código logra eso, pero vea la respuesta de rsp para una mejor solución.}

Salida vacía

Los comandos no devuelven valores, los generan. Puede capturar esta salida utilizando la sustitución de comandos ; por ej $(ls -A). Puede probar una cadena no vacía en Bash como esta:

if [[ $(ls -A) ]]; then
    echo "there are files"
else
    echo "no files found"
fi

Tenga en cuenta que he usado en -Alugar de -a, ya que omite las entradas simbólicas de directorio actual ( .) y padre ( ..).

Nota: Como se señaló en los comentarios, la sustitución de comandos no captura las nuevas líneas finales . Por lo tanto, si el comando genera solo nuevas líneas, la sustitución no capturará nada y la prueba devolverá falso. Si bien es poco probable, esto es posible en el ejemplo anterior, ya que una nueva línea es un nombre de archivo válido. Más información en esta respuesta .

Código de salida

Si desea comprobar que el comando se completó correctamente, puede inspeccionar $?, que contiene el código de salida del último comando (cero para el éxito, no cero para el fracaso). Por ejemplo:

files=$(ls -A)
if [[ $? != 0 ]]; then
    echo "Command failed."
elif [[ $files ]]; then
    echo "Files found."
else
    echo "No files found."
fi

Más información aquí .

TL; DR

if [[ $(ls -A | head -c1 | wc -c) -ne 0 ]]; then ...; fi

Gracias a netj por una sugerencia para mejorar mi original:
if [[ $(ls -A | wc -c) -ne 0 ]]; then ...; fi

Esta es una vieja pregunta, pero veo al menos dos cosas que necesitan alguna mejora o al menos alguna aclaración.

Primer problema

El primer problema que veo es que la mayoría de los ejemplos proporcionados aquí simplemente no funcionan . Utilizan los comandos ls -aly ls -Al, que generan cadenas no vacías en directorios vacíos. Esos ejemplos siempre informan que hay archivos, incluso cuando no hay ninguno .

Por esa razón, debe usar solo ls -A: ¿por qué alguien querría usar el -linterruptor que significa "usar un formato de listado largo" cuando todo lo que quiere es probar si hay alguna salida o no?

Entonces, la mayoría de las respuestas aquí son simplemente incorrectas.

Segundo problema

El segundo problema es que, si bien algunas respuestas funcionan bien (los que no utilizan ls -alo ls -Al, pero ls -Aen su lugar) todos hacen algo como esto:

1. ejecuta un comando
2. amortigua toda su salida en RAM
3. convertir la salida en una gran cadena de una sola línea
4. compara esa cadena con una cadena vacía

Lo que sugeriría hacer en su lugar sería:

1. ejecuta un comando
2. cuente los caracteres en su salida sin almacenarlos
   • o incluso mejor: cuente el número máximo de 1 carácter using head -c1
     (gracias a netj por publicar esta idea en los comentarios a continuación)
3. compara ese número con cero

Entonces, por ejemplo, en lugar de:

if [[ $(ls -A) ]]

Yo usaría:

if [[ $(ls -A | wc -c) -ne 0 ]]
# or:
if [[ $(ls -A | head -c1 | wc -c) -ne 0 ]]

En vez de:

if [ -z "$(ls -lA)" ]

Yo usaría:

if [ $(ls -lA | wc -c) -eq 0 ]
# or:
if [ $(ls -lA | head -c1 | wc -c) -eq 0 ]

y así.

Para salidas pequeñas puede que no sea un problema, pero para salidas más grandes la diferencia puede ser significativa:

$ time [ -z "$(seq 1 10000000)" ]

real    0m2.703s
user    0m2.485s
sys 0m0.347s

Compáralo con:

$ time [ $(seq 1 10000000 | wc -c) -eq 0 ]

real    0m0.128s
user    0m0.081s
sys 0m0.105s

Y aún mejor:

$ time [ $(seq 1 10000000 | head -c1 | wc -c) -eq 0 ]

real    0m0.004s
user    0m0.000s
sys 0m0.007s

Ejemplo completo

Ejemplo actualizado de la respuesta de Will Vousden:

if [[ $(ls -A | wc -c) -ne 0 ]]; then
    echo "there are files"
else
    echo "no files found"
fi

Actualizado nuevamente después de las sugerencias de netj :

if [[ $(ls -A | head -c1 | wc -c) -ne 0 ]]; then
    echo "there are files"
else
    echo "no files found"
fi

Actualización adicional de jakeonfire :

grepsaldrá con una falla si no hay coincidencia. Podemos aprovechar esto para simplificar ligeramente la sintaxis:

if ls -A | head -c1 | grep -E '.'; then
    echo "there are files"
fi

if ! ls -A | head -c1 | grep -E '.'; then
    echo "no files found"
fi

Descartando espacios en blanco

Si el comando que está probando podría generar algún espacio en blanco que desea tratar como una cadena vacía, entonces en lugar de:

| wc -c

podrías usar:

| tr -d ' \n\r\t ' | wc -c

o con head -c1:

| tr -d ' \n\r\t ' | head -c1 | wc -c

o algo así.

Resumen

1. Primero, use un comando que funcione .

2. En segundo lugar, evite el almacenamiento innecesario en RAM y el procesamiento de datos potencialmente enormes.

La respuesta no especificó que la salida siempre es pequeña, por lo que también debe considerarse una posibilidad de salida grande.

if [ -z "$(ls -lA)" ]; then
  echo "no files found"
else
  echo "There are files"
fi

Esto ejecutará el comando y verificará si la salida (cadena) devuelta tiene una longitud cero. Es posible que desee consultar las páginas del manual de 'prueba' para otros indicadores.

Utilice el "" alrededor del argumento que se está comprobando, de lo contrario, los resultados vacíos generarán un error de sintaxis ya que no hay un segundo argumento (para verificar).

Nota: eso ls -lasiempre regresa .y, ..por lo tanto, usar eso no funcionará, consulte las páginas del manual de ls . Además, si bien esto puede parecer conveniente y fácil, supongo que se romperá fácilmente. ¡Escribir un pequeño script / aplicación que devuelve 0 o 1 dependiendo del resultado es mucho más confiable!

Para aquellos que desean una solución elegante, independiente de la versión bash (de hecho, debería funcionar en otros proyectiles modernos) y para aquellos que adoran usar frases ingeniosas para tareas rápidas. ¡Aquí vamos!

ls | grep . && echo 'files found' || echo 'files not found'

(tenga en cuenta como uno de los comentarios mencionados, ls -aly de hecho, solo -ly -atodos devolverán algo, por lo que en mi respuesta utilizo simplels

Manual de referencia de Bash

6.4 Expresiones condicionales bash

-z string
     True if the length of string is zero.

-n string
string
     True if the length of string is non-zero.

Puedes usar la versión abreviada:

if [[ $(ls -A) ]]; then
  echo "there are files"
else
  echo "no files found"
fi

Como comentó Jon Lin, ls -alsiempre saldrá (para .y ..). Desea ls -Alevitar estos dos directorios.

Podría, por ejemplo, poner la salida del comando en una variable de shell:

v=$(ls -Al)

Una notación más antigua, no anidable, es

v=`ls -Al`

pero prefiero la notación anidable $(...)

Puedes probar si esa variable no está vacía

if [ -n "$v" ]; then
    echo there are files
else
    echo no files
fi

Y podrías combinar ambos como if [ -n "$(ls -Al)" ]; then

Supongo que quieres la salida del ls -alcomando, así que en bash, tendrías algo como:

LS=`ls -la`

if [ -n "$LS" ]; then
  echo "there are files"
else
  echo "no files found"
fi

Aquí hay una solución para casos más extremos:

if [ `command | head -c1 | wc -c` -gt 0 ]; then ...; fi

Esto funcionará

• para todos los proyectiles Bourne;
• si la salida del comando es todos ceros;
• eficientemente independientemente del tamaño de salida;

sin embargo,

• el comando o sus subprocesos se eliminarán una vez que se envíe algo.

Todas las respuestas dadas hasta ahora tratan con comandos que terminan y generan una cadena no vacía.

La mayoría están rotos en los siguientes sentidos:

• No manejan adecuadamente los comandos que generan solo nuevas líneas;
• a partir de Bash≥4.4 la mayoría enviará un error estándar de spam si el comando genera bytes nulos (ya que usan la sustitución de comandos);
• la mayoría sorberá la secuencia de salida completa, por lo que esperará hasta que el comando termine antes de responder. Algunos comandos nunca terminan (prueba, por ejemplo, yes).

Entonces, para solucionar todos estos problemas y responder la siguiente pregunta de manera eficiente,

¿Cómo puedo probar si un comando genera una cadena vacía?

puedes usar:

if read -n1 -d '' < <(command_here); then
    echo "Command outputs something"
else
    echo "Command doesn't output anything"
fi

También puede agregar un tiempo de espera para probar si un comando genera una cadena no vacía dentro de un tiempo determinado, utilizando readla -topción 's . Por ejemplo, por un tiempo de espera de 2.5 segundos:

if read -t2.5 -n1 -d '' < <(command_here); then
    echo "Command outputs something"
else
    echo "Command doesn't output anything"
fi

Observación. Si cree que necesita determinar si un comando genera una cadena no vacía, es muy probable que tenga un problema XY.

Aquí hay un enfoque alternativo que escribe el std-out y std-err de algún comando en un archivo temporal, y luego verifica si ese archivo está vacío. Una ventaja de este enfoque es que captura ambas salidas y no utiliza subcapas ni tuberías. Estos últimos aspectos son importantes porque pueden interferir con la captura del manejo de salida de bash (por ejemplo, aquí )

tmpfile=$(mktemp)
some-command  &> "$tmpfile"
if [[ $? != 0 ]]; then
    echo "Command failed"
elif [[ -s "$tmpfile" ]]; then
    echo "Command generated output"
else
    echo "Command has no output"
fi
rm -f "$tmpfile"

A veces desea guardar la salida, si no está vacía, para pasarla a otro comando. Si es así, podrías usar algo como

list=`grep -l "MY_DESIRED_STRING" *.log `
if [ $? -eq 0 ]
then
    /bin/rm $list
fi

De esta manera, el rmcomando no se bloqueará si la lista está vacía.