Bir kabuk komut dosyasından, bir dizinin dosya içerip içermediğini nasıl kontrol ederim?

Buna benzer bir şey

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

ancak dizin bir veya birkaç dosya içeriyorsa işe yarar (yukarıdaki dosya yalnızca 0 veya 1 dosyayla çalışır).

Şimdiye kadar kullanılan çözümler ls. İşte tam bir bash çözümü:

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

En iyi üç numara

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

Bu numara% 100'dür bashve bir alt kabuk çağırır (ortaya çıkarır). Fikir dan Bruno De Fraine ve geliştirilebilir teambob un yorumunu.

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

Not: boş bir dizin ile mevcut olmayan bir dizin arasında fark yoktur (ve sağlanan yol bir dosya olsa bile).

#Bash IRC kanalı için 'resmi' SSS'de benzer bir alternatif ve daha fazla ayrıntı (ve daha fazla örnek) var :

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)" ]

Bu numara, nixCraft'ın 2007'de yayınlanan makalesinden ilham almıştır . 2>/dev/nullÇıktı hatasını bastırmak için ekleyin "No such file or directory".
^{Ayrıca Andrew Taylor'ın cevabına (2008) ve gr8can8dian'ın cevabına (2011) bakın.}

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

veya tek satırlık bashizm versiyonu:

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

Not: dizin mevcut olmadığında lsgeri döner $?=2. Ancak bir dosya ile boş bir dizin arasında hiçbir fark yoktur.

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

Bu son hüner esinlenerek gravstar cevabı-maxdepth 0 ile değiştirilir -pruneve geliştirilebilir Phil'ler un yorumunu.

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

kullanan bir varyasyon -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

Açıklama:

• find -prunefind -maxdepth 0daha az karakter kullanmaya benzer
• find -empty boş dizinleri ve dosyaları yazdırır
• find -type d yalnızca dizinleri yazdırır

Not:[ -n "$(find your/dir -prune -empty)" ] Aşağıdaki kısaltılmış versiyonla da değiştirebilirsiniz :

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

Bu son kod çoğu durumda çalışır, ancak kötü amaçlı yolların bir komutu ifade edebileceğini unutmayın ...

Aşağıdakilere ne dersiniz:

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

Bu şekilde, dizinin içeriğinin tam bir listesini oluşturmaya gerek kalmaz. Her readikisi de çıktıyı atmak ve ifadeyi yalnızca bir şey okunduğunda (yani /some/dir/tarafından boş bulunduğunda find) doğru olarak değerlendirmektir.

Deneyin:

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
}

Çok sayıda dosya içeren dizinlere dikkat edin! lsKomutu değerlendirmek biraz zaman alabilir .

IMO en iyi çözüm, kullanan olandır

find /some/dir/ -maxdepth 0 -empty

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

Bunun çıktısını karşılaştırır mısınız?

 ls -A /some/dir | wc -l

# Bir dizinin gizlenmemiş dosyalar içerip içermediğini kontrol eder.
#
# kullanım: boşsa "$ HOME"; sonra echo "Eve hoş geldin"; fi
#
boş() {
    $ 1 / * cinsinden _ief için; yapmak
        eğer [-e "$ _ief"]; sonra
            dönüş 1
        fi
    tamam
    dönüş 0
}

Bazı uygulama notları:

• forDöngü harici bir çağrı önler lssüreç. Hala tüm telefon rehberi girişlerini bir kez okur. Bu sadece readdir () 'i açıkça kullanan bir C programı yazarak optimize edilebilir.
• test -eDöngü içinde değişken bu durumda boş bir dizin vakasını yakalar _iefdeğeri "somedir / *" tayin olacaktı. Yalnızca bu dosya mevcutsa işlev "boş olmayan" döndürür
• Bu işlev tüm POSIX uygulamalarında çalışacaktır. Ancak Solaris / bin / sh'nin bu kategoriye girmediğini unutmayın. Onun testuygulama desteklemiyor -ebayrağı.

Bu bana dizinin boş olup olmadığını veya yoksa içerdiği dosyaların sayısını söyler.

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

Bu gerçekten geç bir yanıt olabilir ama işte işe yarayan bir çözüm. Bu satır yalnızca dosyaların varlığını tanır! Dizinler varsa, size yanlış bir pozitif vermez.

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

Eğer adlı bir dosya yok farz *içine /any/dir/you/check, bu çalışması gerekir bash dash posh busybox shve zshihtiyaç ama (zsh için) unsetopt nomatch.

Performanslar, lskullanılan *(glob) ile karşılaştırılabilir olmalıdır , sanırım birçok düğüme sahip dizinlerde yavaş olacaktır ( /usr/bin3000'den fazla dosyam o kadar da yavaş gitmedi), en azından tüm dizinleri / dosya adlarını (ve daha fazlasını) ayırmak için yeterince bellek kullanacaktır. hepsi argüman olarak işleve geçirildiğinden (çözümlendiğinden), bazı kabukların argüman sayısı ve / veya argümanların uzunluğu konusunda muhtemelen sınırları vardır.

Bir dizinin boş olup olmadığını kontrol etmenin taşınabilir hızlı O (1) sıfır kaynak yolu olması güzel olurdu.

Güncelleme

Yukarıdaki sürüm is_empty, Rich'in sh (POSIX kabuğu) hileleri gibi bazı daha fazla testin gerekli olması durumunda gizli dosyaları / dizinleri hesaba katmaz :

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

Ama bunun yerine şöyle bir şey düşünüyorum:

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

Sondaki eğik çizgi ile ilgili bazı endişeler argümandan farklılıklar ve dir boş olduğunda bul çıktısı ve son satırlar (ancak bunun üstesinden gelmek kolay olmalıdır), ne yazık ki benim busybox shgösterime göre find -> dd, çıktının rastgele kesildiği boruda muhtemelen bir hata ( Kullandıysam catçıktı hep aynıdır, ddargümanla birlikte görünüyor count).

ZSH

Sorunun bash için işaretlendiğini biliyorum; ancak zsh kullanıcıları için sadece referans için :

Boş olmayan dizini test edin

fooBoş olup olmadığını kontrol etmek için :

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

burada, fooboş değilse , forbloktaki kod çalıştırılacaktır.

Boş dizini test edin

fooBoş olup olmadığını kontrol etmek için :

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

burada, fooboşsa, forbloktaki kod çalıştırılacaktır.

notlar

fooYukarıdaki dizinden alıntı yapmamıza gerek yoktu , ancak bunu yapmamız gerekirse yapabiliriz:

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

Bir dizin olmasa bile birden fazla nesneyi test edebiliriz:

$ 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

Dizin olmayan her şey göz ardı edilecektir.

Ekstralar

Globling olduğumuz için herhangi bir glob (veya küme ayracı genişletmesi) kullanabiliriz:

$ 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

Bir diziye yerleştirilmiş nesneleri de inceleyebiliriz. Yukarıdaki gibi dizinlerle, örneğin:

$ 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

Böylece, bir dizi parametresinde önceden ayarlanmış olabilecek nesneleri test edebiliriz.

Bloktaki kodun foraçıkça sırayla her dizinde yürütüldüğüne dikkat edin. Bu istenmiyorsa, bir dizi parametresini doldurabilir ve ardından bu parametre üzerinde işlem yapabilirsiniz:

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

açıklama

Zsh kullanıcıları için , "dolu" (boş olmayan) dizinlerle eşleşen (F)glob niteleyicisi (bkz. man zshexpn) Vardır :

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

Eleme (F)listeleri bu maçı nesneleri: Bir dizinidir VE boş değil. Yani, (^F)eşleşir: bir dizin değil VEYA boş. Böylece, örneğin (^F)tek başına normal dosyaları da listeleyecektir. Bu nedenle, zshexpman sayfasında açıklandığı gibi (/), yalnızca dizinleri listeleyen glob niteleyicisine de ihtiyacımız var :

$ 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

Böylece, belirli bir dizinin boş olup olmadığını kontrol etmek için şunu çalıştırabilirsiniz:

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

ve sadece boş olmayan bir dizinin yakalanmayacağından emin olmak için:

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

Hata! Yana Yboş değil, zsh için herhangi eşleşmeleri bulur (/^F)( "boş dizinleri") ve böylece topak için eşleşme bulunduğunu belirten bir hata mesajı tükürür. Bu nedenle bu olası hata mesajlarını (N)glob niteleyicisi ile bastırmamız gerekir :

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

Bu nedenle, boş dizinler için niteleyiciye ihtiyacımız var, bu niteleyiciyi (N/^F)okuyabilirsiniz: "beni arızalar ve dolu olmayan dizinler hakkında uyarma".

Benzer şekilde, boş olmayan dizinler için niteleyiciye ihtiyacımız var, bu niteleyiciye (NF)benzer şekilde okuyabiliriz: "beni hatalar, tam dizinler hakkında uyarma".

Boş dizinlerle ilgili yünlü rehberden bahsedilmemesine şaşırdım . Bu kılavuz ve tüm yün kenarları, kabuk tipi sorular için okunması gereken bir kitaptır.

Bu sayfadaki not:

Asla ls çıktısını ayrıştırmaya çalışmayın. Ls -A çözümleri bile bozulabilir (örneğin, HP-UX'te, eğer root isen, ls -A, root değilseniz yaptığının tam tersini yapar - ve hayır, bu kadar inanılmaz bir şey uyduramam Aptal).

Aslında, doğrudan sorudan tamamen kaçınmak isteyebilir. Genellikle insanlar bir dizinin boş olup olmadığını bilmek isterler, çünkü içindeki dosyalar vb. İle ilgili bir şeyler yapmak isterler. Daha büyük soruya bakın. Örneğin, bulmaya dayalı bu örneklerden biri uygun bir çözüm olabilir:

   # 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

Çoğu zaman, gerçekten ihtiyaç duyulan tek şey şuna benzer bir şeydir:

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

Başka bir deyişle, soruyu soran kişi, mympgviewer gibi bir hata mesajından kaçınmak için açık bir boş dizin testinin gerekli olduğunu düşünmüş olabilir: ./*.mpg: Aslında böyle bir test gerekmediğinde böyle bir dosya veya dizin yok.

Bruno'nun cevabının küçük bir varyasyonu :

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

Benim için çalışıyor

Olibre'nin cevabından bir ipucu (veya birkaç) alırsak, Bash fonksiyonunu severim:

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

Çünkü bir alt kabuk oluştururken, bir O (1) çözümüne hayal edebileceğim kadar yakın ve ona bir isim vermek onu okunabilir kılıyor. Sonra yazabilirim

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

O (1) 'e gelince, aykırı durumlar vardır: büyük bir dizinde son girişin tamamı veya tümü silinmişse, "bul", boş olup olmadığını belirlemek için her şeyi okumak zorunda kalabilir. Beklenen performansın O (1) olduğuna inanıyorum, ancak en kötü durum dizin boyutunda doğrusaldır. Bunu ölçmedim.

Şimdiye kadar daha basit bir cevap vereceğini düşündüğüm grep kullanan bir cevap görmedim (çok fazla tuhaf sembolle!). İşte bourne kabuğu kullanarak dizinde herhangi bir dosya olup olmadığını nasıl kontrol edeceğim:

bu, bir dizindeki dosya sayısını döndürür:

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

dizinin yazıldığı dizin yolunu doldurabilirsiniz. Borunun ilk yarısı, her dosya için çıktının ilk karakterinin "-" olmasını sağlar. egrep daha sonra normal ifadeleri kullanarak o sembolle başlayan satır sayısını sayar. şimdi tek yapmanız gereken, elde ettiğiniz numarayı saklamak ve aşağıdaki gibi ters alıntılar kullanarak karşılaştırmaktır:

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

x, seçtiğiniz bir değişkendir.

Kuru erik şeyleri ve son cevapları karıştırmak zorundayım

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

boşluklu yollar için de işe yarar

Bash ile basit cevap :

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

Ben giderdim find:

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

Bu, alt dizinlere geçmeden sadece dizindeki dosyaları aramanın çıktısını kontrol eder. Ardından, -zşuradan alınan seçeneği kullanarak çıktıyı kontrol eder man test:

   -z STRING
          the length of STRING is zero

Bazı sonuçları görün:

$ mkdir aaa
$ dir="aaa"

Boş dizin:

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

Sadece içinde var:

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

Dizindeki bir dosya:

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

Alt dizindeki bir dosya:

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

Bazı geçici çözümlerle, bir dizinde dosya olup olmadığını öğrenmenin basit bir yolunu bulabilirim. Bu, özellikle .xml veya .txt dosyalarını vb. Kontrol etmek için grep komutlarıyla daha fazlasını genişletebilir. Örn: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;

belirli bir hedef dizini test etmek için

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;

Bul komutu ile deneyin. Kodlanmış dizini veya bağımsız değişken olarak belirtin. Ardından dizin içindeki tüm dosyaları aramak için bulmayı başlatın. Bulma dönüşünün boş olup olmadığını kontrol edin. Bulma verilerini yankılayın

#!/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

ls - AGönderilen çözümleri beğenmedim . Büyük olasılıkla dizinin boş olup olmadığını test etmek istersiniz çünkü onu silmek istemezsiniz. Aşağıdakiler bunu yapar. Bununla birlikte, boş bir dosyayı günlüğe kaydetmek istiyorsanız, kesinlikle silmek ve yeniden oluşturmak, muhtemelen sonsuz dosyaları listelemekten daha hızlı mıdır?

Bu çalışmalı...

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

Bu benim için iyi çalışıyor (var olduğunda):

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

Tam kontrol ile:

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