如何在find中排除目录。命令

我正在尝试find为所有JavaScript文件运行命令，但是如何排除特定目录？

这是find我们正在使用的代码。

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

使用-prune开关。例如，如果要排除misc目录，只需将a添加-path ./misc -prune -o到您的find命令中：

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

这是带有多个目录的示例：

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

在这里，我们排除了dir1，dir2和dir3，因为在find表达式中，这是一个作用于条件-path dir1 -o -path dir2 -o -path dir3（如果是dir1或dir2或dir3）的操作，并与进行与type -d。

进一步的操作是-o print，仅打印。

如果-prune对您不起作用，这将：

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

警告：需要遍历所有不需要的目录。

与其他提议的解决方案相比，我发现以下原因更容易推理：

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

重要说明：您键入的路径-path必须与find不排除的内容完全匹配。如果这句话使您感到困惑，则只需确保在整个命令中使用完整路径，如下所示：。如果您想更好地理解，请参见注释[1]。find /full/path/ -not \( -path /full/path/exclude/this -prune \) ...

在\(和内部\)是一个完全 匹配的表达式build/external（请参见上面的重要说明），并且在成功时将避免遍历下面的任何内容。然后，将其作为带有转义括号的单个表达式分组，并以前缀作为前缀-not将find跳过该表达式匹配的任何内容。

有人可能会问，添加-not是否不会使所有其他文件都被隐藏起来-prune，答案是否定的。-prune起作用的方式是，一旦到达该目录下的文件，则该文件将被永久忽略。

这来自一个实际用例，在该用例中，我需要对Wintersmith生成的某些文件调用yui-compressor，但忽略了需要按原样发送的其他文件。

注意[1]：如果要排除/tmp/foo/bar并运行像这样的查找，find /tmp \(...则必须指定-path /tmp/foo/bar。另一方面，如果您运行这样的查找，cd /tmp; find . \(...则必须指定-path ./foo/bar。

对于跳过目录的首选语法，这里显然存在一些困惑。

GNU意见

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

从GNU查找手册页

推理

-prune停止find下降到目录中。仅指定-not -path内容仍将进入已跳过的目录，但是-not -path在find测试每个文件时将为false 。

问题 -prune

-prune 可以达到预期的目的，但是在使用时仍然需要注意一些事项。

1. find 打印修剪后的目录。

   • TRUE这是预期的行为，它只是不落在其中。为避免完全打印目录，请使用在逻辑上将其省略的语法。

2. -prune仅适用于-print其他操作。

   • 不正确。-prune除了可以执行任何动作-delete。为什么删除不起作用？为了-delete正常工作，查找需要按DFS顺序遍历目录，因为-delete将首先删除叶子，然后是叶子的父级，等等。但是为了明确起见-prune，find需要访问目录并停止降级，这显然，开启-depth或关闭都没有意义-delete。

性能

我设置了三大顶尖upvoted答案的一个简单的测试，在这个问题上（替换-print用-exec bash -c 'echo $0' {} \;展示另一个动作的例子）。结果如下

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

结论

无论f10bit的语法和丹尼尔C.索布拉尔的语法了10-25ms，以平均运行。GetFree的语法（不使用-prune）耗时865毫秒。因此，是的，这是一个非常极端的示例，但是如果您关心运行时并且正在做任何远程密集型工作，则应该使用-prune。

注意Daniel C. Sobral的语法在两种-prune语法中表现更好。但是，我强烈怀疑这是某些高速缓存的结果，因为切换两者的运行顺序会导致相反的结果，而非修剪版本始终是最慢的。

测试脚本

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

这是唯一为我工作的人。

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

搜索除“目录”外的“ MyFile”。强调星星*。

一种选择是使用grep排除所有包含目录名称的结果。例如：

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

我更喜欢这种-not表示法……它更具可读性：

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

使用-prune选项。因此，类似：

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

“ -d -name proc -prune”仅查找要排除的名为proc的目录。
“ -o”是“ OR”运算符。

-prune绝对有效，并且是最佳答案，因为它可以防止下降到您要排除的目录中。-not -path仍然会搜索排除的目录，只是不打印结果，如果排除的目录已装入网络卷或您没有权限，则可能会出现问题。

棘手的部分是，find参数的顺序非常特殊，因此，如果您输入的参数不正确，则命令可能无法正常工作。参数的顺序通常如下：

find {path} {options} {action}

{path}：将所有与路径相关的参数放在首位，例如 . -path './dir1' -prune -o

{options}：-name, -iname, etc在该组中，最后一个选项是我获得最大的成功。例如-type f -iname '*.js'

{action}：您需要添加 -print使用时-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

这是我用来排除某些路径的格式：

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

我用它来查找不在“。*”路径中的所有文件：

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

-path -prune方法也可用于路径中的通配符。这是一条find语句，它将查找服务于多个git存储库的git服务器的目录，而忽略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 \)  

要排除多个目录：

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

要添加目录，请添加-o -path "./dirname/*"：

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

但是，如果要排除的目录很多，也许应该使用正则表达式。

有很多不错的答案，我花了一些时间来了解命令的每个元素是什么以及其背后的逻辑。

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

find将开始在当前目录中查找文件和目录，因此find .。

该-o选项代表逻辑或，并将命令的两个部分分开：

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

不是 ./misc目录的任何目录或文件都不会通过第一次测试-path ./misc。但是它们将针对第二个表达式进行测试。如果名称与图案相对应，则*.txt可以选择打印-print。

当find到达./misc目录时，该目录仅满足第一个表达式。因此，该-prune选项将应用于它。它告诉find命令不要浏览该目录。因此，。/ misc中的任何文件或目录都不会被find查找，也不会针对表达式的第二部分进行测试，也不会被打印。

对于可行的解决方案（已在Ubuntu 12.04（精确的穿山甲）上测试）...

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

将在当前文件夹和子文件夹中搜索mp1文件，但在dir1子文件夹中除外。

采用：

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

...以排除dir1和dir2

一个好的技巧，以避免打印修剪目录是使用-print（对于作品-exec的右侧后以及）-or之后-prune。例如， ...

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

将以扩展名.j2打印当前目录下所有文件的路径，并跳过所有隐藏目录。整洁。但如上所述，它还将打印正在跳过的每个目录的完整路径。以下不，...

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

因为从逻辑上讲-and，在-iname运算符之后和-print之前有一个隐藏的内容。-or由于操作的布尔顺序和关联性，这会将其绑定到子句的右侧。但是文档说，-print如果-print0未指定（或它的任何表亲... 等），则存在隐藏项。那么，为什么-or打印的左边没有显示呢？显然（并且，我第一次阅读手册页时并没有理解这一点），这是正确的，如果不存在-print -或-exec ANYWHERE，则在逻辑上撒满-print以便可以打印所有内容。如果连一个print-style操作在任何子句中表示，所有那些隐藏的逻辑操作都消失了，而您只能得到指定的内容。坦率地说，我可能反而更喜欢它，但是 afind仅使用描述性运算符显然不会执行任何操作，因此我认为这是合理的。如上所述，这一切也都适用-exec，因此以下内容提供了ls -la具有所需扩展名的每个文件的完整列表，但未列出每个隐藏目录的第一级，...

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

对我（以及该线程上的其他人）来说，find语法很快就变得很巴洛克式，因此我总是投入括号以确保我知道什么绑定到什么，因此我通常创建一个具有类型输入能力的宏并将所有此类语句形成为。 ..

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

通过这样将世界分为两个部分，很难出错。我希望这会有所帮助，尽管似乎不太可能有人阅读第30个以上的答案并投票赞成，但有人可以希望。:-)

您可以使用prune选项来实现此目的。例如：

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

或反grep“ grep -v”选项：

find -iname example.com | grep -v beta

您可以在Linux find命令中找到详细说明和示例，这些命令从搜索中排除目录。

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

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

似乎与

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

并且更容易记住IMO。

TLDR：使用-path <excluded_path> -prune -o选项了解您的根目录并从那里定制搜索。不要/在排除路径的末尾添加尾随。

例：

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

为了有效地使用findI，我相信对文件系统目录结构有一个很好的了解。在我的家用计算机上，我具有多TB硬盘驱动器，其中大约一半的内容是使用rsnapshot（即rsync）备份的。尽管备份到物理上独立（重复）的驱动器，但它已安装在我的系统根目录（/）下/mnt/Backups/rsnapshot_backups/：

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

该/mnt/Backups/rsnapshot_backups/目录当前占用约2.9 TB的空间，其中包含约6000万个文件和文件夹。仅仅遍历这些内容需要花费时间：

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

因此，每当我需要在我的/（根）分区上搜索文件时，都需要处理（如果可能的话）遍历我的备份分区。

例子

在该线程中提出的各种建议中（如何在find。命令中排除目录）中，我发现使用公认的答案进行搜索的速度要快得多，但有一些警告。

解决方案1

假设我要查找系统文件libname-server-2.a，但我不想搜索rsnapshot备份。要快速查找系统文件，请使用排除路径/mnt（即，使用/mnt，不是/mnt/或/mnt/Backups，或...）：

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

...只需几秒钟即可找到该文件，而这需要很多时间长（出现在所有的“排除”目录的递归）：

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

解决方案2

此线程中提供的另一个解决方案（SO＃4210042）的效果也很差：

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

总结 结论

使用“ 解决方案1 ”中说明的方法

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

即

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

请注意，无论何时将尾随添加/到排除的路径中，该find命令都会递归地进入（所有这些）/mnt/*目录-在我的情况下，由于/mnt/Backups/rsnapshot_backups/*子目录的原因，该目录还包括约2.9 TB的文件搜索！通过不添加结尾/，搜索应几乎立即完成（几秒钟内）。

... -not -path <exclude path> ...同样，“解决方案2”（）似乎可以在被排除的目录中进行递归搜索-不返回被排除的匹配项，但不必要地浪费了搜索时间。

在那些内搜索 rsnapshot备份中：

要在我的每小时/每天/每周/每月rsnapshot备份中找到一个文件）：

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

排除嵌套目录：

在这里，我想排除嵌套目录，例如/mnt/Vancouver/projects/ie/claws/data/*，从中搜索时/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

另外：-print在命令末尾添加将禁止打印排除目录：

$ 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 . -regextype posix-egrep -regex ".*\.(js|vue|s?css|php|html|json)$" -and -not -regex ".*/(node_modules|vendor)/.*" 

这只会给您所有js，vue，css等文件，但不包括node_modules和vendor文件夹中的所有文件。

我曾经find用来提供的文件列表xgettext，但想省略特定的目录及其内容。我尝试了许多-path组合的组合，-prune但无法完全排除我想消失的目录。

尽管我可以忽略要忽略的目录内容，但是find将目录本身作为结果之一返回，结果导致xgettext崩溃（不接受目录；仅接受文件）。

我的解决方案是简单地使用grep -v跳过结果中不需要的目录：

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

find我不能肯定地说，是否有这样的论点会100％奏效。grep头痛后使用，是一种快速简便的解决方案。

先前的答案在Ubuntu上都不好。尝试这个：

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

我在这里找到这个

这在Mac上适合我：

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

搜索名称后缀为会排除vendor和app/cachedir php。

对于那些无法使用-path或-not的UNIX早期版本的用户

在SunOS 5.10 bash 3.2和SunOS 5.11 bash 4.4上测试

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

Laurence Gonsalves很好地回答了如何使用sh-find-sh中的修剪选项-prune。

这是通用解决方案：

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

避免输入/path/to/seach/多次，包裹find在一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

对于我所需要的，它的工作方式如下：landscape.jpg在所有服务器中从root开始查找，并排除/var目录中的搜索：

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

find / -maxdepth 1 -type d列出所有d在irectories/

grep -v /var 从列表中排除“ / var”

xargs -I '{}' find '{}' -name landscape.jpg执行任何命令，例如find使用列表中的每个目录/结果

以下命令有效：

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

如果查找有问题，请使用该-D tree选项查看表达式分析信息。

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

或-D all，以查看所有执行信息。

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

我发现C源文件中的函数名称排除* .o和排除* .swp并排除（不是常规文件）并使用此命令排除dir输出：

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

exec比for循环更好地使用动作：

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

在exec ... '{}' ... '{}' \;将一次每一个匹配的文件来执行，更换支架'{}'与当前文件名。

请注意，括号用单引号引起来，以防止其解释为shell脚本标点符号^*。

笔记

^*从find (GNU findutils) 4.4.2手册页的“示例”部分

我在上面尝试了命令，但是使用“ -prune”的命令都不适合我。最终我用下面的命令尝试了这个：

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