it-swarm-tr.com

Bulunan bir dizinin dışlanması. komuta

Tüm JavaScript dosyaları için find komutunu çalıştırmaya çalışıyorum, ancak belirli bir dizini nasıl hariç tutarım?

İşte kullandığımız find kodu.

for file in $(find . -name '*.js')
do 
  Java -jar config/yuicompressor-2.4.2.jar --type js $file -o $file
done
1108
helion3

Prune anahtarını kullanın, örneğin miscdizinini dışlamak istiyorsanız, find komutunuza yalnızca -path ./misc -Prune -o ekleyin:

find . -path ./misc -Prune -o -name '*.txt' -print

Birden çok dizin içeren bir örnek:

find . -type d \( -path dir1 -o -path dir2 -o -path dir3 \) -Prune -o -print

Burada dirs, dir2 ve dir3'ü dışlıyoruz, çünkü findifadelerinde -path dir1 -o -path dir2 -o -path dir3 (dir1 veya dir2 veya dir3 ise), ANDed type -d ölçütlerine göre hareket eden bir eylemdir. Daha fazla eylem -o print, sadece yazdırın.

853
f10bit

-Prune sizin için işe yaramazsa, bu:

find -name "*.js" -not -path "./directory/*"

Caveat: @Daniel tarafından okunan yorumu.

1727
GetFree

Önerilen diğer çözümlerden daha fazla nedenden dolayı daha kolay buluyorum:

find build -not \( -path build/external -Prune \) -name \*.js
# you can also exclude multiple paths
find build -not \( -path build/external -Prune \) -not \( -path build/blog -Prune \) -name \*.js

Önemli Not:-path komutundan sonra yazdığınız yollar, find öğesinin hariç tutmadan yazdırdığı ile tam olarak eşleşmelidir. Bu cümle sizi şaşırtıyorsa, whole komutunu şu şekilde kullanarak tam yolları kullandığınızdan emin olun: find /full/path/ -not \( -path /full/path/exclude/this -Prune \) .... Daha iyi bir anlayış istiyorsanız Not [1] 'e bakınız.

\( ve \) içinde, tam olarak eşleşecek bir ifadedir build/external (yukarıdaki önemli nota bakınız) ve , başarı durumunda, aşağıdakileri geçmekten kaçınacaktır . Bu daha sonra, çıkarılan parantez ile tek bir ifade olarak gruplandırılır ve find ifadesinin eşleştirdiği herhangi bir şeyi atlamasını sağlayan -not ile ön eklenir.

Bunlardan biri, -not eklenmesi, -Prune tarafından gizlenen diğer tüm dosyaları tekrar ortaya çıkarmayacağını ve yanıtın hayır olup olmadığını sorabilir. -Prune'ın çalışma şekli, ulaştığında, bu dizinin altındaki dosyaların kalıcı olarak göz ardı edildiği bir şeydir.

Bu, kışcı tarafından oluşturulan bazı dosyalarda yui-kompresörünü çağırmam gereken, fakat olduğu gibi gönderilmesi gereken diğer dosyaları dışarıda bırakmam gereken gerçek bir kullanım durumundan geliyor.


Not [1]: /tmp/foo/bar dışında bırakmak istiyorsanız ve "find /tmp \(..." gibi bir sonuç bulmaya çalışıyorsanız, -path /tmp/foo/bar belirtmelisiniz. Öte yandan, koşarken böyle cd /tmp; find . \(... bulursanız _ -path ./foo/bar olarak belirtmelisiniz.

422
Daniel C. Sobral

Burada bir dizini atlamak için tercih edilen sözdiziminin ne olması gerektiği konusunda açıkça bir karışıklık var.

GNU Görüş

To ignore a directory and the files under it, use -Prune

GNU man sayfasını bulun

Muhakeme

-Prunefind öğesinin bir dizine girmesini durdurur. Sadece -not -path belirtmek hala atlanmış dizinine inecektir, ancak find her dosyayı test ettiğinde -not -path yanlış olacaktır.

-Prune ile ilgili sorunlar

-Prune, amaçlandığı şeyi yapar, ancak kullanırken dikkat etmeniz gereken bazı şeylerdir.

  1. find, budanmış dizini yazdırır.

    • TRUEBu amaçlanan davranış, sadece içine inmiyor. Dizini tamamen yazdırmaktan kaçınmak için, mantıken ihmal eden bir sözdizimi kullanın.
  2. -Prune sadece -print ile çalışır ve başka bir işlem yapmaz.

    • DOĞRU DEĞİL . -Prune, -delete dışında herhangi bir eylemle çalışır. Neden silme ile çalışmaz?-delete 'ın çalışması için, dizini DFS sırasından geçirme gereksinimi duyar, çünkü -delete önce yaprakları siler, sonra yaprakların ebeveynleri vb. -Prune 'u belirtmek için find' ın bir dizine basması ve aşağıya doğru durması gerekir; bu, -depth veya -delete on ile açıkça anlaşılmaz.

Performans

Bu soruya ilişkin üst üste gelen üç yanıtın basit bir testini yaptım (başka bir eylem örneği göstermek için -print-exec bash -c 'echo $0' {} \; ile değiştirildi). Sonuçlar aşağıda

----------------------------------------------
# of files/dirs in level one directories
.performance_test/Prune_me     702702    
.performance_test/other        2         
----------------------------------------------

> find ".performance_test" -path ".performance_test/Prune_me" -Prune -o -exec bash -c 'echo "$0"' {} \;
.performance_test
.performance_test/other
.performance_test/other/foo
  [# of files] 3 [Runtime(ns)] 23513814

> find ".performance_test" -not \( -path ".performance_test/Prune_me" -Prune \) -exec bash -c 'echo "$0"' {} \;
.performance_test
.performance_test/other
.performance_test/other/foo
  [# of files] 3 [Runtime(ns)] 10670141

> find ".performance_test" -not -path ".performance_test/Prune_me*" -exec bash -c 'echo "$0"' {} \;
.performance_test
.performance_test/other
.performance_test/other/foo
  [# of files] 3 [Runtime(ns)] 864843145

Sonuç

Her ikisi de f10bit'in sözdizimi ve Daniel C. Sobral'in sözdizimi ortalama olarak çalışması 10-25ms aldı. GetFree'nin sözdizimi , -Prune öğesini kullanmadı, 865ms aldı. Bu yüzden, evet, bu oldukça aşırı bir örnek, ancak çalışma zamanını önemsiyorsanız ve uzaktan yoğun bir şey yapıyorsanız -Prune öğesini kullanmalısınız.

Not Daniel C. Sobral'in sözdizimi , iki -Prune sözdiziminin daha iyisini yaptı; Prune olmayan sürüm her zaman yavaştı.

Test Komut Dosyası

#!/bin/bash

dir='.performance_test'

setup() {
  mkdir "$dir" || exit 1
  mkdir -p "$dir/Prune_me/a/b/c/d/e/f/g/h/i/j/k/l/m/n/o/p/q/r/s/t/u/w/x/y/z" \
    "$dir/other"

  find "$dir/Prune_me" -depth -type d -exec mkdir '{}'/{A..Z} \;
  find "$dir/Prune_me" -type d -exec touch '{}'/{1..1000} \;
  touch "$dir/other/foo"
}

cleanup() {
  rm -rf "$dir"
}

stats() {
  for file in "$dir"/*; do
    if [[ -d "$file" ]]; then
      count=$(find "$file" | wc -l)
      printf "%-30s %-10s\n" "$file" "$count"
    fi
  done
}

name1() {
  find "$dir" -path "$dir/Prune_me" -Prune -o -exec bash -c 'echo "$0"'  {} \;
}

name2() {
  find "$dir" -not \( -path "$dir/Prune_me" -Prune \) -exec bash -c 'echo "$0"' {} \;
}

name3() {
  find "$dir" -not -path "$dir/Prune_me*" -exec bash -c 'echo "$0"' {} \;
}

printf "Setting up test files...\n\n"
setup
echo "----------------------------------------------"
echo "# of files/dirs in level one directories"
stats | sort -k 2 -n -r
echo "----------------------------------------------"

printf "\nRunning performance test...\n\n"

echo \> find \""$dir"\" -path \""$dir/Prune_me"\" -Prune -o -exec bash -c \'echo \"\$0\"\'  {} \\\;
name1
s=$(date +%s%N)
name1_num=$(name1 | wc -l)
e=$(date +%s%N)
name1_perf=$((e-s))
printf "  [# of files] $name1_num [Runtime(ns)] $name1_perf\n\n"

echo \> find \""$dir"\" -not \\\( -path \""$dir/Prune_me"\" -Prune \\\) -exec bash -c \'echo \"\$0\"\' {} \\\;
name2
s=$(date +%s%N)
name2_num=$(name2 | wc -l)
e=$(date +%s%N)
name2_perf=$((e-s))
printf "  [# of files] $name2_num [Runtime(ns)] $name2_perf\n\n"

echo \> find \""$dir"\" -not -path \""$dir/Prune_me*"\" -exec bash -c \'echo \"\$0\"\' {} \\\;
name3
s=$(date +%s%N)
name3_num=$(name3 | wc -l)
e=$(date +%s%N)
name3_perf=$((e-s))
printf "  [# of files] $name3_num [Runtime(ns)] $name3_perf\n\n"

echo "Cleaning up test files..."
cleanup
183
BroSlow

Bir seçenek, grep ile dizin adını içeren tüm sonuçları dışlamak olacaktır. Örneğin:

find . -name '*.js' | grep -v excludeddir
55
Joshua

Bu benim için çalışan tek şey.

find / -name NameOfFile ! -path '*/Directory/*'

"Directory" hariç "NameOfFile" aranıyor. Yıldızlara önem ver *.

42
DimiDak

-not gösterimini tercih ederim ... daha okunaklı:

find . -name '*.js' -and -not -path directory
39
mpapis

-Prune seçeneğini kullanın. Yani, şöyle bir şey:

find . -type d -name proc -Prune -o -name '*.js'

'-Type d -name proc -Prune' sadece dışlanacak proc adlı dizinleri arar.
'-O', 'VEYA' işlecidir.

18
Drew Frezell

Bu, bazı yolları dışlamak için kullandığım format:

$ find ./ -type f -name "pattern" ! -path "excluded path" ! -path "excluded path"

Bunu ". *" Yollarında olmayan tüm dosyaları bulmak için kullandım:

$ find ./ -type f -name "*" ! -path "./.*" ! -path "./*/.*"
14
user1882879

-Prune kesinlikle çalışır ve en iyi cevaptır, çünkü dışlamak istediğiniz dizine inmeyi önler. Dışlanan dizini hala arayan -not -path, sadece dışlanan dizinin ağ birimine bağlı olması veya izin vermemeniz durumunda bir sorun olabilir.

İşin zor kısmı find'ın argümanların sırası konusunda çok özel olduğu, bu yüzden onları doğru yapmazsanız emriniz çalışmayabilir. Bağımsız değişkenlerin sırası genellikle şöyledir:

find {path} {options} {action}

{path}: . -path './dir1' -Prune -o gibi, yolla ilgili tüm argümanları önce girin

{options}: Bu gruptaki son seçenek olarak -name, -iname, etc'u yerleştirirken en başarılıyım. Örneğin. -type f -iname '*.js'

{action}: -print kullanırken -Prune eklemek istersiniz

İşte çalışan bir örnek:

# setup test
mkdir dir1 dir2 dir3
touch dir1/file.txt; touch dir1/file.js
touch dir2/file.txt; touch dir2/file.js
touch dir3/file.txt; touch dir3/file.js

# search for *.js, exclude dir1
find . -path './dir1' -Prune -o -type f -iname '*.js' -print

# search for *.js, exclude dir1 and dir2
find . \( -path './dir1' -o -path './dir2' \) -Prune -o -type f -iname '*.js' -print
13
wisbucky

-Path -Prune yaklaşımı ayrıca yoldaki joker karakterlerle çalışır. Git iç dizinlerini dışarıda bırakarak birden fazla git yerine hizmet veren bir git sunucusunun dizinlerini bulabilecek bir find ifadesi:

find . -type d \
   -not \( -path */objects -Prune \) \
   -not \( -path */branches -Prune \) \
   -not \( -path */refs -Prune \) \
   -not \( -path */logs -Prune \) \
   -not \( -path */.git -Prune \) \
   -not \( -path */info -Prune \) \
   -not \( -path */hooks -Prune \)  
9
Wolfgang Fahl

Çok sayıda iyi cevap var, komutun her bir öğesinin ne olduğunu ve arkasındaki mantığı anlamam biraz zaman aldı.

find . -path ./misc -Prune -o -name '*.txt' -print

bul, geçerli dizindeki dosyaları ve dizinleri bulmaya başlar, bu nedenle find ..

-o seçeneği, mantıksal bir OR anlamına gelir ve komutun iki bölümünü ayırır:

[ -path ./misc -Prune ] OR [ -name '*.txt' -print ]

değil . /Misc dizini olan herhangi bir dizin veya dosya ilk test -path ./misc dosyasını geçemez. Fakat ikinci ifadeye karşı test edilecekler. İsimleri *.txt şablonuna karşılık gelirse, -print seçeneği nedeniyle yazdırılırlar.

Find ./misc dizinine ulaştığında, bu dizin yalnızca ilk ifadeyi karşılar. Böylece -Prune seçeneği buna uygulanacaktır. Find komutuna not bu dizini keşfetmesini söyler. Böylece ./misc içindeki herhangi bir dosya veya dizin bulunup bulunmayacak bile keşfedilmeyecek, ifadenin ikinci kısmına karşı test edilmeyecek ve yazdırılmayacak.

8
Istopopoki

Birden fazla dizini hariç tutmak için:

find . -name '*.js' -not \( -path "./dir1" -o -path "./dir2/*" \)

Dizinler eklemek için -o -path "./dirname/*":

find . -name '*.js' -not \( -path "./dir1" -o -path "./dir2/*" -o -path "./dir3/*"\)

Ancak, hariç tutulacak çok sayıda dizin varsa, belki de bir düzenli ifade kullanmalısınız.

8
JBENOIT

Çalışan bir çözüm için (Ubuntu 12.04 (Precise Pangolin) üzerinde test edilmiştir) ...

find ! -path "dir1" -iname "*.mp3"

geçerli klasördeki MP3 dosyalarını ve dir1 alt klasörü dışındaki alt klasörleri arayacaktır.

Kullanın:

find ! -path "dir1" ! -path "dir2" -iname "*.mp3"

... dir1 VE dir2'yi dışlamak için

7
james dupin

Bunu elde etmek için Prune seçeneğini kullanabilirsiniz. Örneğin olduğu gibi:

find ./ -path ./beta/* -Prune -o -iname example.com -print

Veya ters grep “grep -v” seçeneği:

find -iname example.com | grep -v beta

Ayrıntılı talimatlar ve örnekleri Linux find komutu - dizinlerinin dışında tutularak bulabilirsiniz.

6
Siju V
find -name '*.js' -not -path './node_modules/*' -not -path './vendor/*'

aynı iş gibi görünüyor

find -name '*.js' -not \( -path './node_modules/*' -o -path './vendor/*' \)

ve IMO'yu hatırlamak daha kolaydır.

4
Funkodebat

UNIX'in daha eski sürümlerinde -path veya -not kullanamayanlar için

SunOS 5.10 bash 3.2 ve SunOS 5.11hh 4.4'te test edilmiştir

find . -type f -name "*" -o -type d -name "*excluded_directory*" -Prune -type f
3
JaredTS486

find için dosyaların bir listesini sağlamak için xgettext kullanıyordum ve belirli bir dizini ve içeriğini atlamak istedim. -path'un -Prune ile birleştirilmiş birçok permütasyonunu denedim fakat gitmesini istediğim dizini tamamen dışlayamadı.

Yok sayılmasını istediğim dizinin içeriğini görmezden gelebilsem de, find daha sonra dizinin kendisini sonuç olarak verdi, bu da xgettext'nin bir sonuç olarak çökmesine neden oldu (dizinleri kabul etmiyor; sadece dosyalar.

Benim çözümüm sonuçlarda istemediğim dizini atlamak için basitçe grep -v kullanmaktı:

find /project/directory -iname '*.php' -or -iname '*.phtml' | grep -iv '/some/directory' | xargs xgettext

% 100 çalışacak find için bir argüman olup olmadığı kesin olarak söyleyemem. grep kullanmak, bir miktar baş ağrısından sonra hızlı ve kolay bir çözümdü.

3
Lemmings19

İhtiyacım olan şey için, böyle çalıştı, kökten başlayarak ve landscape.jpg dizinindeki aramayı hariç tutarak tüm sunucularda /var bulmak:

find / -maxdepth 1 -type d | grep -v /var | xargs -I '{}' find '{}' -name landscape.jpg

find / -maxdepth 1 -type d, / içindeki tüm d irectoriesleri listeler.

grep -v /var `/ var 'öğesini listeden çıkarır

xargs -I '{}' find '{}' -name landscape.jpg, listedeki her bir dizin/sonuç bulunan find gibi herhangi bir komutu çalıştırır.

2
adrianTNT

Bu Mac'te benim için uygun:

find . -name *.php -or -path "./vendor" -Prune -or -path "./app/cache" -Prune

vendor ile eklenmiş arama adı için php ve app/cache dir öğelerini hariç tutar.

2
jiahut
find . -name '*.js' -\! -name 'glob-for-excluded-dir' -Prune
2

Ubuntu'da önceki cevapların hiçbiri iyi değil. Bunu dene:

find . ! -path "*/test/*" -type f -name "*.js" ! -name "*-min-*" ! -name "*console*"

Bunu buldum burada

2
sixro

nasıl kullanılacağı-Prune seçeneği-of----in-shLaurence Gonsalves-Prune işlevinin nasıl çalıştığıyla ilgili mükemmel bir cevaptır.

Ve işte genel çözüm:

find /path/to/search                    \
  -type d                               \
    \( -path /path/to/search/exclude_me \
       -o                               \
       -name exclude_me_too_anywhere    \
     \)                                 \
    -Prune                              \
  -o                                    \
  -type f -name '*\.js' -print

/path/to/seach/ komutunu birden çok kez yazmaktan kaçınmak için find dosyasını pushd .. popd çiftine sarın.

pushd /path/to/search;                  \
find .                                  \
  -type d                               \
    \( -path ./exclude_me               \
       -o                               \
       -name exclude_me_too_anywhere    \
     \)                                 \
    -Prune                              \
  -o                                    \
  -type f -name '*\.js' -print;         \
 popd
1
go2null

exec eylemini for döngüsünden daha iyi kullanın:

find . -path "./dirtoexclude" -Prune \
    -o -exec Java -jar config/yuicompressor-2.4.2.jar --type js '{}' -o '{}' \;

exec ... '{}' ... '{}' \;, eşleşen her dosya için bir kez yürütülür; buradaki parantez '{}', geçerli dosya adıyla değiştirilir.

Parantezlerin Kabuk komut dosyası noktalama işaretleri olarak yorumlanmasını önlemek için tek tırnak işareti içine alındığına dikkat edin*.


Notlar

* find (GNU findutils) 4.4.2 man sayfasının ÖRNEKLER bölümünden

1
Alberto

Yukarıdaki komutu denedim, ancak "-Prune" kullananların hiçbiri benim için işe yaramıyor. Sonunda bunu aşağıdaki komutu kullanarak denedim:

find . \( -name "*" \) -Prune -a ! -name "directory"
1
Jolly Liu

C isimleri dosyalarında * .o ve exclude * .swp dışlayan ve dışlayan (normal dosya değil) ve dir komutunu bu komutla dışladım:

find .  \( ! -path "./output/*" \) -a \( -type f \) -a \( ! -name '*.o' \) -a \( ! -name '*.swp' \) | xargs grep -n soc_attach
1
Ivan Ivanovich

Burada zaten birçok cevap var; Başka bir tane eklemek konusunda isteksizim, ancak bu bilginin faydalı olduğunu düşünüyorum.

TLDR: kök dizinlerinizi anlayın ve "-Prune" seçeneğini kullanarak aramanızı oradan düzenleyin.

Arkaplan:rsnapshot(rsyncname__) yedekleme konumum var, /mnt/Backups/, bu dosyalar ~ 4.5TB (terra) içerdiğinden sistem (/) dosyalarını ararken baş ağrısına neden olur!

Ayrıca, /mnt/Vancouver, TB ana çalışma klasörüm, yedeklenmiş [/mnt/Backups/ ve /mnt/Vancouver/ fiziksel olarak (yedek olarak) ayrı sürücülere monte edilmiş].


Buradaki en iyi iki cevaptan ( find. Komutundaki bir dizini nasıl hariç tutabilirsiniz? ), Kabul edilen yanıtı kullanarak sistem dosyalarını aramanın, uyarılarla daha hızlı/ olduğunu buldum.

Bu

find / -path /mnt -Prune -o -name "*libname-server-2.a*" -print

bu dosyayı ~ 3-4 saniyede bulur; Bu

find / -name "*libname-server-2.a*" -not -path "/mnt/*"

hariç tutulan tüm dizinleri (tekrar yerleştirilen rsynctüm bağlı birimlerin anlık görüntüleri) içinde tekrarlamak için görünür (?), bu yüzden sonsuza kadar sürer. Çok fazla TB dosya aradığını farz ediyorum, bu yüzden kesintiye uğradı. Örneğin, bu aramayı "zaman" yapmaya çalışırsam (time find ...), çok fazla çıktı görüyorum - bu, findöğesinin "hariç tutulan" dizini derinden geçtiğini öne sürüyor:

...
find: ‘/mnt/Backups/rsnapshot_backups/monthly.0/snapshot_root/var/lib/udisks2’: Permission denied
...

Dışlanan dizinden (/mnt/) veya iç içe geçmiş bir yoldan (`/ mnt/Yedeklemeler) sonra bir eğik çizgi eklemek, sonsuza dek tekrar * aramasıyla sonuçlanır:

Yavaş:

find / -path /mnt/ -Prune -o -name "*libname-server-2.a*" -print
find / -path /mnt/Vancouver -Prune -o -name "*libname-server-2.a*" -print

"ÇÖZÜM"

İşte en iyi çözümler (hepsi saniyeler içinde çalıştırılıyor). Yine, dizin yapım

  • /: root
  • /mnt/Backups/: çoklu TB yedeklemeleri
  • /mnt/Vancouver/: multi-TB çalışma dizini (sıklıkla ayrı sürücüde /mnt/Backups yedeklenir)
  • /home/*: diğer bağlama noktaları/çalışan "sürücüler" (ör. /home/victoria = ~)

Sistem dosyaları (/):

Bir sistem dosyasını hızlıca bulmak için /mnt (not/mnt/ veya /mnt/Backups, ...) hariç tutun:

$ find / -path /mnt -Prune -o -name "*libname-server-2.a*" -print
/usr/lib/libname-server-2.a

bu dosyayı ~ 3-4 saniye içinde bulur.

Sistem dışı dosyalar:

Örneğin. bir dosyayı iki çalışma "sürücüm", /mnt/Vancouver/ ve/veya /home/victoria/ 'mdan birinde hızlıca bulmak için).

$ find /mnt/Vancouver/ -name "*04t8ugijrlkj.jpg"
/mnt/Vancouver/temp/04t8ugijrlkj.jpg

$ find /home/victoria -iname "*Untitled Document 1"
/home/victoria/backups/shortcuts.bak.2016.11.02/Untitled Document 1
/home/victoria/Untitled Document 1

Yedekler:

Örneğin. silinen bir dosyayı bulmak için, saatlik/günlük/haftalık/aylık yedeklemelerimden birinde).

$ find /mnt/Backups/rsnapshot_backups/daily.0 -name "*04t8ugijrlkj.jpg"
/mnt/Backups/rsnapshot_backups/daily.0/snapshot_root/mnt/Vancouver/temp/04t8ugijrlkj.jpg 

Aside: Komutun sonuna -print eklemek, dışlanan dizinin çıktısını bastırır:

$ find / -path /mnt -Prune -o -name "*libname-server-2.a*"
/mnt
/usr/lib/libname-server-2.a

$ find / -path /mnt -Prune -o -name "*libname-server-2.a*" -print
/usr/lib/libname-server-2.a
$ 
1
Victoria Stuart

Bunun tüm Edge vakalarını kapsayacağından emin değilim, ancak aşağıdakiler oldukça açık ve denemesi kolay olacaktır:

ls -1|grep -v -e ddl -e docs| xargs rm -rf

Bu, tüm dosyaları/dizinleri geçerli 'excd' ddls 've' docs 'dizinlerinden kaldırmalıdır.

0
Arnab

Arama dizinleri desen içeriyorsa (benim durumumda çoğu zaman); basitçe aşağıdaki gibi yapabilirsiniz:

find ./n* -name "*.tcl" 

Yukarıdaki örnekte; "n" ile başlayan tüm alt dizinlerde arama yapar.

0
Prince Bhanwra

FreeBSD kullanıcıları için:

 find . -name '*.js' -not -path '*exclude/this/dir*'
0
Richard Bartisek

Bu işe yarar çünkü find_ _ _ - desen "* foo *" için dosyalar:

find ! -path "dir1" ! -path "dir2" -name "*foo*"

ama yok DEĞIL eğer kullanmazsanız bir desen (findkullanmaz TEST dosya). Böylece findname__, eski değerlendirilen "true" & "false" havuzlarından faydalanmaz. Çalışmama örneği için yukarıdaki gösterime bakınız:

find ! -path "dir1" ! -path "dir2" -type f

Hiçbir findTEST! Herhangi bir desen eşleşmesi olmadan dosyaları bulmanız gerekiyorsa, -Prune kullanın. Ayrıca, Prune findkullanımıyla, eşleme yapmak yerine gerçekten bu dizinleri geçerken ya da eşleşmemesi daha iyi olur. Yani bu durumda şöyle bir şey kullanın:

find dir -not \( -path "dir1" -Prune \) -not \( -path "dir2" -Prune \) -type f

veya:

find dir -not \( -path "dir1" -o -path "dir2" -Prune \) -type f

Saygılarımızla

0
d0n

Bu sayfadaki önerileri buldum ve diğer pek çok sayfa Mac OS X sistemimde çalışmıyor. Ancak, benim için işe yarayan bir varyasyon buldum.

Buradaki ana fikir Macintosh HD'yi aramak, ancak çoğunlukla Time Machine yedekleri, görüntü yedekleri, takma hisse senetleri ve arşivler olan, ancak çoğu zaman pratik olmayan, hepsinin bağlantısını kesmek zorunda kalmadan tüm harici birimlerin arasında gezinmekten kaçının.

İşte "findit" olarak adlandırdığım çalışma betiğim.

#!/usr/bin/env bash
# inspired by http://stackoverflow.com/questions/4210042/exclude-directory-from-find-command Danile C. Sobral
# using special syntax to avoid traversing. 
# However, logic is refactored because the Sobral version still traverses 
# everything on my system

echo ============================
echo find - from cwd, omitting external volumes
date
echo Enter Sudo password if requested
Sudo find . -not \( \
-path ./Volumes/Archive -Prune -o \
-path ./Volumes/Boot\ OS\ X -Prune -o \
-path ./Volumes/C \
-path ./Volumes/Data -Prune -o \
-path ./Volumes/jas -Prune -o \
-path ./Volumes/Recovery\ HD -Prune -o \
-path ./Volumes/Time\ Machine\ Backups -Prune -o \
-path ./Volumes/SuperDuper\ Image -Prune -o \
-path ./Volumes/userland -Prune \
\) -name "$1" -print
date
echo ============================
iMac2:~ jas$

Çeşitli yollar harici arşiv birimleri, Time Machine, Virtual Machines, diğer bağlı sunucular vb. İle ilgilidir. Birim adlarından bazıları içinde boşluklar var.

İyi bir deneme çalıştırması "findit index.php" dir, çünkü bu dosya sistemimdeki birçok yerde var. Bu komut dosyasıyla, ana sabit sürücüyü aramak yaklaşık 10 dakika sürer. Bu dışlamalar olmadan, birkaç saat sürer.

0
Jeffrey Simon