Bulma dizini nasıl hariç tutulur. komuta

findTüm JavaScript dosyaları için bir komut çalıştırmaya çalışıyorum , ancak belirli bir dizini nasıl hariç tutabilirim?

İşte kullandığımız findkod.

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

-pruneAnahtarı kullanın . Örneğin, miscdizini hariç tutmak istiyorsanız -path ./misc -prune -ofind komutunuza a 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 dir1 , dir2 ve dir3'ü hariç tutuyoruz , çünkü findifadelerde bu kriterler -path dir1 -o -path dir2 -o -path dir3( dir1 veya dir2 veya dir3 ise ) ve ( ve) ile hareket eden bir eylemdir type -d.

Diğer eylem -o print, sadece yazdırmak.

Eğer -prunesizin için çalışmaz, bu yapacaktır:

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

Uyarı: istenmeyen tüm dizinlerin geçişini gerektirir.

Aşağıdakilerin akıl yürütmesini diğer önerilen çözümlerden 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: Sonrasında yazdığınız yollar , hariç tutulmadan yazdırılacak yollarla -pathtam olarak eşleşmelidir find. Bu cümle sadece yapmak karıştırır Eğer emin dışarı aracılığıyla tam yollarını kullanmaya bütün böyle komuta: . Daha iyi bir anlayış istiyorsanız not [1] 'e bakınız.find /full/path/ -not \( -path /full/path/exclude/this -prune \) ...

İçeride \(ve tam olarak\) eşleşecek bir ifadedir (yukarıdaki önemli nota bakın) ve başarı üzerine aşağıdaki herhangi bir şeyden kaçınmaktan kaçınacaktır . Bu daha sonra kaçan parantez tek bir ifade olarak gruplandırılmış ve öneki hangi yapacak o ifadesinin eşleştiği edildi atlama şey. build/external-notfind

Ekleme, -nottüm diğer dosyaların -pruneyeniden görünerek gizlenip gizlenmeyeceğini sorabilir ve yanıt hayırdır. Çalışma şekli -prune, ulaşıldıktan sonra bu dizinin altındaki dosyaların kalıcı olarak yoksayıldığı her şeydir.

Bu, wintersmith tarafından oluşturulan bazı dosyalarda yui-kompresör çağırmak, ancak olduğu gibi gönderilmesi gereken diğer dosyaları dışarıda bırakmak için gereken gerçek bir kullanım durumundan geliyor.

Not [1] : Hariç tutmak istiyorsanız /tmp/foo/barve " find /tmp \(..." gibi bulmayı çalıştırıyorsanız , belirtmeniz gerekir -path /tmp/foo/bar. Öte yandan böyle bulursanız cd /tmp; find . \(...belirtmeniz gerekir -path ./foo/bar.

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

GNU Görüşü

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

GNU bulma kılavuzu sayfasından

muhakeme

-prunefindbir dizine inmeyi durdurur . Sadece belirtmek -not -pathyine de atlanan dizine inecektir , ancak her dosyayı test -not -pathettiğinde yanlış olacaktır find.

İle ilgili sorunlar -prune

-prune istediği şeyi yapar, ancak yine de kullanırken dikkat etmeniz gereken bazı şeyler vardır.

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

   • DOĞRU Bu amaçlanan davranış, sadece onun içine inmiyor. Dizinin tamamen yazdırılmasını önlemek için dizini mantıksal olarak ihmal eden bir sözdizimi kullanın.

2. -pruneyalnızca -printbaşka eylemlerle çalışır ve hiçbir işlem yapılmaz.

   • DOĞRU DEĞİL . -prunedışında herhangi bir eylemle çalışır -delete. Silme ile neden çalışmıyor? İçin -deleteişe, çünkü DFS sırayla dizin çapraz geçiş için ihtiyaçlarını bulmak -deleteilk ... Ama belirtmek için yaprak, yapraklar, vb sonra anne silecektir -prune, yapmak duygusuna findbunu inen bir dizin ve durak vurmak ihtiyaçları, hangi açık -depthya da -deleteaçık bir anlam ifade etmiyor .

Verim

Bu soruya en çok oylanan üç cevap için basit bir test oluşturdum ( başka bir eylem örneği göstermek için -printile değiştirildi -exec bash -c 'echo $0' {} \;). 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ç

Hem f10bit'in sözdizimi hem de Daniel C. Sobral'ın sözdizimi ortalama 10-25ms sürdü. GetFree'nin kullanmayan sözdizimi-prune 865 ms sürdü. Yani, evet, bu oldukça uç bir örnektir, ancak çalışma süresini önemsiyorsanız ve uzaktan yoğun bir şey yapıyorsanız kullanmalısınız -prune.

Not Daniel C. Sobral'ın sözdizimi iki -prunesözdiziminden daha iyi performans gösterdi ; ancak, bunun, budama olmayan sürüm her zaman en yavaş olduğu halde, ikisinin tersi sonuçla sonuçlandığı sırayı değiştirmek olarak bazı önbelleğe almanın bir sonucu olduğundan şüpheliyim.

Test Betiği

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

Benim için çalışan tek kişi bu.

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

"Dizin" hariç "Dosyam" aranıyor. Yıldızlara vurgu yapın *.

Seçeneklerden biri grep ile dizin adını içeren tüm sonuçları hariç tutmak olabilir. Örneğin:

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

-notGösterimi tercih ederim ... daha okunabilir:

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

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

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

'-Type d -name proc -prune' yalnızca hariç tutulacak proc adlı dizinleri arar.
'-O' bir 'VEYA' operatörüdür.

-pruneKesinlikle işe yarar ve en iyi cevaptır çünkü dışlamak istediğiniz direk içine inmeyi önler. -not -pathbu da hariç tutulan dizini ararsa, sonucu yazdırmaz; hariç tutulan dizin ağ birimine bağlıysa veya izinleriniz yoksa sorun olabilir.

Zor kısmı, findargümanların sırası hakkında çok özeldir, bu yüzden eğer onları doğru bulmazsanız, komutunuz çalışmayabilir. Argümanların sırası genellikle şöyledir:

find {path} {options} {action}

{path}: Yolla ilgili tüm argümanları önce koyun, örneğin . -path './dir1' -prune -o

{options}: -name, -iname, etcBu grupta son seçenek olarak en başarılı olanı seçtim . Örneğin-type f -iname '*.js'

{action}: -printKullanırken eklemek isteyeceksiniz-prune

İş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

Bu, bazı yolları hariç tutmak için kullandığım biçim:

$ 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 "./*/.*"

-Path-prune yaklaşımı da yoldaki joker karakterlerle çalışır. Git dahili dizinlerini dışarıda bırakarak çoklu git depoları sunan bir git sunucusunun dizinlerini bulan bir find deyimi:

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 \)  

Birden çok dizini hariç tutmak için:

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

Dizin eklemek için şunu ekleyin -o -path "./dirname/*":

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

Ancak , hariç tutulacak çok dizin varsa, normal bir ifade kullanmalısınız .

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

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

find, geçerli dizindeki dosyaları ve dizinleri bulmaya başlayacaktır. find . .

-oSeçenek mantıksal VEYA açılımı ve komuta iki bölümden ayırır:

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

./Misc dizini olmayan herhangi bir dizin veya dosya ilk sınamayı geçemez -path ./misc. Ancak ikinci ifadeye karşı test edilecektir. *.txtAdları, yazdırıldıkları desene karşılık geliyorsa ,-print seçenek .

Find ./misc dizinine ulaştığında, bu dizin yalnızca ilk ifadeyi karşılar. Böylece -pruneseçenek ona uygulanacaktır. Bu yapmak için bulma komutu söyler değil o dizini keşfetmek. Bu nedenle ./misc dosyasındaki herhangi bir dosya veya dizin find ile araştırılmayacak, ifadenin ikinci kısmına karşı test edilmeyecek ve yazdırılmayacaktır.

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

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

dir1 alt klasörü hariç, geçerli klasördeki ve alt klasörlerdeki MP3 dosyalarını arayacaktır.

kullanın:

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

... dir1 VE dir2'yi hariç tutmak için

budanmış dizinleri baskı kaçınmak için iyi bir hüner kullanımına olan -print(için çalışmalar -execsağ tarafında sonra sıra) -orsonrasÖ -prune. Örneğin, ...

find . -path "*/.*" -prune -or -iname "*.j2"

geçerli dizinin altındaki tüm dosyaların yolunu, tüm gizli dizinleri atlayarak `.j2" uzantısıyla yazdıracaktır. takip etmez, ...

find . -path "*/.*" -prune -or -iname "*.j2" -print

çünkü mantıksal olarak operatörden -andsonra -inameve -print'ten önce bir gizli var . Bu, -orboolean işlem sırası ve ilişkilendirilebilirlik nedeniyle maddeyi sağ tarafına bağlar . Ancak dokümanlar -print, (veya kuzenlerinden herhangi biri ... -print0vb.) Belirtilmezse gizli olduğunu söylüyor . Peki neden -orbaskının sol kısmı değil ? Görünüşe göre (ve bunu ilk adam sayfasını okuduğumdan anlamadım), eğer -print-veya herhangi bir -execyerde yoksa, bu durumda, -baskı mantıksal olarak her şeyin yazdırılacağı şekilde serpilirse doğrudur . Eğer BİR bileprint herhangi bir cümlede herhangi bir stil tarzı işlem , tüm bu gizli mantıksal olanlar gider ve sadece sizin belirttiğinizi alırsınız. Şimdi açıkçası, bunu başka bir şekilde tercih edebilirdim, ama sonra birfindsadece açıklayıcı operatörlerle görünüşte hiçbir şey yapmazdı, bu yüzden sanırım olduğu gibi mantıklı. Yukarıda belirtildiği gibi, bu -execda aynı şekilde çalışır, bu nedenle aşağıdakiler ls -la, istenen uzantıya sahip her dosya için tam bir liste verir , ancak her gizli dizinin ilk düzeyini listelemez, ...

find . -path "*/.*" -prune -or -iname "*.j2" -exec ls -la -- {} +

Benim için (ve bu iş parçacığındaki diğerleri), findsözdizimi oldukça hızlı bir şekilde baroklaşıyor, bu yüzden her zaman neye bağlandığımdan emin olmak için parens atıyorum, bu yüzden genellikle tip yeteneği için bir makro oluşturuyorum ve tüm bu ifadeleri oluşturuyorum. ..

find . \( \( ... description of stuff to avoid ... \) -prune \) -or \
\( ... description of stuff I want to find ... [ -exec or -print] \)

Dünyayı bu şekilde iki parçaya ayırarak yanlış gitmek zor. Umarım bu yardımcı olur, ancak herkesin 30 + th cevabını okuması ve oy vermesi olası görünmese de, umarım biri olabilir. :-)

Bunu elde etmek için budama 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

Linux find komutunda ayrıntılı talimatlar ve örnekler bulabilirsiniz .

find . -name '*.js' -\! -name 'glob-for-excluded-dir' -prune

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

gibi çalışıyor gibi görünüyor

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

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

TLDR:-path <excluded_path> -prune -o seçeneği kullanarak kök dizinlerinizi anlayın ve aramanızı oradan özelleştirin . Sondaki noktayı dahil etme/Dışlanan yolun sonuna .

Misal:

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

Etkili bir şekilde kullanmak için findben dosya sistemi dizin yapısı hakkında iyi bir anlayış olması gerektiğine inanıyorum. Ev bilgisayarımda çoklu TB sabit disklerim var, içeriğin yaklaşık yarısı rsnapshot(yani rsync) kullanılarak yedekleniyor . Fiziksel olarak bağımsız (yinelenen) bir sürücüye yedeklense de, sistem root ( /) dizinimin altına monte edilir /mnt/Backups/rsnapshot_backups/::

/mnt/Backups/
└── rsnapshot_backups/
    ├── hourly.0/
    ├── hourly.1/
    ├── ...
    ├── daily.0/
    ├── daily.1/
    ├── ...
    ├── weekly.0/
    ├── weekly.1/
    ├── ...
    ├── monthly.0/
    ├── monthly.1/
    └── ...

/mnt/Backups/rsnapshot_backups/Dizin şu anda 60M dosya ve klasörler ~ ile ~ 2.9 TB kaplar; basitçe bu içerikleri taramak zaman alır:

## As sudo (#), to avoid numerous "Permission denied" warnings:

time find /mnt/Backups/rsnapshot_backups | wc -l
60314138    ## 60.3M files, folders
34:07.30    ## 34 min

time du /mnt/Backups/rsnapshot_backups -d 0
3112240160  /mnt/Backups/rsnapshot_backups    ## 3.1 TB
33:51.88    ## 34 min

time rsnapshot du    ## << more accurate re: rsnapshot footprint
2.9T    /mnt/Backups/rsnapshot_backups/hourly.0/
4.1G    /mnt/Backups/rsnapshot_backups/hourly.1/
...
4.7G    /mnt/Backups/rsnapshot_backups/weekly.3/
2.9T    total    ## 2.9 TB, per sudo rsnapshot du (more accurate)
2:34:54          ## 2 hr 35 min

Bu nedenle, /(kök) bölümümde bir dosya aramam gerektiğinde, yedekler bölümümü geçerek (mümkünse kaçınmalıyım) uğraşmam gerekir.

ÖRNEKLER

Bu iş parçacığında önerilen çeşitli yaklaşımlar arasında ( find. Komutunda bir dizin nasıl hariç tutulur), kabul edilen yanıtı kullanan aramaların çok daha hızlı olduğunu görüyorum - uyarılar.

Çözüm 1

Diyelim ki sistem dosyasını bulmak istiyorum libname-server-2.a, ancak rsnapshotyedeklemelerimi aramak istemiyorum . Hızlı bir sistem dosyasını bulmak için, yol hariç kullanmak /mnt(yani kullanım /mntdeğil /mnt/, ya /mnt/Backups, ya ...):

## As sudo (#), to avoid numerous "Permission denied" warnings:

time find / -path /mnt -prune -o -name "*libname-server-2.a*" -print
/usr/lib/libname-server-2.a
real    0m8.644s              ## 8.6 sec  <<< NOTE!
user    0m1.669s
 sys    0m2.466s

## As regular user (victoria); I also use an alternate timing mechanism, as
## here I am using 2>/dev/null to suppress "Permission denied" warnings:

$ START="$(date +"%s")" && find 2>/dev/null / -path /mnt -prune -o \
    -name "*libname-server-2.a*" -print; END="$(date +"%s")"; \
    TIME="$((END - START))"; printf 'find command took %s sec\n' "$TIME"
/usr/lib/libname-server-2.a
find command took 3 sec     ## ~3 sec  <<< NOTE!

... bu dosyayı birkaç saniye içinde bulur, ancak bu işlem çok daha uzun sürer (tüm "hariç tutulan" dizinlerde yineleniyor gibi görünür):

## As sudo (#), to avoid numerous "Permission denied" warnings:

time find / -path /mnt/ -prune -o -name "*libname-server-2.a*" -print
find: warning: -path /mnt/ will not match anything because it ends with /.
/usr/lib/libname-server-2.a
real    33m10.658s            ## 33 min 11 sec (~231-663x slower!)
user    1m43.142s
 sys    2m22.666s

## As regular user (victoria); I also use an alternate timing mechanism, as
## here I am using 2>/dev/null to suppress "Permission denied" warnings:

$ START="$(date +"%s")" && find 2>/dev/null / -path /mnt/ -prune -o \
    -name "*libname-server-2.a*" -print; END="$(date +"%s")"; \
    TIME="$((END - START))"; printf 'find command took %s sec\n' "$TIME"
/usr/lib/libname-server-2.a
find command took 1775 sec    ## 29.6 min

Çözüm 2

Bu konuda sunulan diğer çözüm ( SO # 4210042 ) de kötü bir performans sergiliyor:

## As sudo (#), to avoid numerous "Permission denied" warnings:

time find / -name "*libname-server-2.a*" -not -path "/mnt"
/usr/lib/libname-server-2.a
real    33m37.911s            ## 33 min 38 sec (~235x slower)
user    1m45.134s
 sys    2m31.846s

time find / -name "*libname-server-2.a*" -not -path "/mnt/*"
/usr/lib/libname-server-2.a
real    33m11.208s            ## 33 min 11 sec
user    1m22.185s
 sys    2m29.962s

ÖZET | SONUÇLAR

" Çözüm 1 " de gösterilen yaklaşımı kullanın

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

yani

... -path <excluded_path> -prune -o ...

izleyenleri /hariç tutulan yola eklediğinizde, findkomut daha sonra (tüm bu) /mnt/*dizinlere özyineli olarak girer - ki bu durumda, /mnt/Backups/rsnapshot_backups/*alt dizinler nedeniyle ek olarak aramak için ~ 2.9 TB dosya içerir! Bir iz ekleyemediğinizde /, arama neredeyse anında (saniyeler içinde) tamamlanmalıdır.

"Çözüm 2" ( ... -not -path <exclude path> ...) de, hariç tutulan dizinler arasında özyineli olarak arama yapıyor gibi görünüyor - hariç tutulan eşleşmeleri döndürmüyor, ancak bu arama süresini gereksiz yere tüketiyor.

Bu rsnapshotyedekler içinde arama :

Saatlik / günlük / haftalık / aylık rsnapshotyedeklemelerimden birinde dosya bulmak için ):

$ START="$(date +"%s")" && find 2>/dev/null /mnt/Backups/rsnapshot_backups/daily.0 -name '*04t8ugijrlkj.jpg'; END="$(date +"%s")"; TIME="$((END - START))"; printf 'find command took %s sec\n' "$TIME"
/mnt/Backups/rsnapshot_backups/daily.0/snapshot_root/mnt/Vancouver/temp/04t8ugijrlkj.jpg
find command took 312 sec   ## 5.2 minutes: despite apparent rsnapshot size
                            ## (~4 GB), it is in fact searching through ~2.9 TB)

Yuvalanmış bir dizini hariç tutma:

Burada, örneğin /mnt/Vancouver/projects/ie/claws/data/*arama yaparken iç içe bir dizini hariç tutmak istiyorum /mnt/Vancouver/projects/:

$ time find . -iname '*test_file*'
./ie/claws/data/test_file
./ie/claws/test_file
0:01.97

$ time find . -path '*/data' -prune -o -iname '*test_file*' -print
./ie/claws/test_file
0:00.07

Kenara:-print Komutun sonuna eklemek , hariç tutulan 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

Ayrıca, aramanıza bazı dosyaları / dizinleri dahil etmek / hariç tutmak için normal ifadeleri aşağıdaki gibi bir şey kullanarak da kullanabilirsiniz:

find . -regextype posix-egrep -regex ".*\.(js|vue|s?css|php|html|json)$" -and -not -regex ".*/(node_modules|vendor)/.*" 

Bu size yalnızca js, vue, css vb. Dosyaları verir ancak node_modulesve vendorklasörlerindeki tüm dosyaları hariç tutar .

findDosyaların bir listesini sağlamak için kullanıyordum xgettextve belirli bir dizini ve içeriğini atlamak istedim. -pathKombine ile birçok permütasyon denedim -pruneama tamamen istediğim dizini hariç tutamadım.

Yoksayılmasını istediğim dizinin içeriğini görmezden gelebilmeme rağmen find, dizinin kendisini sonuçlardan biri olarak döndürdü.xgettext olarak çökmeye oldu (dizinleri kabul etmiyor; sadece dosyalar).

Benim çözüm sadece grep -vsonuçlarda istemediğim dizini atlamak için kullanmak oldu:

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

Bunun find% 100 işe yarayacağına dair bir argüman olup olmadığı kesin olarak söyleyemem. Kullanılması grepbazı baş ağrısı sonra hızlı ve kolay bir çözüm oldu.

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

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

Bu bulduk burada

Bu Mac'te benim için uygundur:

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

Eklenen arama adını hariç tutar vendorve yönlendirir .app/cachephp

UNIX'in eski sürümlerinde -path veya -not kullanamayanlarınız için

SunOS 5.10 bash 3.2 ve SunOS 5.11 bash 4.4 üzerinde test edilmiştir

find . -type f -name "*" -o -type d -name "*excluded_directory*" -prune -type f

nasıl kullanılır-buda-bul-in-sh seçeneği , Laurence Gonsalves'in nasıl -pruneçalıştığı konusunda 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/Birden çok kez yazmaktan kaçınmak için find, bir pushd .. popdçifti 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

Ihtiyacım ne için landscape.jpg, kökten başlayarak ve /vardizindeki arama hariç tüm sunucu bulma, böyle çalıştı :

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

find / -maxdepth 1 -type diçindeki tüm d dizinleri listeler/

grep -v /var / var 'i listeden hariç tutar

xargs -I '{}' find '{}' -name landscape.jpgfindlisteden her dizin / sonuç gibi herhangi bir komutu yürütün

Aşağıdaki komutlar çalışır:

find . -path ./.git -prune -o -print

Bulmayla ilgili bir sorununuz varsa -D tree, ifade analizi bilgilerini görüntüleme seçeneğini kullanın.

find -D tree . -path ./.git -prune -o -print

Veya, -D alltüm yürütme bilgilerini görmek için.

find -D all . -path ./.git -prune -o -print

C kaynak dosyalarında işlev adını * .o ve * .swp ve * (normal dosya değil) hariç tut ve bu komutla dir çıktısını hariç tuttum:

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

execEylemi fordöngüden daha iyi kullanın :

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

exec ... '{}' ... '{}' \;Parantez yerine her eşleştirme dosyası için bir kez çalıştırılacaktır '{}'geçerli dosya adı ile.

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

notlar

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

Yukarıdaki komutu denedim, ancak "-prune" kullananların hiçbiri benim için çalışmıyor. Sonunda bunu aşağıdaki komutla denedim:

find . \( -name "*" \) -prune -a ! -name "directory"