Bash scripting: test per directory vuota

Voglio verificare se una directory non contiene alcun file. In tal caso, salterò alcune elaborazioni.

Ho provato quanto segue:

if [ ./* == "./*" ]; then
    echo "No new file"
    exit 1
fi

Questo dà il seguente errore:

line 1: [: too many arguments

C'è una soluzione / alternativa?

if [ -z "$(ls -A /path/to/dir)" ]; then
   echo "Empty"
else
   echo "Not Empty"
fi

Inoltre, sarebbe bello controllare se la directory esiste prima.

Non c'è bisogno di contare nulla o globs shell. È inoltre possibile utilizzare readin combinazione con find. Se findl'output è vuoto, restituirai false:

if find /some/dir -mindepth 1 | read; then
   echo "dir not empty"
else
   echo "dir empty"
fi

Questo dovrebbe essere portatile.

if [ -n "$(find "$DIR_TO_CHECK" -maxdepth 0 -type d -empty 2>/dev/null)" ]; then
    echo "Empty directory"
else
    echo "Not empty or NOT a directory"
fi

#!/bin/bash
if [ -d /path/to/dir ]; then
    # the directory exists
    [ "$(ls -A /path/to/dir)" ] && echo "Not Empty" || echo "Empty"
else
    # You could check here if /path/to/dir is a file with [ -f /path/to/dir]
fi

Questo farà il lavoro nella directory di lavoro corrente (.):

[ `ls -1A . | wc -l` -eq 0 ] && echo "Current dir is empty." || echo "Current dir has files (or hidden files) in it."

o lo stesso comando diviso su tre righe solo per essere più leggibile:

[ `ls -1A . | wc -l` -eq 0 ] && \
echo "Current dir is empty." || \
echo "Current dir has files (or hidden files) in it."

Sostituisci semplicemente ls -1A . | wc -lcon ls -1A <target-directory> | wc -lse devi eseguirlo su una cartella di destinazione diversa.

Modifica : ho sostituito -1acon -1A(vedi commento @Daniel)

Utilizza il seguente:

count="$( find /path -mindepth 1 -maxdepth 1 | wc -l )"
if [ $count -eq 0 ] ; then
   echo "No new file"
   exit 1
fi

In questo modo, sei indipendente dal formato di output di ls. -mindepthsalta la directory stessa, -maxdepthimpedisce la difesa ricorsiva in sottodirectory per accelerare le cose.

Utilizzando un array:

files=( * .* )
if (( ${#files[@]} == 2 )); then
    # contents of files array is (. ..)
    echo dir is empty
fi

Un modo bizzarro, ma solo bash, senza PID:

is_empty() {
    test -e "$1/"* 2>/dev/null
    case $? in
        1)   return 0 ;;
        *)   return 1 ;;
    esac
}

Questo sfrutta il fatto che testbuiltin esce con 2 se viene dato più di un argomento dopo -e: Primo, "$1"/*glob viene espanso di bash. Ciò si traduce in un argomento per file. Così

• Se non ci sono file, l'asterisco in test -e "$1"*non si espande, quindi Shell torna a provare il file denominato *, che restituisce 1.

• ... tranne se in realtà esiste un file chiamato esattamente *, allora l'asterisco si espande bene, l'asterisco, che finisce con la stessa chiamata di cui sopra, cioè. test -e "dir/*", proprio questa volta restituisce 0. (Grazie @TrueY per averlo segnalato.)

• Se è presente un file, test -e "dir/file"viene eseguito, che restituisce 0.

• Ma se ci sono più file di 1, test -e "dir/file1" "dir/file2" viene eseguito, che bash lo segnala come errore di utilizzo, cioè 2.

case avvolge l'intera logica in modo che solo il primo caso, con 1 stato di uscita, venga segnalato come riuscito.

Possibili problemi che non ho verificato:

• Ci sono più file che numero di argomenti consentiti - immagino che questo potrebbe comportarsi in modo simile al caso con 2+ file.

• O in realtà c'è un file con un nome vuoto - non sono sicuro che sia possibile su qualsiasi sistema operativo / FS sano.

Con FIND (1) (sotto Linux e FreeBSD) puoi guardare in modo non ricorsivo una voce della directory tramite "-maxdepth 0" e verificare se è vuota con "-empty". Applicato alla domanda questo dà:

if test -n "$(find ./ -maxdepth 0 -empty)" ; then
    echo "No new file"
    exit 1
fi

Penso che la soluzione migliore sia:

files=$(shopt -s nullglob; shopt -s dotglob; echo /MYPATH/*)
[[ "$files" ]] || echo "dir empty" 

grazie a https://stackoverflow.com/a/91558/520567

Questa è una modifica anonima della mia risposta che potrebbe essere o non essere utile a qualcuno: una leggera alterazione fornisce il numero di file:

files=$(shopt -s nullglob dotglob; s=(MYPATH/*); echo ${s[*]}) 
echo "MYPATH contains $files files"

Funzionerà correttamente anche se i nomi dei file contengono spazi.

if find "${DIR}" -prune ! -empty -exit 1; then
    echo Empty
else
    echo Not Empty
fi

EDIT: Penso che questa soluzione funzioni bene con gnu find, dopo una rapida occhiata all'implementazione . Ma questo potrebbe non funzionare con, ad esempio, la ricerca di netbsd . In effetti, quello usa il campo st_size di stat (2). Il manuale lo descrive come:

st_size            The size of the file in bytes.  The meaning of the size
                   reported for a directory is file system dependent.
                   Some file systems (e.g. FFS) return the total size used
                   for the directory metadata, possibly including free
                   slots; others (notably ZFS) return the number of
                   entries in the directory.  Some may also return other
                   things or always report zero.

Una soluzione migliore, anche più semplice, è:

if find "${DIR}" -mindepth 1 -exit 1; then
    echo Empty
else
    echo Not Empty
fi

Inoltre, la -pruna nella prima soluzione è inutile.

EDIT: no -exit for gnu find .. la soluzione sopra è buona per la ricerca di NetBSD. Per GNU find, questo dovrebbe funzionare:

if [ -z "`find \"${DIR}\" -mindepth 1 -exec echo notempty \; -quit`" ]; then
    echo Empty
else
    echo Not Empty
fi

Sono tutte cose fantastiche: l'ho appena trasformato in uno script in modo da poter controllare se ci sono directory vuote sotto quella corrente. Il seguente dovrebbe essere messo in un file chiamato 'findempty', posizionato nel percorso da qualche parte in modo che bash possa trovarlo e quindi eseguire 755 per eseguirlo. Immagino che possa essere facilmente modificato in base alle tue esigenze specifiche.

#!/bin/bash
if [ "$#" == "0" ]; then 
find . -maxdepth 1 -type d -exec findempty "{}"  \;
exit
fi

COUNT=`ls -1A "$*" | wc -l`
if [ "$COUNT" == "0" ]; then 
echo "$* : $COUNT"
fi

Questo lavoro per me, per controllare ed elaborare i file nella directory ../IN, considerando lo script è nella ../Scriptdirectory:

FileTotalCount=0

    for file in ../IN/*; do
    FileTotalCount=`expr $FileTotalCount + 1`
done

if test "$file" = "../IN/*"
then

    echo "EXITING: NO files available for processing in ../IN directory. "
    exit

else

  echo "Starting Process: Found ""$FileTotalCount"" files in ../IN directory for processing."

# Rest of the Code

Che ne dici di verificare se la directory esiste e non vuota in una istruzione if

if [[ -d path/to/dir && -n "$(ls -A path/to/dir)" ]]; then 
  echo "directory exists"
else
  echo "directory doesn't exist"
fi

Per qualsiasi directory diversa da quella corrente, è possibile verificare se è vuota provandoci rmdir, perché rmdirè garantito un errore per le directory non vuote. Se rmdirriesce, e in realtà volevi che la directory vuota sopravvivesse al test, di mkdirnuovo.

Non usare questo trucco se ci sono altri processi che potrebbero essere scomposti da una directory di cui sanno che cessa di esistere brevemente.

Se rmdirnon funziona per te e potresti testare directory che potrebbero potenzialmente contenere un numero elevato di file, qualsiasi soluzione che si basa sul globbing della shell potrebbe rallentare e / o incorrere in limiti di lunghezza della riga di comando. Probabilmente meglio usare findin quel caso. La findsoluzione più veloce che mi viene in mente va come

is_empty() {
    test -z $(find "$1" -mindepth 1 -printf X -quit)
}

Questo funziona per le versioni GNU e BSD di findma non per quella di Solaris, che manca a ciascuno di quegli findoperatori. Adoro il tuo lavoro, Oracle.

Puoi provare a rimuovere la directory e attendere un errore; rmdir non cancellerà la directory se non è vuota.

_path="some/path"
if rmdir $_path >/dev/null 2>&1; then
   mkdir $_path        # create it again
   echo "Empty"
else
   echo "Not empty or doesn't exist"
fi