Em um script de shell, como verifico se um diretório contém arquivos?

Algo parecido com isso

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

mas que funciona se o diretório contém um ou vários arquivos (o acima só funciona com exatamente 0 ou 1 arquivo).

As soluções até agora usam ls. Esta é uma solução totalmente bash:

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

Três melhores truques

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

Este truque é 100% bashe invoca (gera) um sub-shell. A ideia é de Bruno De Fraine e melhorada pelo comentário do 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: não há diferença entre um diretório vazio e um não existente (e mesmo quando o caminho fornecido é um arquivo).

Há uma alternativa semelhante e mais detalhes (e mais exemplos) no FAQ 'oficial' do 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 truque é inspirado no artigo da nixCraft postado em 2007. Adicione 2>/dev/nullpara suprimir o erro de saída "No such file or directory".
^{Veja também a resposta de Andrew Taylor (2008) e a resposta 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

ou a versão do bashismo de uma linha:

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

Nota: ls retorna $?=2quando o diretório não existe. Mas não há diferença entre um arquivo e um diretório vazio.

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

Este último truque é inspirado na resposta da gravstar, onde -maxdepth 0é substituído -prunee melhorado pelo comentário de phils .

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

uma variação 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

Explicação:

• find -prune é semelhante a find -maxdepth 0 usar menos caracteres
• find -empty imprime os diretórios e arquivos vazios
• find -type d imprime diretórios apenas

Observação: você também pode substituir [ -n "$(find your/dir -prune -empty)" ]apenas pela versão abreviada abaixo:

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 na maioria dos casos, mas esteja ciente de que caminhos maliciosos podem expressar um comando ...

Que tal o seguinte:

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

Desta forma, não há necessidade de gerar uma listagem completa do conteúdo do diretório. O readserve para descartar a saída e fazer com que a expressão seja avaliada como verdadeira apenas quando algo for lido (ou seja, /some/dir/for encontrado vazio por find).

Experimentar:

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
}

Cuidado com os diretórios com muitos arquivos! Pode levar algum tempo para avaliar o lscomando.

IMO a melhor solução é aquela que usa

find /some/dir/ -maxdepth 0 -empty

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

Você poderia comparar a saída disso?

 ls -A /some/dir | wc -l

# Verifica se um diretório contém arquivos não ocultos.
#
# uso: if isempty "$ HOME"; em seguida, echo "Bem-vindo ao lar"; fi
#
está vazia() {
    para _ief em $ 1 / *; Faz
        if [-e "$ _ief"]; então
            retorno 1
        fi
    feito
    retornar 0
}

Algumas notas de implementação:

• O forloop evita uma chamada para um lsprocesso externo . Ele ainda lê todas as entradas do diretório uma vez. Isso só pode ser otimizado escrevendo um programa C que usa readdir () explicitamente.
• O test -edentro do loop captura o caso de um diretório vazio, caso em que a variável _iefseria atribuída ao valor "somedir / *". Somente se o arquivo existir a função retornará "não vazio"
• Esta função funcionará em todas as implementações POSIX. Mas esteja ciente de que o Solaris / bin / sh não se enquadra nessa categoria. Sua testimplementação não suporta a -ebandeira.

Isso me diz se o diretório está vazio ou não, o número de arquivos que ele contém.

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 pode ser uma resposta muito tardia, mas aqui está uma solução que funciona. Esta linha reconhece apenas a existência de arquivos! Ele não fornecerá um falso positivo se houver diretórios.

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

Suponha que você não tenha um arquivo nomeado *em /any/dir/you/check, ele deve funcionar bash dash posh busybox she, zshmas (para zsh) exigir unsetopt nomatch.

Os desempenhos devem ser comparáveis ​​a qualquer um lsque use *(glob), acho que será lento em diretórios com muitos nós (meu/usr/bin com mais de 3000 arquivos não foi tão lento), usará pelo menos memória suficiente para alocar todos os diretórios / nomes de arquivos (e mais) como todos eles são passados ​​(resolvidos) para a função como argumentos, alguns shell provavelmente têm limites no número de argumentos e / ou comprimento dos argumentos.

Seria bom ter uma maneira rápida e portátil O (1) de zero recursos para verificar se um diretório está vazio.

atualizar

A versão acima não leva em conta arquivos / diretórios ocultos, caso seja necessário mais algum teste, como os truques 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 )

Mas, em vez disso, estou pensando em algo assim:

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

Alguma preocupação sobre as diferenças de barras finais do argumento e da saída de encontrar quando o dir está vazio, e novas linhas finais (mas isso deve ser fácil de manusear), infelizmente no meu busybox shprograma o que provavelmente é um bug no find -> ddtubo com a saída truncada aleatoriamente ( se usei cata saída é sempre a mesma, parece ser ddcom o argumento count).

ZSH

Eu sei que a pergunta foi marcada para bash; mas, apenas para referência, para usuários zsh :

Teste para diretório não vazio

Para verificar se foonão está vazio:

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

onde, se foonão estiver vazio, o código do forbloco será executado.

Teste para diretório vazio

Para verificar se fooestá vazio:

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

onde, se fooestiver vazio, o código do forbloco será executado.

Notas

Não precisamos citar o diretório fooacima, mas podemos fazer isso se precisarmos:

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

Também podemos testar mais de um objeto, mesmo que não seja um diretório:

$ 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

Tudo o que não for um diretório será simplesmente ignorado.

Extras

Já que estamos globbing, podemos usar qualquer glob (ou expansão de chave):

$ 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

Também podemos examinar objetos colocados em uma matriz. Com os diretórios acima, por exemplo:

$ 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

Assim, podemos testar objetos que já podem estar configurados em um parâmetro de matriz.

Observe que o código no forbloco é, obviamente, executado em cada diretório por vez. Se isso não for desejável, você pode simplesmente preencher um parâmetro de matriz e, em seguida, operar nesse parâmetro:

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

Explicação

Para usuários zsh, há o (F)qualificador glob (consulte Recursos man zshexpn), que corresponde a diretórios "completos" (não vazios):

$ 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/

O qualificador (F)lista os objetos que correspondem: é um diretório E não está vazio. Portanto, (^F)corresponde a: não é um diretório OU está vazio. Assim, (^F)sozinho também listaria arquivos regulares, por exemplo. Portanto, conforme explicado na zshexppágina do manual, também precisamos do (/)qualificador glob, que lista apenas os diretórios:

$ 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

Assim, para verificar se um determinado diretório está vazio, você pode executar:

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

e apenas para ter certeza de que um diretório não vazio não seria capturado:

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

Ops! Como Ynão está vazio, zsh não encontra correspondências para (/^F)("diretórios que estão vazios") e, portanto, exibe uma mensagem de erro informando que nenhuma correspondência para o glob foi encontrada. Portanto, precisamos suprimir essas possíveis mensagens de erro com o (N)qualificador glob:

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

Assim, para diretórios vazios, precisamos do qualificador (N/^F), que pode ser lido como: "não me avise sobre falhas, diretórios que não estão cheios".

Da mesma forma, para diretórios não vazios, precisamos do qualificador (NF), que também podemos ler como: "não me avise sobre falhas, diretórios completos".

Estou surpreso que o guia complicado sobre diretórios vazios não tenha sido mencionado. Este guia, e realmente tudo de lã, é uma leitura obrigatória para perguntas do tipo shell.

Digno de nota nessa página:

Nunca tente analisar a saída ls. Mesmo as soluções ls -A podem falhar (por exemplo, no HP-UX, se você for root, ls -A faz exatamente o oposto do que faria se você não fosse root - e não, não posso inventar algo tão incrivelmente estúpido).

Na verdade, pode-se desejar evitar a pergunta direta completamente. Normalmente as pessoas querem saber se um diretório está vazio porque querem fazer algo envolvendo os arquivos nele, etc. Observe a questão maior. Por exemplo, um desses exemplos baseados em localização pode ser uma solução apropriada:

   # 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

Mais comumente, tudo o que é realmente necessário é algo assim:

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

Em outras palavras, a pessoa que fez a pergunta pode ter pensado que um teste explícito de diretório vazio era necessário para evitar uma mensagem de erro como mympgviewer: ./*.mpg: Não existe esse arquivo ou diretório quando na verdade esse teste não é necessário.

Pequena variação da resposta de Bruno :

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

Funciona para mim

Pegando uma dica (ou várias) da resposta de olibre, gosto de uma função Bash:

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

Porque, embora crie um subshell, é o mais próximo de uma solução O (1) que posso imaginar e dar um nome a torna legível. Eu posso então escrever

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

Quanto a O (1), há casos atípicos: se um diretório grande teve todos ou todos, exceto a última entrada excluída, "find" pode ter que ler tudo para determinar se está vazio. Eu acredito que o desempenho esperado é O (1), mas o pior caso é linear no tamanho do diretório. Eu não medi isso.

Até agora não vi uma resposta que use grep, o que acho que daria uma resposta mais simples (sem muitos símbolos estranhos!) Aqui está como eu verificaria se existem arquivos no diretório usando o shell do bourne:

isso retorna o número de arquivos em um diretório:

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

você pode preencher o caminho do diretório onde o diretório está escrito. A primeira metade do pipe garante que o primeiro caractere de saída seja "-" para cada arquivo. egrep então conta o número de linhas que começam com aquele símbolo usando expressões regulares. agora tudo o que você precisa fazer é armazenar o número obtido e compará-lo usando crases como:

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

x é uma variável de sua escolha.

Misturando coisas de poda e últimas respostas, eu tenho que

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

que funciona para caminhos com espaços também

Resposta simples com bash :

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

Eu iria para find:

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

Isso verifica a saída de procurar apenas arquivos no diretório, sem passar pelos subdiretórios. Em seguida, verifica a saída usando a -zopção retirada de man test:

   -z STRING
          the length of STRING is zero

Veja alguns resultados:

$ mkdir aaa
$ dir="aaa"

Dir vazio:

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

Apenas dirs nele:

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

Um arquivo no diretório:

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

Um arquivo em um subdiretório:

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

Com alguma solução alternativa, poderia encontrar uma maneira simples de descobrir se há arquivos em um diretório. Isso pode ser estendido com mais comandos grep para verificar especificamente arquivos .xml ou .txt, etc. Ex: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 testar um diretório 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;

Tente com o comando find. Especifique o diretório codificado ou como argumento. Em seguida, inicie a localização para pesquisar todos os arquivos dentro do diretório. Verifique se o retorno do find é nulo. Ecoar os dados 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

Não gosto das ls - Asoluções postadas. Provavelmente, você deseja testar se o diretório está vazio porque não deseja excluí-lo. O seguinte faz isso. Se, no entanto, você deseja apenas registrar um arquivo vazio, certamente excluí-lo e recriá-lo é mais rápido do que listar arquivos possivelmente infinitos.

Isso deve funcionar ...

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

Funciona bem para mim (quando 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

Com verificação 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