Cómo excluir un directorio en find. mando

Estoy intentando ejecutar un findcomando para todos los archivos JavaScript, pero ¿cómo excluyo un directorio específico?

Aquí está el 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

Usa el -pruneinterruptor. Por ejemplo, si desea excluir el miscdirectorio, simplemente agregue un -path ./misc -prune -oa su comando de búsqueda:

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

A continuación, se muestra un ejemplo con varios directorios:

find . -type d \( -path dir1 -o -path dir2 -o -path dir3 \) -prune -false -o -name '*.txt'

Aquí excluimos ./dir1 , ./dir2 y ./dir3 en el directorio actual, ya que en las findexpresiones es una acción que actúa sobre los criterios -path dir1 -o -path dir2 -o -path dir3(si dir1 o dir2 o dir3 ), Y con type -d.

Para excluir el nombre del directorio en cualquier nivel, use -name:

find . -type d \( -name node_modules -o -name dir2 -o -path name \) -prune -false -o -name '*.json'

Si -pruneno funciona para usted, esto:

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

Advertencia: requiere atravesar todos los directorios no deseados.

Encuentro lo siguiente más fácil de razonar que otras soluciones propuestas:

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: las rutas que escriba después -pathdeben coincidir exactamente con lo que findse imprimiría sin la exclusión. Si esta frase confunde que sólo asegúrese de usar rutas completas en todo el conjunto de comandos de esta manera: . Consulte la nota [1] si desea una mejor comprensión.find /full/path/ -not \( -path /full/path/exclude/this -prune \) ...

Dentro \(y \)hay una expresión que coincidirá exactamente build/external (ver nota importante arriba) y, en caso de éxito, evitará atravesar cualquier cosa debajo . Esto luego se agrupa como una sola expresión con el paréntesis de escape, y con el prefijo -notque hará que se findomita cualquier cosa que coincida con esa expresión.

Uno podría preguntarse si agregar -notno hará que todos los demás archivos ocultos -prunevuelvan a aparecer, y la respuesta es no. La forma en que -prunefunciona es que cualquier cosa que, una vez que se alcanza, los archivos debajo de ese directorio se ignoran permanentemente.

Esto proviene de un caso de uso real, en el que necesitaba llamar a yui-compressor en algunos archivos generados por wintersmith, pero omitir otros archivos que deben enviarse tal cual.

Nota [1] : Si desea excluir /tmp/foo/bary ejecuta buscar así " find /tmp \(...", debe especificar -path /tmp/foo/bar. Si, por otro lado, ejecuta find así cd /tmp; find . \(..., debe especificar -path ./foo/bar.

Es evidente que aquí existe cierta confusión en cuanto a cuál debería ser la sintaxis preferida para omitir un directorio.

Opinión GNU

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

Desde la página de manual de búsqueda de GNU

Razonamiento

-prunedeja findde descender a un directorio. La simple especificación -not -pathseguirá descendiendo al directorio omitido , pero -not -pathserá falso siempre que se findpruebe cada archivo.

Problemas con -prune

-prune hace lo que está destinado a hacer, pero aún hay algunas cosas que debe tener en cuenta al usarlo.

1. find imprime el directorio podado.

   • VERDADERO Ese es el comportamiento intencionado, simplemente no desciende a él. Para evitar imprimir el directorio por completo, use una sintaxis que lo omita lógicamente.

2. -prunesolo funciona con -printotras acciones y no.

   • NO ES CIERTO . -prunefunciona con cualquier acción excepto -delete. ¿Por qué no funciona con eliminar? Para -deleteque funcione, find necesita recorrer el directorio en orden DFS, ya -deleteque primero eliminará las hojas, luego los padres de las hojas, etc ... Pero para que la especificación -prunetenga sentido, findnecesita presionar un directorio y dejar de descender, claramente no tiene sentido con -deptho -deleteen.

Rendimiento

Configuré una prueba simple de las tres respuestas más votadas a favor de esta pregunta (reemplazadas -printpor -exec bash -c 'echo $0' {} \;para mostrar otro ejemplo de acción). Los resultados están debajo

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

Conclusión

Tanto la sintaxis de f10bit como la de Daniel C. Sobral tardaron entre 10 y 25 ms en ejecutarse en promedio. La sintaxis de GetFree , que no usa -prune, tomó 865ms. Entonces, sí, este es un ejemplo bastante extremo, pero si le importa el tiempo de ejecución y está haciendo algo remotamente intensivo, debe usarlo -prune.

Tenga en cuenta que la sintaxis de Daniel C. Sobral realizó la mejor de las dos -prunesintaxis; pero sospecho que esto es el resultado de un almacenamiento en caché, ya que cambiar el orden en el que se ejecutaron los dos dio como resultado el resultado opuesto, mientras que la versión sin podar siempre fue la más lenta.

Script de prueba

#!/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 es el único que funcionó para mí.

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

Buscando "MyFile" excluyendo "Directory". Dale énfasis a las estrellas *.

Una opción sería excluir todos los resultados que contienen el nombre del directorio con grep. Por ejemplo:

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

Prefiero la -notnotación ... es más legible:

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

Utilice la opción -prune. Entonces, algo como:

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

El '-type d -name proc -prune' solo busca directorios llamados proc para excluir.
El '-o' es un operador 'OR'.

-prunedefinitivamente funciona y es la mejor respuesta porque evita descender al directorio que desea excluir. -not -pathque aún busca en el directorio excluido, simplemente no imprime el resultado, lo que podría ser un problema si el directorio excluido es un volumen de red montado o no tiene permisos.

La parte complicada es que findes muy particular sobre el orden de los argumentos, por lo que si no los obtiene correctamente, es posible que su comando no funcione. El orden de los argumentos es generalmente como tal:

find {path} {options} {action}

{path}: Pon todos los argumentos relacionados con la ruta primero, como . -path './dir1' -prune -o

{options}: Tengo más acierto al poner -name, -iname, etccomo última opción en este grupo. P.ej-type f -iname '*.js'

{action}: Querrá agregar -printcuando use-prune

Aquí hay un ejemplo de trabajo:

# 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 es el formato que utilicé para excluir algunas rutas:

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

Usé esto para encontrar todos los archivos que no están en las rutas ". *":

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

El enfoque -path -prune también funciona con comodines en la ruta. Aquí hay una declaración de búsqueda que encontrará los directorios de un servidor git que sirve a múltiples repositorios git, dejando fuera los directorios internos de 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 \)  

Hay muchas buenas respuestas, solo me tomó algo de tiempo entender para qué era cada elemento del comando y la lógica detrás de él.

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

find comenzará a buscar archivos y directorios en el directorio actual, de ahí el find ..

La -oopción representa un OR lógico y separa las dos partes del comando:

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

Cualquier directorio o archivo que no sea el directorio ./misc no pasará la primera prueba -path ./misc. Pero serán probados contra la segunda expresión. Si su nombre corresponde al patrón *.txtque se imprime, por la -printopción.

Cuando find llega al directorio ./misc, este directorio solo satisface la primera expresión. Entonces -prunese le aplicará la opción. Le dice al comando de búsqueda que no explore ese directorio. De modo que cualquier archivo o directorio en ./misc ni siquiera será explorado por find, no se probará con la segunda parte de la expresión y no se imprimirá.

Para excluir varios directorios:

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

Para agregar directorios, agregue -o -path "./dirname/*":

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

Pero tal vez debería usar una expresión regular , si hay muchos directorios para excluir.

Para una solución de trabajo (probado en Ubuntu 12.04 (Precise Pangolin)) ...

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

buscará archivos MP3 en la carpeta y subcarpetas actuales, excepto en la subcarpeta dir1.

Usar:

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

... para excluir dir1 Y dir2

un buen truco para evitar imprimir los directorios podados es usar -print(también funciona para -exec) después del lado derecho del -ordespués -prune. Por ejemplo, ...

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

imprimirá la ruta de todos los archivos debajo del directorio actual con la extensión `.j2", omitiendo todos los directorios ocultos. Ordenado. Pero también imprimirá la ruta completa de cada directorio que se omite, como se indicó anteriormente. Sin embargo, el lo siguiente no lo hace, ...

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

porque lógicamente hay un oculto -anddespués del -inameoperador y antes de la impresión. Esto lo vincula a la parte derecha de la -orcláusula debido al orden booleano de operaciones y la asociatividad. Pero los documentos dicen que hay un oculto -printsi -print0no se especifica (o cualquiera de sus primos ... , etc.). Entonces, ¿por qué no está la parte izquierda de la -orimpresión? Aparentemente (y no entendí esto desde mi primera lectura de la página de manual), eso es cierto si no hay -print-o -execCUALQUIER LUGAR, en cuyo caso, -impresión se esparce lógicamente de tal manera que todo se imprime. Si incluso una printoperación de estilo UNO se expresa en cualquier cláusula, todas esas operaciones lógicas ocultas desaparecen y solo obtiene lo que especifica. Ahora, francamente, podría haberlo preferido al revés, pero entonces un findcon solo operadores descriptivos aparentemente no haría nada, así que supongo que tiene sentido tal como está. Como se mencionó anteriormente, todo esto también funciona -exec, por lo que a continuación se proporciona una ls -lalista completa de cada archivo con la extensión deseada, pero sin enumerar el primer nivel de cada directorio oculto, ...

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

Para mí (y para otros en este hilo), la findsintaxis se vuelve bastante barroca con bastante rapidez, por lo que siempre agrego parens para asegurarme de que sé qué se une a qué, por lo que generalmente creo una macro para la capacidad de escritura y formo todas las declaraciones como. ..

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

Es difícil equivocarse si configura el mundo en dos partes de esta manera. Espero que esto ayude, aunque parece poco probable que alguien lea hasta la respuesta número 30 y la vote, pero es de esperar. :-)

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

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

parece funcionar igual que

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

y es más fácil de recordar en mi opinión.

Puede usar la opción de podar para lograr esto. Como por ejemplo:

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

O la opción inversa grep "grep -v":

find -iname example.com | grep -v beta

Puede encontrar instrucciones detalladas y ejemplos en el comando find de Linux para excluir directorios de la búsqueda .

También puede usar expresiones regulares para incluir / excluir algunos archivos / directorios de su búsqueda usando algo como esto:

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

Esto solo le dará todos los archivos js, vue, css, etc. pero excluyendo todos los archivos en las carpetas node_modulesy vendor.

Ninguna de las respuestas anteriores es buena en Ubuntu. Prueba esto:

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

He encontrado esto aquí

TLDR: comprenda sus directorios raíz y adapte su búsqueda desde allí, usando la -path <excluded_path> -prune -oopción. No incluya un final /al final de la ruta excluida.

Ejemplo:

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

Para utilizar eficazmente el find, creo que es imperativo tener una buena comprensión de la estructura de directorios de su sistema de archivos. En la computadora de mi casa tengo discos duros de varios TB, con aproximadamente la mitad de ese contenido respaldado usando rsnapshot(es decir, rsync). Aunque se realiza una copia de seguridad en una unidad físicamente independiente (duplicada), está montada en el /directorio raíz ( ) de mi 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/
    └── ...

El /mnt/Backups/rsnapshot_backups/directorio ocupa actualmente ~ 2.9 TB, con ~ 60M de archivos y carpetas; simplemente recorrer esos contenidos lleva tiempo:

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

Por lo tanto, cada vez que necesito buscar un archivo en mi /partición (raíz), debo lidiar con (evitar si es posible) atravesar mi partición de copias de seguridad.

EJEMPLOS

Entre los enfoques sugeridos de diversas maneras en este hilo ( Cómo excluir un directorio en el comando find. ), Encuentro que las búsquedas que utilizan la respuesta aceptada son mucho más rápidas, con salvedades.

Solución 1

Digamos que quiero encontrar el archivo del sistema libname-server-2.a, pero no quiero buscar en mis rsnapshotcopias de seguridad. Para encontrar rápidamente un archivo del sistema, use la ruta de exclusión /mnt(es decir, use /mnt, not /mnt/, or /mnt/Backups, o ...):

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

... encuentra ese archivo en solo unos segundos, mientras que esto toma mucho más tiempo (parece que se repite a través de todos los directorios "excluidos"):

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

Solucion 2

La otra solución ofrecida en este hilo ( SO # 4210042 ) también funciona mal:

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

RESUMEN | CONCLUSIONES

Utilice el enfoque ilustrado en la " Solución 1 "

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

es decir

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

teniendo en cuenta que cada vez que agrega el final /a la ruta excluida, el findcomando ingresa recursivamente (todos esos) /mnt/*directorios, que en mi caso, debido a los /mnt/Backups/rsnapshot_backups/*subdirectorios, ¡además incluye ~ 2.9 TB de archivos para buscar! Al no agregar un seguimiento, /la búsqueda debería completarse casi de inmediato (en segundos).

La "Solución 2" ( ... -not -path <exclude path> ...) también parece buscar de forma recursiva en los directorios excluidos, sin devolver coincidencias excluidas, pero consumiendo innecesariamente ese tiempo de búsqueda.

Buscando dentro de esas rsnapshotcopias de seguridad:

Para buscar un archivo en una de mis rsnapshotcopias de seguridad por hora / diaria / semanal / mensual ):

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

Excluyendo un directorio anidado:

Aquí, quiero excluir un directorio anidado, por ejemplo, /mnt/Vancouver/projects/ie/claws/data/*al buscar desde /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

Aparte: Agregar -printal final del comando suprime la impresión del directorio excluido:

$ 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

find . \( -path '.**/.git' -o -path '.**/.hg' \) -prune -o -name '*.js' -print

El ejemplo anterior busca todos los *.jsarchivos en el directorio actual, excluidas las carpetas , .gity .hgno importa la profundidad de estas .gity las .hgcarpetas.

Nota: esto también funciona:

find . \( -path '.*/.git' -o -path '.*/.hg' \) -prune -o -name '*.js' -print

pero prefiero la **notación por coherencia con algunas otras herramientas que estarían fuera de tema aquí.

Estaba usando findpara proporcionar una lista de archivos xgettexty quería omitir un directorio específico y su contenido. Probé muchas permutaciones de -pathcombinado con -prunepero no pude excluir completamente el directorio que quería que desapareciera.

Aunque pude ignorar el contenido del directorio que quería ignorar, findluego devolví el directorio en sí como uno de los resultados, lo que provocó xgettextque se bloqueara como resultado (no acepta directorios; solo archivos).

Mi solución fue simplemente usar grep -vpara omitir el directorio que no quería en los resultados:

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

Si existe o no un argumento para findque funcione al 100%, no puedo decirlo con certeza. Usar grepfue una solución rápida y fácil después de un dolor de cabeza.

Esto es adecuado para mí en una Mac:

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

Excluirá vendory dirigirá el app/cachenombre de búsqueda que tenga el sufijo php.

Para aquellos de ustedes en las versiones anteriores de UNIX que no pueden utilizar -path o -no

Probado en SunOS 5.10 bash 3.2 y 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 es una excelente respuesta de Laurence Gonsalves sobre cómo -prunefunciona.

Y aquí está la solución 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 escribir /path/to/seach/varias veces, envuelva el finden un 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 lo que necesitaba, funcionó así, encontrando landscape.jpgen todos los servidores comenzando desde la raíz y excluyendo la búsqueda en el /vardirectorio:

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

find / -maxdepth 1 -type denumera todos los d irectories en/

grep -v /var excluye `/ var 'de la lista

xargs -I '{}' find '{}' -name landscape.jpgejecutar cualquier comando, como findcon cada directorio / resultado de la lista

Los siguientes comandos funcionan:

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

Si tiene un problema con la búsqueda, use la -D treeopción para ver la información del análisis de expresión.

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

O el -D all, para ver toda la información de ejecución.

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

Encontré que el nombre de las funciones en los archivos de fuentes C excluye * .o y excluye * .swp y excluye (archivo no normal) y excluye la salida del directorio con este comando:

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

Mejor usa la execacción que el forbucle:

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

Se exec ... '{}' ... '{}' \;ejecutará una vez para cada archivo coincidente, reemplazando las llaves '{}'con el nombre del archivo actual.

Tenga en cuenta que las llaves están encerradas entre comillas simples para protegerlas de la interpretación como puntuación de script de shell ^* .

Notas

^* De la sección EJEMPLOS de la find (GNU findutils) 4.4.2página del manual