Cómo excluir un directorio en find. mando

Estoy tratando de 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 -o -name '*.txt' -print

Aquí hay un ejemplo con múltiples directorios:

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

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

Otra acción es -o print, solo imprimir.

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

En el interior \(y \)es una expresión que se ajuste exactamente build/external (ver nota importante más arriba), y la voluntad, en caso de éxito, evitar el desplazamiento nada por debajo . Esto se agrupa como una sola expresión con el paréntesis escapado, y con el prefijo -notque hará findomitir todo lo que coincida con esa expresión.

Uno podría preguntar si agregar -notno hará que todos los demás archivos estén ocultos por -prunereaparecer, y la respuesta es no. La manera-prune funciona es que todo lo que, una vez alcanzado, los archivos debajo de ese directorio se ignoran permanentemente.

Esto proviene de un caso de uso real, donde 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 find como este " find /tmp \(...", debe especificarlo -path /tmp/foo/bar. Si, por otro lado, ejecuta find como este cd /tmp; find . \(..., debe especificarlo -path ./foo/bar.

Claramente, aquí existe cierta confusión sobre cuál debería ser la sintaxis preferida para omitir un directorio.

Opinión de GNU

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

Desde la página de manual de encontrar de GNU

Razonamiento

-prunedeja findde descender a un directorio. Solo especificar -not -pathseguirá descendiendo al directorio omitido , pero -not -pathserá falso cada vezfind pruebe 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 previsto, simplemente no desciende a él. Para evitar imprimir el directorio por completo, use una sintaxis que lo omita lógicamente.

2. -prunesolo funciona con -printy no otras acciones.

   • NO ES VERDAD . -prunefunciona con cualquier acción excepto -delete. ¿Por qué no funciona con eliminar? Para -deletetrabajar, find necesita atravesar el directorio en orden DFS, ya -deleteque primero eliminará las hojas, luego los padres de las hojas, etc. Pero para especificar -pruneque tiene sentido, finddebe presionar un directorio y dejar de descender, lo que claramente no tiene sentido con -deptho -deletesobre.

Actuación

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

----------------------------------------------
# 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 y la sintaxis de Daniel C. Sobral tomaron 10-25ms para funcionar en promedio. La sintaxis de GetFree , que no usa -prune, tomó 865 ms. Entonces, sí, este es un ejemplo bastante extremo, pero si le importa el tiempo de ejecución y está haciendo algo remotamente intensivo, debe usar-prune .

Tenga en cuenta que la sintaxis de Daniel C. Sobral fue la mejor de las dos -prunesintaxis; pero, sospecho fuertemente que esto es el resultado de un cierto almacenamiento en caché, ya que cambiar el orden en que se ejecutaron los dos dio como resultado el resultado opuesto, mientras que la versión sin poda 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 "Directorio". Dar é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

Use 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 el directorio excluido, simplemente no imprime el resultado, lo que podría ser un problema si el directorio excluido está montado en el volumen de la red o no tiene permisos.

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

find {path} {options} {action}

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

{options}: Tengo el mayor éxito al poner -name, -iname, etccomo última opción en este grupo. P.ej-type f -iname '*.js'

{action}: Querrás agregar -printcuando uses-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 find que encontrará los directorios para un servidor git que sirve a múltiples repositorios git que dejan 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 \)  

Para excluir múltiples 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.

Hay muchas buenas respuestas, solo me llevó un 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 imprimen, debido a la-print opción.

Cuando find alcanza el directorio ./misc, este directorio solo satisface la primera expresión. Entonces -prunese le aplicará la opción. Le dice al comando find que no explore ese directorio. Por lo tanto, 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 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.

Utilizar:

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

... para excluir dir1 Y dir2

un buen truco para evitar imprimir los directorios podados es usar -print(funciona -exectambién) después del lado derecho del -orafter -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. Neat. Pero también imprimirá la impresión de la ruta completa de cada directorio que se omite, como se indicó anteriormente. Sin embargo, el siguiente no, ...

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 une a la parte derecha de la -orcláusula debido al orden booleano de operaciones y asociatividad. Pero los documentos dicen que hay un oculto -printsi no -print0está especificado (o alguno 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 del manual), eso es cierto si no hay -print-o -execEN CUALQUIER LUGAR, en cuyo caso, -print se rocía lógicamente para que todo se imprima. Si incluso UNOprint operación estilo expresada en alguna cláusula, todos esos lógicos ocultos desaparecen y obtienes solo lo que especificas. Ahora, francamente, podría haberlo preferido al revés, pero luegofind operador con solo operadores descriptivos aparentemente no haría nada, así que supongo que tiene sentido. Como se mencionó anteriormente, todo esto también funciona -exec, por lo que a continuación se ofrece una ls -lalista completa de cada archivo con la extensión deseada, pero no se enumera 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 saber qué se une a qué, por lo que generalmente creo una macro para la capacidad de escritura y formulo 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 configurando el mundo en dos partes de esta manera. Espero que esto ayude, aunque parece poco probable que alguien lea la respuesta número 30 y la vote, pero uno puede esperar. :-)

Puede usar la opción de podar para lograr esto. Como en 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 de búsqueda de Linux para excluir directorios de la búsqueda .

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 IMO.

TLDR: comprenda sus directorios raíz y adapte su búsqueda desde allí, utilizando 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 de manera efectiva 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 TB múltiple, 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 actualmente ocupa ~ 2.9 TB, con ~ 60 millones de archivos y carpetas; simplemente atravesar 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), necesito tratar (evitar si es posible) atravesar mi partición de copias de seguridad.

EJEMPLOS

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

Solución 1

Digamos que quiero encontrar el archivo del sistema libname-server-2.a, pero no quiero buscar entre 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, or ...):

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

Solución 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, lo que en mi caso, debido a los /mnt/Backups/rsnapshot_backups/*subdirectorios, ¡también incluye ~ 2.9 TB de archivos para buscar! Al no agregar un final, /la búsqueda debe completarse casi de inmediato (en segundos).

Del mismo modo, la "Solución 2" ( ... -not -path <exclude path> ...) parece buscar recursivamente a través de los directorios excluidos, no devuelve coincidencias excluidas, pero consume innecesariamente ese tiempo de búsqueda.

Buscando dentro de esos rsnapshot copias de seguridad:

Para encontrar un archivo en una de mis rsnapshotcopias de seguridad por hora / día / semana / mes ):

$ 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

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.

Estaba usando findpara proporcionar una lista de archivos xgettexty quería omitir un directorio específico y sus contenidos. Intenté muchas permutaciones -pathcombinadas 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 como uno de los resultados, lo que provocó xgettextun bloqueo 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 hay o no un argumento para findque funcione al 100%, no puedo decirlo con certeza. Usar grepera una solución rápida y fácil después de un dolor de cabeza.

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 aqui

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

cómo-usar-podar-opción-de-encontrar-en-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, envuélvala 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

Por 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 find, 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é el nombre de las funciones en los archivos de fuentes de C excluir * .o y excluir * .swp y excluir (no un archivo normal) y excluir 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 usar 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 por cada archivo coincidente, reemplazando las llaves'{}' con el nombre del archivo actual.

Tenga en cuenta que los corchetes están entre comillas simples para protegerlos de la interpretación como puntuación de script de shell ^* .

Notas

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

Intenté el comando anterior, pero ninguno de los que usan "-prune" funciona para mí. Finalmente probé esto con el siguiente comando:

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