Jak wykluczyć katalog w find. Komenda

Próbuję uruchomić findpolecenie dla wszystkich plików JavaScript, ale jak wykluczyć określony katalog?

Oto findkod, którego używamy.

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

Użyj -pruneprzełącznika. Na przykład, jeśli chcesz wykluczyć misckatalog, po prostu dodaj -path ./misc -prune -odo polecenia find:

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

Oto przykład z wieloma katalogami:

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

Tutaj wykluczamy dir1 , dir2 i dir3 , ponieważ w findwyrażeniach jest to działanie, które działa na podstawie kryteriów -path dir1 -o -path dir2 -o -path dir3(jeśli dir1 lub dir2 lub dir3 ), AND z type -d.

Dalsze działanie to -o printpo prostu wydrukuj.

Jeśli -pruneto nie zadziała, spowoduje to:

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

Uwaga: wymaga przejścia przez wszystkie niechciane katalogi.

Uważam, że łatwiej jest uzasadnić niż inne proponowane rozwiązania:

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

Ważna uwaga: ścieżki, które wpisujesz, -pathmuszą dokładnie pasować do tego find, co zostanie wydrukowane bez wykluczenia. Jeśli to zdanie myli po prostu upewnij się, aby korzystać z pełnej ścieżki przechodzące przez całą polecenia jak poniżej: . Zobacz notatkę [1], jeśli chcesz lepiej zrozumieć.find /full/path/ -not \( -path /full/path/exclude/this -prune \) ...

Wewnątrz \(i \)jest wyrażeniem, które będą pasować dokładnie build/external (patrz Ważna uwaga powyżej), i będzie, w przypadku sukcesu, unikać postępowy cokolwiek poniżej . Jest to następnie grupowane jako pojedyncze wyrażenie z nawiasem ucieczkowym i poprzedzone nim, -notco spowoduje findpominięcie wszystkiego, co pasowało do tego wyrażenia.

Można zapytać, czy dodanie -notnie spowoduje, że wszystkie inne pliki zostaną ukryte przez -pruneponowne pojawienie się, a odpowiedź brzmi „nie”. Sposób, w jaki -prunedziała to, że coś, że po jego osiągnięciu, pliki poniżej tego katalogu są stale ignorowane.

Wynika to z rzeczywistego przypadku użycia, w którym musiałem wywołać kompresor Yui w przypadku niektórych plików generowanych przez wintersmith, ale pomijać inne pliki, które należy przesłać w obecnej postaci.

Uwaga [1] : Jeśli chcesz wykluczyć /tmp/foo/bari uruchomisz wyszukiwanie w ten sposób find /tmp \(..., musisz to określić -path /tmp/foo/bar. Jeśli z drugiej strony tak się cd /tmp; find . \(...dzieje, musisz to określić -path ./foo/bar.

Widać tutaj pewne zamieszanie co do preferowanej składni do pomijania katalogu.

Opinia GNU

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

Ze strony podręcznika użytkownika GNU znajdź

Rozumowanie

-pruneprzestaje findschodzić do katalogu. Samo określenie -not -pathnadal będzie przechodzić do pominiętego katalogu, ale -not -pathbędzie fałszywe przy każdym findtestowaniu każdego pliku.

Problemy z -prune

-prune robi to, do czego jest przeznaczony, ale nadal są pewne rzeczy, o które musisz zadbać, używając go.

1. find drukuje przycięty katalog.

   • PRAWDA To zamierzone zachowanie, po prostu się do niego nie schodzi. Aby całkowicie nie wydrukować katalogu, użyj składni, która logicznie go pomija.

2. -prunedziała tylko -printbez żadnych innych działań.

   • NIE PRAWDA . -prunewspółpracuje z dowolną akcją oprócz -delete. Dlaczego to nie działa z usuwaniem? Aby -deletedziałać, find musi przechodzić przez katalog w kolejności DFS, ponieważ -deletenajpierw usunie liście, następnie rodziców liści itp. Ale aby określić, -pruneże ma to sens, findmusi trafić do katalogu i przestać go opuszczać, co wyraźnie nie ma sensu z włączaniem -depthlub -deletewyłączaniem.

Wydajność

Przygotowałem prosty test z trzema najwyżej ocenionymi odpowiedziami na to pytanie (zastąpione -printprzez, -exec bash -c 'echo $0' {} \;aby pokazać inny przykład działania). Wyniki są poniżej

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

Wniosek

Zarówno składnia f10bit, jak i składnia Daniela C. Sobrala trwały średnio 10–25 ms. Składnia GetFree , która nie korzysta -prune, zajęła 865 ms. Tak, jest to raczej skrajny przykład, ale jeśli zależy ci na czasie działania i robisz coś zdalnie intensywnego, powinieneś użyć -prune.

Uwaga : składnia Daniela C. Sobrala była lepsza z dwóch -prune; ale mocno podejrzewam, że jest to wynikiem pewnego buforowania, ponieważ zmiana kolejności, w której oba działały, dawała przeciwny wynik, podczas gdy wersja bez przycinania była zawsze najwolniejsza.

Skrypt testowy

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

To jedyny, który dla mnie działał.

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

Wyszukiwanie „MyFile” z wyłączeniem „Directory”. Podkreśl gwiazdy *.

Jedną z opcji byłoby wykluczenie wszystkich wyników zawierających nazwę katalogu z grep. Na przykład:

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

Wolę -notnotację ... jest bardziej czytelna:

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

Użyj opcji -prune. Coś w stylu:

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

Opcja „-type d -name proc -prune” szuka tylko katalogów o nazwie proc, które mają zostać wykluczone.
„-O” jest operatorem „LUB”.

-prunezdecydowanie działa i jest najlepszą odpowiedzią, ponieważ zapobiega zejściu do katalogu, który chcesz wykluczyć. -not -pathktóry nadal przeszukuje wykluczony katalog, po prostu nie drukuje wyniku, co może być problemem, jeśli wyłączonym katalogiem jest podłączony wolumin sieciowy lub użytkownik nie ma uprawnień.

Część trudna polega na tym, że findjest bardzo szczególna w kolejności argumentów, więc jeśli nie zrozumiesz ich poprawnie, twoje polecenie może nie działać. Kolejność argumentów jest na ogół taka:

find {path} {options} {action}

{path}: Najpierw umieść wszystkie argumenty związane ze ścieżką, np . -path './dir1' -prune -o

{options}: Odnoszę największy sukces, gdy stawiam -name, -iname, etcjako ostatnią opcję w tej grupie. Na przykład-type f -iname '*.js'

{action}: Będziesz chciał dodać -printpodczas korzystania-prune

Oto działający przykład:

# 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

To jest format, którego użyłem do wykluczenia niektórych ścieżek:

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

Użyłem tego, aby znaleźć wszystkie pliki spoza ścieżek „. *”:

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

Podejście -path -prune działa również z symbolami wieloznacznymi na ścieżce. Oto instrukcja find, która znajdzie katalogi dla serwera git obsługującego wiele repozytoriów git z pominięciem wewnętrznych katalogów git:

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

Aby wykluczyć wiele katalogów:

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

Aby dodać katalogi, dodaj -o -path "./dirname/*":

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

Ale może powinieneś użyć wyrażenia regularnego , jeśli istnieje wiele katalogów do wykluczenia.

Jest wiele dobrych odpowiedzi, zajęło mi trochę czasu, aby zrozumieć, do czego służy każdy element polecenia i jaka jest logika.

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

find rozpocznie wyszukiwanie plików i katalogów w bieżącym katalogu, stąd find ..

-oOpcja oznacza logiczną OR i oddziela dwie części komendy:

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

Każdy katalog lub plik, który nie jest katalogiem ./misc, nie przejdzie pierwszego testu -path ./misc. Ale zostaną przetestowane pod kątem drugiego wyrażenia. Jeśli ich nazwa odpowiada wzorowi *.txt, drukowane są z powodu -printopcji.

Gdy find osiągnie katalog ./misc, katalog ten spełnia tylko pierwsze wyrażenie. Tak więc -pruneopcja zostanie zastosowana do niego. Mówi poleceniu find, aby nie eksplorowało tego katalogu. Tak więc żaden plik lub katalog w ./misc nie będzie nawet eksplorowany przez find, nie będzie testowany względem drugiej części wyrażenia i nie zostanie wydrukowany.

Dla działającego rozwiązania (testowane na Ubuntu 12.04 (Precise Pangolin)) ...

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

wyszuka pliki MP3 w bieżącym folderze i podfolderach, z wyjątkiem podfolderu dir1.

Posługiwać się:

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

... aby wykluczyć katalog 1 i katalog 2

dobrą sztuczką pozwalającą uniknąć drukowania przyciętych katalogów jest użycie -print(działa -execrównież) po prawej stronie -orpo -prune. Na przykład, ...

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

wydrukuje ścieżkę wszystkich plików w bieżącym katalogu z rozszerzeniem `.j2", pomijając wszystkie ukryte katalogi. Schludnie. Ale wydrukuje również wydruk pełną ścieżkę każdego katalogu, który pomija, jak wspomniano powyżej. Jednak następujące nie, ...

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

ponieważ logicznie jest ukryte -andza -inameoperatorem i przed nadrukiem. To wiąże go z prawą częścią -orzdania ze względu na logiczną kolejność operacji i asocjatywność. Ale doktorzy mówią, że jest ukryty, -printjeśli on (lub którykolwiek z jego kuzynów ... -print0itd.) Nie jest określony. Dlaczego więc nie lewa część -orwydruku? Najwyraźniej (i nie zrozumiałem tego po pierwszym przeczytaniu strony podręcznika), to prawda, jeśli nie ma nic, tylko operatory opisowe najwyraźniej nic nie zrobiłyby, więc myślę, że ma to sens. Jak wspomniano powyżej, to wszystko również działa , więc poniższe zawiera pełną listę każdego pliku z pożądanym rozszerzeniem, ale nie wyświetla pierwszego poziomu każdego ukrytego katalogu, ...-print operacji w stylu -lub wyrażonej w dowolnej klauzuli, wszystkie te ukryte logiczne znikają i dostajesz tylko to, co ty sprecyzować. Szczerze mówiąc, wolałbym to na odwrót, ale potem-exec gdziekolwiek, w którym to przypadku, -print jest logicznie traktowane wokół tak, że wszystko zostanie wydrukowany. Jeśli nawet JEDENprintfind-execls -la

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

Dla mnie (i innych w tym wątku) findskładnia robi się dość barokowa dość szybko, więc zawsze rzucam pareny, aby upewnić się, że wiem, co się z tym wiąże, więc zwykle tworzę makro dla zdolności pisania i formuję wszystkie takie stwierdzenia jak. ..

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

Trudno się pomylić, ustanawiając świat na dwie części w ten sposób. Mam nadzieję, że to pomaga, choć wydaje się mało prawdopodobne, aby ktokolwiek przeczytał ponad 30. odpowiedź i zagłosował, ale można mieć nadzieję. :-)

Aby to zrobić, możesz użyć opcji przycinania. Jak na przykład:

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

Lub odwrotna opcja grep „grep -v”:

find -iname example.com | grep -v beta

Możesz znaleźć szczegółowe instrukcje i przykłady w Linuxie polecenie find wyklucza wyszukiwanie katalogów .

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

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

wydaje się działać tak samo jak

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

i łatwiej zapamiętać IMO.

TLDR: zrozum katalogi główne i dostosuj wyszukiwanie z tego miejsca, korzystając z tej -path <excluded_path> -prune -oopcji. Nie dołączaj końcowego/ końca na końcu wykluczonej ścieżki.

Przykład:

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

Aby skutecznie korzystać z find, uważam, że konieczne jest dobre zrozumienie struktury katalogów systemu plików. Na moim komputerze domowym mam dyski twarde o pojemności TB, z kopią zapasową około połowy tej zawartości przy użyciu rsnapshot(tj rsync.). Chociaż tworzy kopię zapasową na fizycznie niezależnym (zduplikowanym) dysku, jest on montowany w katalogu systemowym root ( /) /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/Katalog zajmuje obecnie ~ 2,9 TB, z ~ 60m plików i folderów; po prostu przeglądanie tych treści wymaga czasu:

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

Dlatego za każdym razem, gdy muszę wyszukać plik na mojej /(głównej) partycji, muszę poradzić sobie (jeśli to możliwe) przechodząc przez moją partycję kopii zapasowych.

PRZYKŁADY

Wśród podejść, które są różnie sugerowane w tym wątku ( Jak wykluczyć katalog w poleceniu find. ), Stwierdzam, że wyszukiwania przy użyciu zaakceptowanej odpowiedzi są znacznie szybsze - z zastrzeżeniami.

Rozwiązanie 1

Powiedzmy, że chcę znaleźć plik systemowy libname-server-2.a, ale nie chcę przeszukiwać rsnapshotkopii zapasowych. Aby szybko znaleźć plik systemowy, użyj wykluczyć ścieżkę /mnt(czyli zastosowanie /mnt, nie /mnt/, albo /mnt/Backups, albo ...):

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

... znajduje ten plik w ciągu kilku sekund, a to trwa znacznie dłużej (wydaje się, że powtarza się we wszystkich „wykluczonych” katalogach):

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

Rozwiązanie 2

Inne rozwiązanie oferowane w tym wątku ( SO # 4210042 ) również działa słabo:

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

PODSUMOWANIE | WNIOSKI

Zastosuj podejście przedstawione w „ Rozwiązaniu 1 ”

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

to znaczy

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

zauważając, że za każdym razem, gdy dodajesz znak końcowy /do wykluczonej ścieżki, findpolecenie rekurencyjnie wchodzi (wszystkie te) /mnt/*katalogi - które w moim przypadku, z powodu /mnt/Backups/rsnapshot_backups/*podkatalogów, zawierają dodatkowo ~ 2,9 TB plików do przeszukania! Nie dołączając znaku /końca, wyszukiwanie powinno zakończyć się niemal natychmiast (w ciągu kilku sekund).

... -not -path <exclude path> ...Wydaje się, że „Rozwiązanie 2” ( ) rekurencyjnie przeszukuje wykluczone katalogi - nie zwraca wykluczonych dopasowań, ale niepotrzebnie pochłania ten czas wyszukiwania.

Wyszukiwanie w ramach tych rsnapshotkopii zapasowych:

Aby znaleźć plik w jednej z moich godzinnych / dziennych / tygodniowych / miesięcznych rsnapshotkopii zapasowych):

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

Z wyłączeniem zagnieżdżonego katalogu:

Tutaj chcę wykluczyć katalog zagnieżdżony, np. /mnt/Vancouver/projects/ie/claws/data/*Podczas wyszukiwania z /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

Na bok: Dodanie -printna końcu polecenia pomija wydruk wykluczonego katalogu:

$ 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

Możesz także użyć wyrażeń regularnych, aby włączyć / wyłączyć niektóre pliki / katalogi wyszukiwania, używając czegoś takiego:

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

To da ci tylko wszystkie pliki js, vue, css itp., Ale z wyłączeniem wszystkich plików w folderach node_modulesi vendor.

Użyłem, findaby dostarczyć listę plików xgettexti chciałem pominąć konkretny katalog i jego zawartość. Próbowałem wielu -pathkombinacji w połączeniu z, -pruneale nie byłem w stanie w pełni wykluczyć katalogu, który chciałem zniknąć.

Chociaż byłem w stanie zignorować zawartość katalogu, który chciałem zignorować, zwróciłem findsam katalog jako jeden z wyników, co spowodowałoxgettext awarię w wyniku (nie akceptuje katalogów, tylko pliki).

Moim rozwiązaniem było po prostu grep -vpominięcie katalogu, którego nie chciałem w wynikach:

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

Bez względu na to, czy istnieje argument przemawiający za findtym, czy będzie on działał w 100%, nie mogę powiedzieć na pewno. Korzystanie grepbyło szybkim i łatwym rozwiązaniem po pewnym bólu głowy.

Żadna z poprzednich odpowiedzi nie jest dobra na Ubuntu. Spróbuj tego:

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

Znalazłem to tutaj

Jest to odpowiednie dla mnie na komputerze Mac:

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

Wyklucza vendori app/cachereżimem szukanej nazwy z przyrostkiem php.

Dla tych z was w starszych wersjach UNIX, którzy nie mogą używać -path lub -not

Testowane na SunOS 5.10 bash 3.2 i SunOS 5.11 bash 4.4

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

how-to-use-prune-option-of-find-in-sh to doskonała odpowiedź Laurence Gonsalves na temat tego, jak -prunedziała.

A oto ogólne rozwiązanie:

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

Aby uniknąć /path/to/seach/wielokrotnego pisania , zawiń findw pushd .. popdparę.

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

Dla tego, czego potrzebowałem, działało to tak: znajdowanie landscape.jpgna wszystkich serwerach zaczynających się od katalogu głównego i wykluczanie wyszukiwania w /varkatalogu:

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

find / -maxdepth 1 -type dwymienia wszystkie d irectories w/

grep -v /var wyklucza `/ var 'z listy

xargs -I '{}' find '{}' -name landscape.jpgwykonaj dowolne polecenie, na przykład finddla każdego katalogu / wyniku z listy

Działa następujące polecenie:

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

Jeśli masz problem ze znalezieniem, użyj -D treeopcji, aby wyświetlić informacje analizy wyrażeń.

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

Lub -D all, aby wyświetlić wszystkie informacje o wykonaniu.

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

Znalazłem nazwę funkcji w plikach źródłowych C wykluczających * .o i wykluczających * .swp i wykluczających (nie zwykły plik) i wykluczających dane wyjściowe katalogu za pomocą tego polecenia:

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

Lepiej użyj execakcji niż forpętli:

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

exec ... '{}' ... '{}' \;Będzie wykonywana raz dla każdego pliku pasującego, zastępując szelki '{}'z aktualną nazwą pliku.

Zauważ, że nawiasy klamrowe są ujęte w pojedyncze znaki cudzysłowu, aby chronić je przed interpretacją jako interpunkcji skryptu powłoki ^* .

Notatki

^* W sekcji Przykłady find (GNU findutils) 4.4.2manualu

Próbowałem polecenia powyżej, ale żaden z tych, którzy używają „-prune” nie działa dla mnie. W końcu wypróbowałem to za pomocą poniższego polecenia:

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