Desde un script de shell, ¿cómo verifico si un directorio contiene archivos?

Algo parecido a esto

if [ -e /some/dir/* ]; then echo "huzzah"; fi;

pero que funciona si el directorio contiene uno o varios archivos (el anterior solo funciona con exactamente 0 o 1 archivos).

Las soluciones hasta ahora utilizan ls. Aquí hay una solución de bash:

#!/bin/bash
shopt -s nullglob dotglob     # To include hidden files
files=(/some/dir/*)
if [ ${#files[@]} -gt 0 ]; then echo "huzzah"; fi

Tres mejores trucos

shopt -s nullglob dotglob; f=your/dir/*; ((${#f}))

Este truco es 100% bashe invoca (genera) un sub-shell. La idea es de Bruno De Fraine y mejorada por el comentario de teambob .

files=$(shopt -s nullglob dotglob; echo your/dir/*)
if (( ${#files} ))
then
  echo "contains files"
else 
  echo "empty (or does not exist or is a file)"
fi

Nota: no hay diferencia entre un directorio vacío y uno que no existe (e incluso cuando la ruta proporcionada es un archivo).

Hay una alternativa similar y más detalles (y más ejemplos) en las preguntas frecuentes 'oficiales' para el canal de IRC #bash :

if (shopt -s nullglob dotglob; f=(*); ((${#f[@]})))
then
  echo "contains files"
else 
  echo "empty (or does not exist, or is a file)"
fi

[ -n "$(ls -A your/dir)" ]

Este truco está inspirado en el artículo de nixCraft publicado en 2007. Agregar 2>/dev/nullpara suprimir el error de salida "No such file or directory".
^{Véase también la respuesta de Andrew Taylor (2008) y la respuesta de gr8can8dian (2011).}

if [ -n "$(ls -A your/dir 2>/dev/null)" ]
then
  echo "contains files (or is a file)"
else
  echo "empty (or does not exist)"
fi

o la versión bashism de una línea:

[[ $(ls -A your/dir) ]] && echo "contains files" || echo "empty"

Nota: ls regresa $?=2cuando el directorio no existe. Pero no hay diferencia entre un archivo y un directorio vacío.

[ -n "$(find your/dir -prune -empty)" ]

Este último truco está inspirado en la respuesta de gravstar donde -maxdepth 0se reemplaza por -pruney mejorado por phils comentario 's.

if [ -n "$(find your/dir -prune -empty 2>/dev/null)" ]
then
  echo "empty (directory or file)"
else
  echo "contains files (or does not exist)"
fi

una variación usando -type d:

if [ -n "$(find your/dir -prune -empty -type d 2>/dev/null)" ]
then
  echo "empty directory"
else
  echo "contains files (or does not exist or is not a directory)"
fi

Explicación:

• find -prunees similar a find -maxdepth 0usar menos caracteres
• find -empty imprime los directorios y archivos vacíos
• find -type d imprime directorios solamente

Nota: También puede reemplazar [ -n "$(find your/dir -prune -empty)" ]solo por la versión abreviada a continuación:

if [ `find your/dir -prune -empty 2>/dev/null` ]
then
  echo "empty (directory or file)"
else
  echo "contains files (or does not exist)"
fi

Este último código funciona en la mayoría de los casos, pero tenga en cuenta que las rutas maliciosas pueden expresar un comando ...

¿Qué tal lo siguiente?

if find /some/dir/ -maxdepth 0 -empty | read v; then echo "Empty dir"; fi

De esta forma no es necesario generar una lista completa del contenido del directorio. El reades tanto descartar la salida como hacer que la expresión se evalúe como verdadera solo cuando se lee algo ( /some/dir/es decir, se encuentra vacío por find).

Tratar:

if [ ! -z `ls /some/dir/*` ]; then echo "huzzah"; fi

# Works on hidden files, directories and regular files
### isEmpty()
# This function takes one parameter:
# $1 is the directory to check
# Echoes "huzzah" if the directory has files
function isEmpty(){
  if [ "$(ls -A $1)" ]; then
    echo "huzzah"
  else 
    echo "has no files"
  fi
}

¡Tenga cuidado con los directorios con muchos archivos! Podría llevar algún tiempo evaluar el lscomando.

En mi opinión, la mejor solución es la que utiliza

find /some/dir/ -maxdepth 0 -empty

DIR="/some/dir"
if [ "$(ls -A $DIR)" ]; then
     echo 'There is something alive in here'
fi

¿Podrías comparar el resultado de esto?

 ls -A /some/dir | wc -l

# Comprueba si un directorio contiene archivos no ocultos.
#
# uso: si está vacío "$ HOME"; luego repita "Bienvenido a casa"; fi
#
esta vacio() {
    por _ief en $ 1 / *; hacer
        si [-e "$ _ief"]; luego
            volver 1
        fi
    hecho
    volver 0
}

Algunas notas de implementación:

• El forbucle evita una llamada a un lsproceso externo . Todavía lee todas las entradas del directorio una vez. Esto solo se puede optimizar escribiendo un programa en C que use readdir () explícitamente.
• El test -einterior del bucle captura el caso de un directorio vacío, en cuyo caso a la variable _iefse le asignaría el valor "somedir / *". Solo si ese archivo existe, la función devolverá "no vacío"
• Esta función funcionará en todas las implementaciones POSIX. Pero tenga en cuenta que Solaris / bin / sh no entra en esa categoría. Su testimplementación no es compatible con la -ebandera.

Esto me dice si el directorio está vacío o si no lo está, la cantidad de archivos que contiene.

directory="/some/dir"
number_of_files=$(ls -A $directory | wc -l)

if [ "$number_of_files" == "0" ]; then
    echo "directory $directory is empty"
else
    echo "directory $directory contains $number_of_files files"
fi

Esta puede ser una respuesta muy tardía, pero aquí hay una solución que funciona. ¡Esta línea solo reconoce la existencia de archivos! No le dará un falso positivo si existen directorios.

if find /path/to/check/* -maxdepth 0 -type f | read
  then echo "Files Exist"
fi

dir_is_empty() {
   [ "${1##*/}" = "*" ]
}

if dir_is_empty /some/dir/* ; then
   echo "huzzah"
fi

Suponga que usted no tiene un archivo llamado *en /any/dir/you/check, que debería funcionar en bash dash posh busybox shy zshpero (por zsh) requieren unsetopt nomatch.

Los rendimientos deben ser comparables a cualquiera lsque use *(glob), supongo que será lento en directorios con muchos nodos (mi /usr/bincon más de 3000 archivos no fue tan lento), usará al menos la memoria suficiente para asignar todos los directorios / nombres de archivo (y más) como todos se pasan (resuelven) a la función como argumentos, algunos shell probablemente tienen límites en el número de argumentos y / o la longitud de los argumentos.

Sería bueno tener una forma portátil rápida de O (1) cero recursos para verificar si un directorio está vacío.

actualizar

La versión anterior no tiene en cuenta los archivos / directorios ocultos, en caso de que se requieran más pruebas, como los trucos sh (shell POSIX)is_empty de Rich :

is_empty () (
cd "$1"
set -- .[!.]* ; test -f "$1" && return 1
set -- ..?* ; test -f "$1" && return 1
set -- * ; test -f "$1" && return 1
return 0 )

Pero, en cambio, estoy pensando en algo como esto:

dir_is_empty() {
    [ "$(find "$1" -name "?*" | dd bs=$((${#1}+3)) count=1 2>/dev/null)" = "$1" ]
}

Alguna preocupación acerca de las diferencias de barras al final del argumento y la salida de búsqueda cuando el directorio está vacío, y las líneas nuevas al final (pero esto debería ser fácil de manejar), lamentablemente en mi busybox shprograma lo que probablemente sea un error en la find -> ddtubería con la salida truncada aleatoriamente ( si utilicé catla salida es siempre la misma, parece estar ddcon el argumento count).

ZSH

Sé que la pregunta estaba marcada para bash; pero, solo como referencia, para usuarios de zsh :

Prueba de directorio no vacío

Para comprobar si foono está vacío:

$ for i in foo(NF) ; do ... ; done

donde, si foono está vacío, forse ejecutará el código del bloque.

Prueba de directorio vacío

Para comprobar si fooestá vacío:

$ for i in foo(N/^F) ; do ... ; done

donde, si fooestá vacío, forse ejecutará el código del bloque.

Notas

No necesitamos citar el directorio fooanterior, pero podemos hacerlo si es necesario:

$ for i in 'some directory!'(NF) ; do ... ; done

También podemos probar más de un objeto, incluso si no es un directorio:

$ mkdir X     # empty directory
$ touch f     # regular file
$ for i in X(N/^F) f(N/^F) ; do echo $i ; done  # echo empty directories
X

Todo lo que no sea un directorio simplemente se ignorará.

Extras

Como estamos haciendo globbing, podemos usar cualquier glob (o expansión de llaves):

$ mkdir X X1 X2 Y Y1 Y2 Z
$ touch Xf                    # create regular file
$ touch X1/f                  # directory X1 is not empty
$ touch Y1/.f                 # directory Y1 is not empty
$ ls -F                       # list all objects
X/ X1/ X2/ Xf Y/ Y1/ Y2/ Z/
$ for i in {X,Y}*(N/^F); do printf "$i "; done; echo  # print empty directories
X X2 Y Y2

También podemos examinar objetos que se colocan en una matriz. Con los directorios como arriba, por ejemplo:

$ ls -F                       # list all objects
X/ X1/ X2/ Xf Y/ Y1/ Y2/ Z/
$ arr=(*)                     # place objects into array "arr"
$ for i in ${^arr}(N/^F); do printf "$i "; done; echo
X X2 Y Y2 Z

Por lo tanto, podemos probar objetos que ya pueden estar configurados en un parámetro de matriz.

Tenga en cuenta que for, obviamente, el código del bloque se ejecuta en todos los directorios. Si esto no es deseable, simplemente puede completar un parámetro de matriz y luego operar en ese parámetro:

$ for i in *(NF) ; do full_directories+=($i) ; done
$ do_something $full_directories

Explicación

Para los usuarios de zsh existe el (F)calificador glob (ver man zshexpn), que coincide con directorios "llenos" (no vacíos):

$ mkdir X Y
$ touch Y/.f        # Y is now not empty
$ touch f           # create a regular file
$ ls -dF *          # list everything in the current directory
f X/ Y/
$ ls -dF *(F)       # will list only "full" directories
Y/

El calificador (F)enumera los objetos que coinciden: es un directorio Y no está vacío. Entonces, (^F)coincide: no es un directorio O está vacío. Por lo tanto, (^F)solo también enumeraría archivos regulares, por ejemplo. Por lo tanto, como se explica en la zshexppágina del manual, también necesitamos el (/)calificador glob, que enumera solo directorios:

$ mkdir X Y Z
$ touch X/f Y/.f    # directories X and Y now not empty
$ for i in *(/^F) ; do echo $i ; done
Z

Por lo tanto, para verificar si un directorio determinado está vacío, puede ejecutar:

$ mkdir X
$ for i in X(/^F) ; do echo $i ; done ; echo "finished"
X
finished

y solo para estar seguro de que no se capturará un directorio que no esté vacío:

$ mkdir Y
$ touch Y/.f
$ for i in Y(/^F) ; do echo $i ; done ; echo "finished"
zsh: no matches found: Y(/^F)
finished

¡Ups! Dado Yque no está vacío, zsh no encuentra coincidencias para (/^F)("directorios que están vacíos") y por lo tanto escupe un mensaje de error que dice que no se encontraron coincidencias para el glob. Por lo tanto, debemos suprimir estos posibles mensajes de error con el (N)calificador glob:

$ mkdir Y
$ touch Y/.f
$ for i in Y(N/^F) ; do echo $i ; done ; echo "finished"
finished

Por lo tanto, para los directorios vacíos necesitamos el calificador (N/^F), que se puede leer como: "no me advierta sobre fallas, directorios que no están llenos".

De manera similar, para los directorios que no están vacíos necesitamos el calificador (NF), que también podemos leer como: "no me adviertan sobre fallas, directorios llenos".

Me sorprende que no se haya mencionado la guía de wooledge sobre directorios vacíos . Esta guía, y todo Wooledge realmente, es una lectura obligada para preguntas de tipo shell.

De nota de esa página:

Nunca intente analizar la salida de ls. Incluso las soluciones ls -A pueden romperse (por ejemplo, en HP-UX, si eres root, ls -A hace exactamente lo contrario de lo que hace si no eres root, y no, no puedo inventar algo tan increíble estúpido).

De hecho, es posible que desee evitar la pregunta directa por completo. Por lo general, la gente quiere saber si un directorio está vacío porque quieren hacer algo relacionado con los archivos que contiene, etc. Busque la pregunta más amplia. Por ejemplo, uno de estos ejemplos basados ​​en búsquedas puede ser una solución adecuada:

   # Bourne
   find "$somedir" -type f -exec echo Found unexpected file {} \;
   find "$somedir" -maxdepth 0 -empty -exec echo {} is empty. \;  # GNU/BSD
   find "$somedir" -type d -empty -exec cp /my/configfile {} \;   # GNU/BSD

Más comúnmente, todo lo que realmente se necesita es algo como esto:

   # Bourne
   for f in ./*.mpg; do
        test -f "$f" || continue
        mympgviewer "$f"
    done

En otras palabras, la persona que hace la pregunta puede haber pensado que se necesitaba una prueba explícita de directorio vacío para evitar un mensaje de error como mympgviewer: ./*.mpg: No existe tal archivo o directorio cuando en realidad no se requiere tal prueba.

Pequeña variación de la respuesta de Bruno :

files=$(ls -1 /some/dir| wc -l)
if [ $files -gt 0 ] 
then
    echo "Contains files"
else
    echo "Empty"
fi

Esto funciona para mi

Tomando una pista (o varias) de la respuesta de olibre, me gusta una función Bash:

function isEmptyDir {
  [ -d $1 -a -n "$( find $1 -prune -empty 2>/dev/null )" ]
}

Porque aunque crea una subcapa, es lo más parecido a una solución O (1) que puedo imaginar y darle un nombre lo hace legible. Entonces puedo escribir

if isEmptyDir somedir
then
  echo somedir is an empty directory
else
  echo somedir does not exist, is not a dir, is unreadable, or is  not empty
fi

En cuanto a O (1), hay casos atípicos: si un directorio grande ha tenido todas o todas las entradas eliminadas, excepto la última, es posible que "find" tenga que leer todo para determinar si está vacío. Creo que el rendimiento esperado es O (1) pero el peor de los casos es lineal en el tamaño del directorio. No he medido esto.

Hasta ahora no he visto una respuesta que use grep, lo que creo que daría una respuesta más simple (¡sin demasiados símbolos extraños!). Así es como comprobaría si existe algún archivo en el directorio usando bourne shell:

esto devuelve el número de archivos en un directorio:

ls -l <directory> | egrep -c "^-"

puede completar la ruta del directorio donde está escrito el directorio. La primera mitad de la tubería asegura que el primer carácter de salida sea "-" para cada archivo. egrep luego cuenta el número de líneas que comienzan con ese símbolo usando expresiones regulares. ahora todo lo que tiene que hacer es almacenar el número que obtiene y compararlo usando comillas inversas como:

 #!/bin/sh 
 fileNum=`ls -l <directory> | egrep -c "^-"`  
 if [ $fileNum == x ] 
 then  
 #do what you want to do
 fi

x es una variable de su elección.

Mezclando ciruelas y últimas respuestas, llegué a

find "$some_dir" -prune -empty -type d | read && echo empty || echo "not empty"

que funciona para caminos con espacios también

Respuesta simple con bash :

if [[ $(ls /some/dir/) ]]; then echo "huzzah"; fi;

Yo iría por find:

if [ -z "$(find $dir -maxdepth 1 -type f)" ]; then
    echo "$dir has NO files"
else
    echo "$dir has files"

Esto verifica el resultado de buscar solo archivos en el directorio, sin pasar por los subdirectorios. Luego verifica la salida usando la -zopción tomada de man test:

   -z STRING
          the length of STRING is zero

Vea algunos resultados:

$ mkdir aaa
$ dir="aaa"

Directorio vacío:

$ [ -z "$(find aaa/ -maxdepth 1 -type f)" ] && echo "empty"
empty

Solo dirs en él:

$ mkdir aaa/bbb
$ [ -z "$(find aaa/ -maxdepth 1 -type f)" ] && echo "empty"
empty

Un archivo en el directorio:

$ touch aaa/myfile
$ [ -z "$(find aaa/ -maxdepth 1 -type f)" ] && echo "empty"
$ rm aaa/myfile 

Un archivo en un subdirectorio:

$ touch aaa/bbb/another_file
$ [ -z "$(find aaa/ -maxdepth 1 -type f)" ] && echo "empty"
empty

Con alguna solución, pude encontrar una forma sencilla de averiguar si hay archivos en un directorio. Esto se puede extender con más comandos grep para verificar específicamente archivos .xml o .txt, etc. Ej:ls /some/dir | grep xml | wc -l | grep -w "0"

#!/bin/bash
if ([ $(ls /some/dir | wc -l  | grep -w "0") ])
    then
        echo 'No files'
    else
        echo 'Found files'
fi

if ls /some/dir/* >/dev/null 2>&1 ; then echo "huzzah"; fi;

para probar un directorio de destino específico

if [ -d $target_dir ]; then
    ls_contents=$(ls -1 $target_dir | xargs); 
    if [ ! -z "$ls_contents" -a "$ls_contents" != "" ]; then
        echo "is not empty";
    else
        echo "is empty";
    fi;
else
    echo "directory does not exist";
fi;

Prueba con el comando find. Especifique el directorio codificado o como argumento. Luego inicie buscar para buscar todos los archivos dentro del directorio. Compruebe si el retorno de la búsqueda es nulo. Hacer eco de los datos de encontrar

#!/bin/bash

_DIR="/home/user/test/"
#_DIR=$1
_FIND=$(find $_DIR -type f )
if [ -n "$_FIND" ]
then
   echo -e "$_DIR contains files or subdirs with files \n\n "
   echo "$_FIND"
else
echo "empty (or does not exist)"
fi

No me gustan las ls - Asoluciones publicadas. Lo más probable es que desee probar si el directorio está vacío porque no desea eliminarlo. Lo siguiente hace eso. Sin embargo, si solo desea registrar un archivo vacío, seguramente eliminarlo y recrearlo es más rápido que enumerar archivos posiblemente infinitos.

Esto debería funcionar...

if !  rmdir ${target}
then
    echo "not empty"
else
    echo "empty"
    mkdir ${target}
fi

Funciona bien para mí esto (cuando existe dir):

some_dir="/some/dir with whitespace & other characters/"
if find "`echo "$some_dir"`" -maxdepth 0 -empty | read v; then echo "Empty dir"; fi

Con verificación completa:

if [ -d "$some_dir" ]; then
  if find "`echo "$some_dir"`" -maxdepth 0 -empty | read v; then echo "Empty dir"; else "Dir is NOT empty" fi
fi