Jak wykluczyć katalog w find. dowództwo

Jeśli -prune nie zadziała dla ciebie, to:

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

Uważam, że następujące łatwiejsze do rozumowania niż inne proponowane rozwiązania:

find build -not \( -path build/external -prune \) -name \*.js

To pochodzi z rzeczywistego przypadku użycia, w którym musiałem wywołać yui-compressor na niektórych plikach generowanych przez wintersmith, ale pominąć inne pliki, które muszą być wysłane tak, jak jest.

Wewnątrz \( i \) jest wyrażenie, które będzie pasowało dokładnie. build/external ( będzie Nie pasował, jeśli zrobiłeś find ./build, na przykład -- musisz zmienić go na ./build/external w takim przypadku), i będzie, w przypadku sukcesu, unikaj przechodzenia przez cokolwiek poniżej. Jest to następnie zgrupowane jako pojedyncze wyrażenie z nawiasem ucieczki i poprzedzone {[7] } , co spowoduje, że find pominie wszystko, co zostało dopasowane do tego wyrażenia.

Można zapytać, czy dodanie -not nie spowoduje, że wszystkie inne pliki ukryte przez -prune pojawią się ponownie, a odpowiedź brzmi nie. Sposób działania {[10] } polega na tym, że wszystko, co po jego osiągnięciu, pliki znajdujące się pod tym katalogiem są trwale ignorowane.

To także łatwy do rozszerzenia, aby dodać dodatkowe wykluczenia. Na przykład:

find build -not \( -path build/external -prune \) -not \( -path build/blog -prune \) -name \*.js

Jest tu pewne zamieszanie co do preferowanej składni pomijania katalogu.

Opinia GNU

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

ze strony podręcznika GNU find

Rozumowanie

-prune zatrzymuje find zstępowanie do katalogu. Samo podanie -not -pathnadal będzie spadać do katalogu pominiętego, ale -not -path będzie false, gdy find przetestuje każdy plik.

Problemy z -prune

-prune robi to, co jest zamierzone, ale nadal są pewne rzeczy, którymi musisz się zająć podczas korzystania z niego.

1. find drukuje przycinany katalog.

   • prawda to zamierzone zachowanie, po prostu nie zstępuje do niego. Aby uniknąć drukowania katalogu, użyj składni, która logicznie go pomija.

2. -prune działa tylko z -print i nie ma innych działania.

   • NIEPRAWDA . -prune działa z każdą akcją z wyjątkiem -delete. dlaczego nie działa z delete? aby -delete zadziałało, find musi przejść przez katalog w kolejności DFS, ponieważ -delete najpierw usunie liście, potem rodziców liści itp... Ale aby określić -prune, aby mieć sens, find musi uderzyć w katalog i przestać go malować, co wyraźnie nie ma sensu z -depth lub -delete on

Wydajność

Ustawiłem prosty test trzech top upvoted odpowiedzi na to pytanie(zamienione -print na -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 zajęła średnio 10-25ms. składnia GetFree, która nie używa -prune, zajęła 865ms. więc tak, jest to dość ekstremalny przykład, ale jeśli zależy ci na czasie pracy i robisz coś zdalnie intensywnego, powinieneś użyć -prune.

zauważ składnia Daniela C. Sobrala sprawdziła się lepiej z dwóch składni -prune; ale mocno podejrzewam, że jest to wynik jakiegoś buforowania, ponieważ zmiana kolejności, w jakiej oba biegły, skutkowała odwrotnym rezultatem, podczas gdy wersja nie-prune 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

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

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

Wolę notację -not... jest bardziej czytelny:

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

Użyj opcji-prune. Czyli coś w stylu:

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

'- type D-name proc - prune ' szuka tylko katalogów o nazwie proc do wykluczenia.
Operator'- o 'jest operatorem' lub'.

Tylko ta mi pomogła.

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

Wyszukiwanie "NameOfFile" z wyłączeniem "Directory". Kłaść nacisk na Gwiazdy * .

Jest to 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 nie w "."ścieżki": {]}

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

-prune zdecydowanie działa i jest najlepszą odpowiedzią, ponieważ zapobiega zejściu do katalogu, który chcesz wykluczyć. -not -path który nadal przeszukuje wykluczony Katalog, po prostu nie wyświetla wyniku, co może być problemem, jeśli wykluczony katalog jest zamontowany na woluminie sieciowym lub nie masz uprawnień.

Najtrudniejsze jest to, że find jest bardzo szczegółowe pod względem kolejności argumentów, więc jeśli nie zrobisz ich dobrze, twoje polecenie może nie działać. Kolejność argumentów jest generalnie jak takie:

find {path} {options} {action}

{path}: Umieść najpierw wszystkie argumenty związane ze ścieżką, jak . -path './dir1' -prune -o

{options}: największe sukcesy odnosiłem, umieszczając -name, -iname, etc jako ostatnią opcję w tej grupie. Np. -type f -iname '*.js'

{action}: będziesz chciał dodać -print przy użyciu -prune

# 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

Podejście-path-prune działa również z symbolami wieloznacznymi w ścieżce. Poniżej znajduje się instrukcja find, która znajdzie Katalogi dla serwera git obsługującego wiele repozytoriów git, pomijając katalogi wewnętrzne 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 \)  

Dla rozwiązania roboczego (testowane na Ubuntu 12.04 (Precise Pangolin))...

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

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

Użycie:

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

...aby wykluczyć dir1 i dir2

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.

Możesz użyć opcji prune, aby to osiągnąć. 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

Szczegółowe instrukcje i przykłady znajdziesz w Linux find polecenie wyklucz katalogi z wyszukiwania.

Jest mnóstwo dobrych odpowiedzi, po prostu Zajęło mi trochę czasu, aby zrozumieć, do czego służy każdy element polecenia i logikę za nim stojącą.

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

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

Opcja -o oznacza logiczny OR i oddziela dwie części polecenia:

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

Każdy katalog lub plik, który jest Nie.katalog / misc nie przejdzie pierwszego testu -path ./misc. Ale będą testowane przeciw drugiemu wyrazowi. Jeśli ich nazwa odpowiada wzorcowi *.txt, zostaną wydrukowane z powodu opcji -print.

Kiedy find dotrze do ./ misc katalog, ten katalog spełnia tylko pierwsze wyrażenie. Tak więc zastosowana zostanie do niego opcja -prune. Polecenie find nakazuje , a nie eksplorację tego katalogu. Więc każdy plik lub katalog w ./ misc nie będzie nawet badane przez find, nie będzie testowane z drugą częścią wyrażenia i nie będzie drukowane.

Używałem find, aby podać listę plików dla xgettext i chciałem pominąć konkretny katalog i jego zawartość. Próbowałem wielu permutacji -path w połączeniu z -prune, ale nie byłem w stanie całkowicie wykluczyć katalogu, który chciałem usunąć.

Chociaż udało mi się zignorować zawartość katalogu, który chciałem zignorować, find następnie zwrócił sam katalog jako jeden z wyników, co spowodowało awarię xgettext w wyniku (nie akceptuje katalogów; tylko plików).

Moim rozwiązaniem było po prostu użycie grep -v, aby pominąć katalog, którego nie chciałem w wynikach:

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

Czy istnieje argument za find, który zadziała w 100%, nie mogę powiedzieć na pewno. Używanie grep było szybkim i łatwym rozwiązaniem po bólu głowy.

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 jest łatwiejsze do zapamiętania IMO.

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

Ż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

To jest dla mnie odpowiednie na Maca:

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

Spowoduje wyłączenie katalogu vendor i app/cache dla nazwy wyszukiwania, która kończy się php.

Dla tych z Was na starszych wersjach Uniksa, którzy nie mogą używać - path lub - not

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

Jak-używać-prune-option-of-find-in-SH to doskonała odpowiedź Laurence Gonsalves na temat tego, jak -prune dział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ąć wielokrotnego wpisywania /path/to/seach/, zawiń find w parę pushd .. popd.

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

Znalazłem nazwę funkcji w plikach źródłowych C exclude *.o i wyklucz *.swp i exclude (nie zwykły plik) oraz exclude dir output za pomocą tego polecenia:

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

Lepiej używać akcji exec niż pętlifor:

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

exec ... '{}' ... '{}' \; zostanie wykonane raz dla każdego pasującego pliku, zastępując klamry '{}' bieżącą nazwą pliku.

Zauważ, że klamry są zamknięte w pojedynczych znakach cudzysłowu, aby chronić je przed interpretacją jako interpunkcja skryptu powłoki^*.

Uwagi

^* z sekcji przykłady strony man find (GNU findutils) 4.4.2

Próbowałem komendy powyżej, ale żaden z tych używających "- prune " nie działa dla mnie. W końcu wypróbowałem to poleceniem poniżej:

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

Do tego czego potrzebowałem działało to tak, znajdując landscape.jpg we wszystkich serwerach zaczynając od roota i wyłączając wyszukiwanie w katalogu /var:

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

find / -maxdepth 1 -type d lista wszystkich d irectories w /

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

xargs -I '{}' find '{}' -name landscape.jpg wykonaj dowolne polecenie, jak find z każdym katalogiem / wynikiem z listy

To działa, ponieważ find testuje pliki dla wzorca "*foo*":

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

Ale to działa a nie działa, jeśli nie używasz wzoru (find nie testuje pliku). Więc find nie wykorzystuje swojej poprzedniej oceny " true" & "false " bools. Przykład niedziałającego przypadku użycia z powyższą notacją:

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

Nie ma find testów! Więc jeśli chcesz znaleźć pliki bez dopasowania wzorca użyj śliwki. Ponadto, dzięki użyciu prune find jest zawsze szybsze, podczas gdy naprawdę pomija, że katalogi zamiast pasować do niego lub lepiej nie pasując do niego. Więc w takim przypadku użyj czegoś w stylu:

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

Lub:

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

Pozdrawiam

Dla FreeBSD użytkowników:

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

Jeśli katalogi wyszukiwania mają wzorzec (w moim przypadku najczęściej), możesz to zrobić tak jak poniżej:

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

W powyższym przykładzie; przeszukuje wszystkie podkatalogi zaczynające się od "n".

Znalazłem sugestie na tej stronie i wiele innych stron po prostu nie działa na moim systemie Mac OS X. Jednak znalazłem odmianę, która działa dla mnie.

Oto mój działający skrypt, który nazwałem "findit".

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

Różne ścieżki mają związek z zewnętrznymi woluminami archiwów, wehikułem czasu, maszynami wirtualnymi, innymi zamontowanymi serwerami i tak dalej. Niektóre nazwy woluminów mają w sobie spacje.

Dobrym testem jest " findit index.php", ponieważ plik ten występuje w wielu miejscach w moim systemie. Dzięki temu skryptowi wyszukiwanie głównego dysku twardego zajmuje około 10 minut. Bez tych wyłączeń zajmuje to wiele godzin.