Como excluir um diretório na localização. comando

Estou tentando executar um findcomando para todos os arquivos JavaScript, mas como excluo um diretório específico?

Aqui está o findcódigo que estamos usando.

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

Use o -pruneinterruptor. Por exemplo, se você deseja excluir o miscdiretório, adicione a -path ./misc -prune -oao seu comando find:

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

Aqui está um exemplo com vários diretórios:

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

Aqui nós excluímos dir1 , dir2 e dir3 , pois nas findexpressões é uma ação que age com base nos critérios -path dir1 -o -path dir2 -o -path dir3(se dir1 ou dir2 ou dir3 ), ANDed with type -d.

Outra ação é -o printapenas imprimir.

Se -prunenão funcionar para você, isso irá:

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

Advertência: requer percorrer todos os diretórios indesejados.

Acho que é mais fácil raciocinar a seguir do que outras soluções propostas:

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

Nota importante: os caminhos digitados depois -pathdevem corresponder exatamente ao que findseria impresso sem a exclusão. Se esta frase confunde apenas certifique-se de usar caminhos completos através do todo comando como este: . Veja a nota [1] se você quiser entender melhor.find /full/path/ -not \( -path /full/path/exclude/this -prune \) ...

Por dentro \(e \)é uma expressão que corresponderá exatamente build/external (veja a nota importante acima) e, com sucesso, evitará atravessar qualquer coisa abaixo . Isso é então agrupado como uma única expressão com parênteses escapados e prefixado com o -notqual fará com que findpule qualquer coisa que corresponda a essa expressão.

Pode-se perguntar se a adição -notnão fará com que todos os outros arquivos ocultos -prunereapareçam, e a resposta é não. A maneira como -prunefunciona é que tudo o que, uma vez alcançado, os arquivos abaixo desse diretório são permanentemente ignorados.

Isso vem de um caso de uso real, no qual eu precisava chamar o yui-compressor em alguns arquivos gerados pelo wintersmith, mas deixar de fora outros arquivos que precisam ser enviados como estão.

Nota [1] : Se você deseja excluir /tmp/foo/bare executar o find como este " find /tmp \(...", deverá especificar -path /tmp/foo/bar. Se, por outro lado, você executar encontrar assim cd /tmp; find . \(..., deverá especificar -path ./foo/bar.

Há claramente alguma confusão aqui sobre qual deveria ser a sintaxe preferida para ignorar um diretório.

Opinião GNU

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

Na página de manual do GNU find

Raciocínio

-prunepára findde descer para um diretório. Apenas especificar -not -pathcontinuará no diretório ignorado , mas -not -pathserá falso sempre que findtestar cada arquivo.

Problemas com -prune

-prune faz o que se destina, mas ainda há algumas coisas que você precisa cuidar ao usá-lo.

1. find imprime o diretório removido.

   • VERDADEIRO Esse é o comportamento pretendido, apenas não desce a ele. Para evitar a impressão completa do diretório, use uma sintaxe que o omita logicamente.

2. -prunesó funciona com -printe sem outras ações.

   • NÃO É VERDADEIRO . -prunefunciona com qualquer ação, exceto -delete. Por que não funciona com exclusão? Para -deletefuncionar, encontre as necessidades de percorrer o diretório na ordem DFS, já -deleteque primeiro excluirá as folhas, depois os pais das folhas, etc ... Mas, para especificar -pruneque faz sentido, é findnecessário acessar um diretório e parar de descer, claramente não faz sentido com -depthou -deleteligado.

atuação

Configurei um teste simples das três principais respostas votadas para essa pergunta (substituídas -printpor -exec bash -c 'echo $0' {} \;para mostrar outro exemplo de ação). Os resultados estão abaixo

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

Conclusão

Ambos sintaxe do f10bit e sintaxe de Daniel C. Sobral tomou 10-25ms para executar em média. A sintaxe do GetFree , que não usa -prune, levou 865ms. Portanto, sim, este é um exemplo bastante extremo, mas se você se importa com o tempo de execução e está fazendo algo intensamente remotamente, deve usá-lo -prune.

Observe que a sintaxe de Daniel C. Sobral apresentou o melhor das duas -prunesintaxes; mas suspeito fortemente que esse seja o resultado de algum cache, pois a troca da ordem em que os dois foram executados resultou no resultado oposto, enquanto a versão sem remoção foi sempre mais lenta.

Script de teste

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

Este é o único que funcionou para mim.

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

Procurando por "MyFile" excluindo "Diretório". Dê ênfase às estrelas *.

Uma opção seria excluir todos os resultados que contêm o nome do diretório com grep. Por exemplo:

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

Eu prefiro a -notnotação ... é mais legível:

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

Use a opção -prune. Então, algo como:

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

O '-type d -name proc -prune' procura apenas os diretórios chamados proc para excluir.
O '-o' é um operador 'OR'.

-prunedefinitivamente funciona e é a melhor resposta, pois impede a descida no diretório que você deseja excluir. -not -pathque ainda pesquisa o diretório excluído, simplesmente não imprime o resultado, o que pode ser um problema se o diretório excluído estiver montado no volume da rede ou se você não tiver permissões.

A parte complicada é que findé muito particular a ordem dos argumentos; portanto, se você não os acertar, seu comando pode não funcionar. A ordem dos argumentos é geralmente a seguinte:

find {path} {options} {action}

{path}: Coloque todos os argumentos relacionados ao caminho primeiro, como . -path './dir1' -prune -o

{options}: Eu tenho mais sucesso ao colocar -name, -iname, etccomo a última opção neste grupo. Por exemplo-type f -iname '*.js'

{action}: Você deseja adicionar -printao usar-prune

Aqui está um exemplo de trabalho:

# 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

Este é o formato que eu usei para excluir alguns caminhos:

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

Eu usei isso para encontrar todos os arquivos que não estão nos caminhos ". *":

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

A abordagem -path -prune também funciona com curingas no caminho. Aqui está uma instrução find que encontrará os diretórios de um servidor git que atende a vários repositórios git, deixando de fora os diretórios internos do 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 \)  

Para excluir vários diretórios:

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

Para adicionar diretórios, adicione -o -path "./dirname/*":

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

Mas talvez você deva usar uma expressão regular , se houver muitos diretórios a serem excluídos.

Há muitas respostas boas, levei algum tempo para entender para que serviam cada elemento do comando e a lógica por trás dele.

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

find começará a encontrar arquivos e diretórios no diretório atual, daí o find ..

A -oopção representa um OR lógico e separa as duas partes do comando:

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

Qualquer diretório ou arquivo que não seja o diretório ./misc não passará no primeiro teste -path ./misc. Mas eles serão testados contra a segunda expressão. Se o nome deles corresponder ao padrão, *.txteles serão impressos, devido ao-print opção.

Quando a localização atinge o diretório ./misc, esse diretório satisfaz apenas a primeira expressão. Portanto, a -pruneopção será aplicada a ele. Diz ao comando find para não explorar esse diretório. Portanto, qualquer arquivo ou diretório em ./misc nem será explorado pelo find, não será testado na segunda parte da expressão e não será impresso.

Para uma solução funcional (testada no Ubuntu 12.04 (Precise Pangolin)) ...

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

procurará por arquivos MP3 na pasta e nas subpastas atuais, exceto na subpasta dir1.

Usar:

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

... para excluir dir1 AND dir2

um bom truque para evitar a impressão dos diretórios removidos é usar -print(também funciona -exec) depois do lado direito do -ordepois -prune. Por exemplo, ...

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

imprimirá o caminho de todos os arquivos abaixo do diretório atual com a extensão `.j2", ignorando todos os diretórios ocultos. Limpo. Mas também imprimirá o caminho completo de cada diretório que estiver sendo ignorado, conforme observado acima. a seguir não, ...

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

porque logicamente há um oculto -andapós o -inameoperador e antes da impressão. Isso o vincula à parte correta da -orcláusula devido à ordem booleana de operações e associatividade. Mas os documentos dizem que há um oculto -printse ele (ou qualquer um de seus primos ... -print0, etc) não for especificado. Então, por que a parte esquerda da -orimpressão não está? Aparentemente (e eu não entendi isso desde a primeira leitura da página de manual), isso é verdade se não houver apenas operadores descritivos aparentemente não faria nada, então acho que faz sentido. Como mencionado acima, tudo isso também funciona ; portanto, a seguir, é exibida uma lista completa de cada arquivo com a extensão desejada, mas não listando o primeiro nível de cada diretório oculto, ...-print - ou -execEM QUALQUER LUGAR, nesse caso, - a impressão é logicamente espalhada em torno de tal forma que tudo seja impresso. Se mesmo UMprint operação no estilo - é expressa em qualquer cláusula, todas essas lógicas ocultas desaparecem e você obtém apenas o que deseja. especificamos. Agora, francamente, eu poderia ter preferido o contrário, mas então umfind-execls -la

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

Para mim (e outras pessoas neste segmento), a findsintaxe fica bem barroca muito rapidamente, então eu sempre uso parênteses para ter certeza de que sei o que se liga ao que, então eu geralmente crio uma macro para capacidade de digitação e forma todas as declarações como. ..

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

É difícil dar errado, configurando o mundo em duas partes dessa maneira. Espero que isso ajude, embora pareça improvável que alguém leia até a 30ª resposta e vote, mas pode-se esperar. :-)

Você pode usar a opção de remoção para conseguir isso. Como por exemplo:

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

Ou a opção inversa grep "grep -v":

find -iname example.com | grep -v beta

Você pode encontrar instruções e exemplos detalhados no comando Linux find, excluindo diretórios da pesquisa .

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

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

parece funcionar da mesma forma que

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

e é mais fácil lembrar da IMO.

TLDR: entenda seus diretórios raiz e adapte sua pesquisa a partir daí, usando a -path <excluded_path> -prune -oopção Não inclua um final /no final do caminho excluído.

Exemplo:

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

Para usar efetivamente o find, acredito que é imperativo ter um bom entendimento da estrutura de diretórios do sistema de arquivos. No meu computador doméstico, eu tenho discos rígidos com vários TB, com cerca de metade desse conteúdo sendo copiada usando rsnapshot(ou seja, rsync). Embora faça backup em uma unidade fisicamente independente (duplicada), ela é montada no /diretório raiz ( ) do meu sistema /mnt/Backups/rsnapshot_backups/::

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

O /mnt/Backups/rsnapshot_backups/diretório atualmente ocupa ~ 2,9 TB, com ~ 60M de arquivos e pastas; simplesmente atravessar esses conteúdos leva tempo:

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

Assim, sempre que eu precisar procurar um arquivo na minha /partição (raiz), preciso lidar com (evitar se possível) atravessar minha partição de backups.

EXEMPLOS

Entre as abordagens sugeridas de várias maneiras neste tópico ( Como excluir um diretório no comando find. ), Acho que as pesquisas usando a resposta aceita são muito mais rápidas - com ressalvas.

Solução 1

Digamos que desejo encontrar o arquivo do sistema libname-server-2.a, mas não desejo pesquisar nos meus rsnapshotbackups. Para localizar rapidamente um arquivo do sistema, use o caminho de exclusão /mnt(por exemplo, use /mnt, not /mnt/, ou /mnt/Backups, ou ...):

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

... encontra esse arquivo em apenas alguns segundos, enquanto isso leva muito mais tempo (parecendo ser repetido em todos os diretórios "excluídos"):

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

Solução 2

A outra solução oferecida neste segmento ( SO # 4210042 ) também apresenta desempenho ruim:

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

RESUMO CONCLUSÕES

Use a abordagem ilustrada em " Solução 1 "

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

ie

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

observando que sempre que você adiciona a /trilha ao caminho excluído, o findcomando entra recursivamente nos /mnt/*diretórios (todos esses) - que, no meu caso, por causa dos /mnt/Backups/rsnapshot_backups/*subdiretórios, inclui adicionalmente ~ 2,9 TB de arquivos a serem pesquisados! Ao não anexar uma trilha, /a pesquisa deve ser concluída quase imediatamente (em segundos).

A "Solução 2" ( ... -not -path <exclude path> ...) também parece procurar recursivamente os diretórios excluídos - não retornando correspondências excluídas, mas consumindo desnecessariamente esse tempo de pesquisa.

Pesquisando nesses rsnapshotbackups:

Para localizar um arquivo em um dos meus rsnapshotbackups horários / diários / semanais / mensais ):

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

Excluindo um diretório aninhado:

Aqui, quero excluir um diretório aninhado, por exemplo, /mnt/Vancouver/projects/ie/claws/data/*ao pesquisar em /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

Além: A adição -printno final do comando suprime a impressão do diretório excluído:

$ 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

Você também pode usar expressões regulares para incluir / excluir alguns arquivos / direcionar sua pesquisa usando algo como isto:

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

Isso fornecerá apenas todos os arquivos js, vue, css, etc, mas excluindo todos os arquivos nas pastas node_modulese vendor.

Eu estava usando findpara fornecer uma lista de arquivos xgettexte queria omitir um diretório específico e seu conteúdo. Eu tentei muitas permutações de -pathcombinado com, -prunemas foi incapaz de excluir completamente o diretório que eu queria ir.

Embora eu tenha conseguido ignorar o conteúdo do diretório que eu queria ignorar, findretornei o próprio diretório como um dos resultados, o que causou xgettextuma falha como resultado (não aceita diretórios; apenas arquivos).

Minha solução foi simplesmente usar grep -vpara pular o diretório que eu não queria nos resultados:

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

Se existe ou não um argumento para findisso funcionará 100%, não posso dizer com certeza. O uso grepfoi uma solução rápida e fácil após algumas dores de cabeça.

Nenhuma das respostas anteriores é boa no Ubuntu. Tente o seguinte:

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

Eu encontrei isso aqui

Isso é adequado para mim em um Mac:

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

Ele excluirá vendore dirá o app/cachenome da pesquisa com o sufixo php.

Para aqueles em versões mais antigas do UNIX que não podem usar -path ou -not

Testado no SunOS 5.10 bash 3.2 e no SunOS 5.11 bash 4.4

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

Como usar a opção de podar-de-encontrar-em-sh é uma excelente resposta de Laurence Gonsalves sobre como -prunefunciona.

E aqui está a solução genérica:

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

Para evitar digitar /path/to/seach/várias vezes, envolva o findem um 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

Para o que eu precisava, funcionou assim, encontrando landscape.jpgem todos os servidores a partir do root e excluindo a pesquisa no /vardiretório:

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

find / -maxdepth 1 -type dlista todos os d diretórios em/

grep -v /var exclui `/ var 'da lista

xargs -I '{}' find '{}' -name landscape.jpgexecute qualquer comando, como findem cada diretório / resultado da lista

Os seguintes comandos funcionam:

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

Se você tiver um problema com a localização, use a -D treeopção para visualizar as informações da análise de expressão.

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

Ou o -D all, para ver todas as informações de execução.

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

Encontrei o nome das funções nos arquivos de origem C excluindo * .o e exclua * .swp e exclude (arquivo não regular) e exclua a saída dir com este comando:

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

Melhor usar a execação que o forloop:

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

O exec ... '{}' ... '{}' \;será executado uma vez para cada arquivo correspondente, substituindo os chavetas '{}'pelo nome do arquivo atual.

Observe que os colchetes estão entre aspas simples para protegê-los da interpretação como pontuação do script do shell ^* .

Notas

^* Na seção EXEMPLOS da find (GNU findutils) 4.4.2página de manual

Eu tentei o comando acima, mas nenhum dos que usam "-prune" funciona para mim. Eventualmente, eu tentei isso com o comando abaixo:

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