How do I exclude a directory when using `find`?

Question

How do I exclude a specific directory when searching for *.js files using find?

find . -name '*.js'

GetFree · Answer 1 · 2021-09-29T12:03:13.223

2600

If -prune doesn't work for you, this will:

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

Caveat: requires traversing all of the unwanted directories.

edited Sep 29 '21 at 12:03

answered Apr 01 '13 at 01:26

GetFree

40,278
18
77
104

3

Describe why they're wrong? I've been using the chosen answer for two and a half years now... – helion3 Apr 01 '13 at 03:31
115

One of the comments in the accepted answer points out the problem. `-prune` does not exclude the directory itself, it exclude its content, which means you are going to get an unwanted line in the output with the excluded directory. – GetFree Apr 01 '13 at 08:20
167

Great answer. I'd add to this that you can exclude a directory at ANY level by changing the first `.` to `*`. so `find -name "*.js" -not -path "*/omitme/*"` would omit files from a directory named "omitme" at any level of depth. – DeeDee May 01 '13 at 02:51
104

It still *traverses* all of the unwanted directory, though. I'm adding my own answer. :-) – Daniel C. Sobral May 16 '13 at 18:52
26

Note, however, that the prune option only doesn't work if you don't use `-print` explicitly. – Daniel C. Sobral May 16 '13 at 19:07
42

It would be better to say "This is an alternative to using -prune". The answers suggesting -prune are clearly not wrong, they just aren't the way you would do it. – Jimbo Aug 16 '13 at 08:27
3

@Jimbo, yes they are wrong. Read the comments in the accepted answer and this one or try them yourself to check it. – GetFree Sep 12 '13 at 21:48
4

@GetFree: As the original author of the infamous "prune" answer: No they are not wrong. To test your claim, I just created a test directory, created 5 js files inside, created a testtest subdirectory right beside them and copied the js files into the subdirectory. I ran both commands (prune and your) and they both return the exact same output: http://pastebin.com/eH4tvgSh – f10bit Sep 26 '13 at 12:35
4

@f10bit, a previous comment to this answer explains why it worked for you. The `-prune` option only works if you use `-print` as the action. If you want to do anything else, it doesn't work properly. That's why all answers using `-prune` are wrong for the general case (they would work in one specific case only). – GetFree Sep 26 '13 at 23:14
2

Using prune works fine for me, even with an `exec` or `ls` action. Am I misreading something, or are you asserting the man page is wrong? From the man page (GNU findutils 4.4.2 - Ubuntu 12.04 Precise): "To ignore a whole directory tree, use -prune rather than checking every file in the tree. For example, to skip the directory `src/emacs` and all files and directories under it, and print the names of the other files found, do something like this: `find . -path ./src/emacs -prune -o -print`" – jbo5112 Dec 09 '13 at 16:07
9

-1: A good answer must avoid traversing below the unwanted directories. It's one of the main use-cases going beyond the particulars of the original question. – Evgeni Sergeev Feb 07 '14 at 22:02
1

Works for me on RHEL 6, whereas `-prune` did not (even with `-print`) – xav Mar 13 '14 at 12:08
1

I think maybe what he means by "wrong" are "stupid and inefficient". He was just being polite. – Buttle Butkus Mar 18 '14 at 02:13
4

@ButtleButkus Except `-prune` is more efficient. He is wrong in using `wrong`, it's as simple as that. – Reinstate Monica Please Sep 30 '14 at 20:48
4

@pal4life Use `!`, which is posix compliant. – Reinstate Monica Please Sep 30 '14 at 20:51
1

The use of `-prune` is not only more efficient, it's also inline exactly with the man page (referenced in `-name`, `-wholename`, and `-prune`). :-) – Hossy Oct 18 '14 at 22:33
3

Doesn't prune not work when used in concert with `-depth` and as a side effect not work correctly with other commands which imply `-depth`? IIRC there is even a warning about this in the manpage for find. – Dave Rawks Jun 22 '15 at 17:18
7

-1 The use of `prune` is definitely what the original autor looks for. The [currently accepted answer](http://stackoverflow.com/a/4210072/413020) prints out the pruned dir, but that doesn't mean that it's wrong. The author wanted to compress some files. That can be achieved by an `-exec` in the right side of the `-o`, and it will work flawlessly. I'm amazed how many upvotes has become this answer. If you don't even want to print the pruned dir, you could also tune that. Better improve the accepted answer. – Alberto Aug 28 '15 at 08:00
1

Thanks. This answer worked in 5 seconds to dump changelog without fiddling around much...prune was outputting unexpected results (or lack of file ext): `# find /searched-directory -type f -not -path "/ignored-directory1/*" -not -path "/ignored-directory2/*" -not -path "/ignored-directory3/*" -printf '%TY-%Tm-%Td %TT %p\n' | sort -r > /export-directory/changedump.txt` – dhaupin Nov 17 '15 at 15:24
14

KEY TAKE AWAY: "**It still traverses all of the unwanted directory, though**" --> results are the same but time is very different. for me the difference was: **2 minutes vs 8 seconds**. Using the `-prune` is more difficult IMO but makes execution time *much* faster. – Trevor Boyd Smith Nov 04 '16 at 17:21
1

this is not working for me to exclude node_modules => " find $(dirname "$DIR")/**/**/*.js -maxdepth 8 -type f -not -path "*/node_modules/*" ....kind of sad that it doesn't work TBH – Alexander Mills Dec 15 '16 at 09:06
4

`!` is more concise than `-not`. – Quolonel Questions Jun 04 '17 at 22:02
1

@GetFree “all answers using -prune are wrong for the general case” No, not all. `find`’s primary and most general use-case is *finding files.* Use-cases outside of that—deleting, exec-ing, etc.—are extras and nice-to-haves. They’re built-in—in spite of the challenge their inclusion poses to the UNIX “one thing” philosophy—primarily for convenience/historical purposes. But they’re not `find`’s primary role&responsibility. Incidentally, this is why piping `-print`’d `find` output to something like a while loop is usually better when you need to do anything more complex with the discovered files. – Mark G. Jun 16 '17 at 16:00
@MarkG. you made up that quote yourself. I've never said that. – GetFree Jun 17 '17 at 14:57
1

`-prune` definitely works. The problem is that the Accepted Answer by f10bit isn't totally correct. Try this solution with a working example: https://stackoverflow.com/a/47341478 – wisbucky Nov 17 '17 at 00:43
1

I like this answer, but how can I modify it to exclude multiple specific directories instead of just one? – still_dreaming_1 Dec 09 '17 at 01:02
5

@still_dreaming_1, just repeat the part `-not -path "./dir_name/*"` – GetFree Dec 09 '17 at 13:39
Is there any way to detect all the folder having a specific folder name instead of its path ? @GetFree – alper Aug 03 '18 at 22:19
1

@alper, the third comment to this answer (by DeeDee) might help you. – GetFree Aug 04 '18 at 15:24
@GetFree “you made up that quote yourself” *Au contraire.* For context, my comment was in reference to [this](https://stackoverflow.com/questions/4210042/how-to-exclude-a-directory-in-find-command/15736463#comment28137557_15736463). My point was that `-prune` *is* the general case. It’s `-not -path` or `! -path` that are exceptional, such as when one is using an action (like `-delete`) that implies `-depth` (which is antithetical to general-purpose `-prune`). Neither are wrong, but one would be well-advised to use the right tool for the job. If `-depth` is not needed/implied, that’s `-prune`. – Mark G. Aug 09 '18 at 14:19
@MarkG. that comment was posted long, long time ago when in fact all answers to this question that proposed using `-prune` where wrong. Since then, a few new answers have been posted that use `-prune` correctly. – GetFree Aug 09 '18 at 16:59
1

this doesn't work for me in Ubuntu 18.04.1 LTS. Working command is like `find / ! $ -path /proc -prune $ -type f -name '*.js'` - e.g. it does not traverse /proc and *does not print errors* about not entering this forbidden directory. – Nishi Nov 21 '18 at 12:53
Why is not this accepted answer? If I haven't scrolled past it, I would never find this, which actually solves problem – xZero Jan 10 '19 at 12:16
@GetFree,you said `-prune does not exclude the directory itself`,but through test in centos 7.4,your answer also `not exclude the directory itsel`.For example,`find -not -path "./.git/*" -type d` also include `./.git` – kittygirl Jan 30 '19 at 13:57
@kittygirl, you have to include the `-name` filter as well to search for a specific file extension. If you want to search for files and dirs alike, but want to exclude a given directory, you either use `-not -name` to exclude that directory name or `-not path` to exclude a specific directory path, e.g. `-not -path "./.git"` – GetFree Jan 30 '19 at 23:20
@helion3 it is likely because of the use of -o which means or, which will negate the pruning. remove the -o and it should work with prune. – mjs Nov 30 '19 at 15:10
1

Got this error on MacOS: find: illegal option -- n – Long Nguyen Apr 09 '21 at 13:33
Notice that the `./` _before_ and the `/*` _after_ the folder name to exclude are *required* in order to exclude `dir_to_exclude`, and anything within it! Ex: do `find -not -path "./dir_to_exclude/*"`, NOT `find -not -path "dir_to_exclude"`. This took me a while to figure out. [I expound upon this in my answer I just added here](https://stackoverflow.com/a/69830768/4561887), and I discuss the various case-**in**sensitive options too. – Gabriel Staples Nov 03 '21 at 19:37
This answer does no cover the folders that are located in subfolders – alper Feb 03 '22 at 18:20
@GetFree What are the differences between `-not -path` and `-prune`? – John Mar 26 '22 at 14:39
Half of the edits to this answer are adding a period after the find command `find . -name`, and @GetFree edited every one of them to remove it. Without the period, I get an `illegal option -- n` error, it works with the period, yet there is no explanation as to why you keep deleting it. Since it is so important to keep it removed, and breaks the command without the period, you should really give an explanation as to why you want it removed. – Jtcruthers Dec 23 '22 at 01:37

score 1716 · Accepted Answer · edited Sep 29 '21 at 11:03

1716

Use the -prune primary. For example, if you want to exclude ./misc:

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

To exclude multiple directories, OR them between parentheses.

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

And, to exclude directories with a specific name at any level, use the -name primary instead of -path.

find . -type d -name node_modules -prune -o -name '*.json' -print

edited Sep 29 '21 at 11:03

oguz ismail

1
16
47
69

answered Nov 17 '10 at 23:00

f10bit

18,710
2
25
20

23

This didn't work for me until I prefixed my local path wih `./`, e.g. `./.git`. This distinction for `find` might not be obvious to the occasional `find` user. – sebkraemer Dec 17 '21 at 09:56
26

Since this is the accepted answer, I feel it should be mentioned here that the reason `-print` must be added to the end is to prevent the default behavior, which is to also print the names of the pruned directories. @cycollins explains this well in another answer. – Thomas Jan 06 '22 at 21:16
`find . -type d $ -path "./Library/*" -o -path "./.Trash" $ -prune -o -name '.DS_Store' -print0 | xargs -0 rm` From ~/ on my mac cleans it up nicely :) – Ahi Tuna Feb 08 '22 at 18:36
@Thomas regarding `-print`, `default` seems the keyword in your comment. – Timo Mar 06 '22 at 11:27
8

If u wanna skip the exclude dir in the result file lists, just add `-false` after `-prune`. like `find . -path ./misc -prune -false -o -name '*.txt' -print` – tianjianchn Jun 04 '22 at 13:13
This did not work for me in git bash on Windows when I left `/` at the end of path, i.e. this: `-path ./dir/`. I had to make sure that I used `-path ./dir` (without the trailing `/` after `dir`). – jcxz Aug 25 '23 at 09:15

score 609 · Answer 3 · edited Jul 06 '19 at 15:12

609

I find the following easier to reason about than other proposed solutions:

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

Important Note: the paths you type after -path must exactly match what find would print without the exclusion. If this sentence confuses you just make sure to use full paths through out the whole command like this: find /full/path/ -not $ -path /full/path/exclude/this -prune $ .... See note [1] if you'd like a better understanding.

Inside $ and $ is an expression that will match exactly build/external (see important note above), and will, on success, avoid traversing anything below. This is then grouped as a single expression with the escaped parenthesis, and prefixed with -not which will make find skip anything that was matched by that expression.

One might ask if adding -not will not make all other files hidden by -prune reappear, and the answer is no. The way -prune works is that anything that, once it is reached, the files below that directory are permanently ignored.

This comes from an actual use case, where I needed to call yui-compressor on some files generated by wintersmith, but leave out other files that need to be sent as-is.

Note [1]: If you want to exclude /tmp/foo/bar and you run find like this "find /tmp \(..." then you must specify -path /tmp/foo/bar. If on the other hand you run find like this cd /tmp; find . \(... then you must specify -path ./foo/bar.

edited Jul 06 '19 at 15:12

Konrad Rudolph

530,221
131
937
1,214

answered May 16 '13 at 19:01

Daniel C. Sobral

295,120
86
501
681

55

Outstanding answer, thank you. This works and is scalable (readable) for multiple exclusions. You are a gentlemen and a scholar sir. Thank you for the example for multiple exclusions – Freedom_Ben Aug 16 '13 at 16:38
8

This does not work if I want to use -delete switch: `find . -not $ -path ./CVS -prune $ -type f -mtime +100 -delete find: The -delete action atomatically turns on -depth, but -prune does nothing when -depth is in effect. If you want to carry on anyway, just explicitly use the -depth option.` – Jānis Elmeris Dec 14 '13 at 09:12
21

@Janis You can use `-exec rm -rf {} \;` instead of `-delete`. – Daniel C. Sobral Dec 15 '13 at 21:14
1

This is great and worked perfectly for excluding huge static directories from my bytecode search. One gotcha: the -name parameter has to be after the -not (-prune) command for the exclusion to work. – Matthew F. Robben Jan 04 '14 at 21:10
13

By examining the output of `find`, this is obvious really, but it tripped me up. If you are searching in the current directory (by specifying `.` as the search path, or not specifying one at all), you most likely want your pattern after `-path` to start with `./`, e.g: `find -not $ -path ./.git -prune $ -type f`. – Zantier Oct 09 '14 at 10:10
Windows git bash shell find does not seem to support this but if you have cygwin you can do something like `/c/cygwin/bin/find` it spits some errors, probably without symlinking stuff over to git bash but seems to work for this task. – sabgenton Feb 25 '15 at 03:26
@sabgenton it works for me in git bash 1.9.5. See my answer on [how to exclude `.git` and `node_modules`](http://stackoverflow.com/q/34152804/245966) from being traversed. – jakub.g Dec 08 '15 at 09:57
@sabgenton Well in fact it seems this indeed does not work with `-name` part. But this is the easy part: you can exclude stuff using this answer, and then pipe to grep. – jakub.g Dec 08 '15 at 10:11
1

Instead of using the `-not` switch, why don't you simply separate the two statements with a comma? Like `find build -path build/external -prune , -name *.js` – M.Herzkamp Feb 08 '16 at 02:38
@M.Herzkamp Comma is not on BSD. – Daniel C. Sobral Feb 09 '16 at 07:16
I like that this approach makes the exclusion code self-contained (i.e. not split before/after the other find primaries). That enabled me to write a short-hand script, ~/bin/exclude, so I could say `$ find . \`exclude .git CVS\` -name foo`. Script is: `for k in "$@" ; do echo -not $ -type d -name "${k%/}" -prune $ ; done` – Noach Magedman Mar 30 '16 at 11:14
Works for me in Win7, using gfind from gow. Here is my exact syntax with the cmd.exe shell (i.e. not bash): gfind . -not ( -path ./DrU -prune ) -not ( -path ./DrV -prune ) – Radim Cernej May 19 '16 at 22:42
2

@Janis from the manpage: `-prune True; if the file is a directory, do not descend into it. If -depth is given, false; no effect. Because -delete implies -depth, you cannot usefully use -prune and -delete together.` – sjas Aug 01 '16 at 10:18
11

A more precise (and POSIX compatible) variation of this method: `find searchdir \! $ -type d \( -path './excludedir/*' -o -path './excludedir2/*' -o -path './excludedir3/*' $ -prune \)` followed by any conditions that should match what you are looking for. – Walf May 26 '17 at 04:17
1

Do not omit the spaces after \$ and before \$ :-) – bebbo Jan 08 '18 at 07:47
1

Perhaps you could add some clarification in that the `-prune` is looking for the actual text the find output displays; in your example `build/external`. Another example is a more common `find .`, in which case the `./` needs to lead the prune'd expression. – Krista K Feb 16 '18 at 18:40
2

My suggested command's general format should actually be `find searchdir \! $ -type d \( -path 'searchdir/excludedir' -o -path 'searchdir/exclude/dir/2' -o -path 'searchdir/exclude/dir3' $ -prune \) ...` – Walf May 14 '18 at 01:59
1

only workable answer because it omits the -o option. jeezus. – mjs Nov 30 '19 at 15:11
!!! Make sure `-type f` is behind `-not $ -path ./build/external -prune $` otherwise you will have a bad day !!! – qräbnö Feb 01 '21 at 16:20
This is a great answer. I always end up crafting some pipe train because I can never remember the right order of find expressions to exclude more than one directory. This is the most straight forward solution and is really pretty easy to remember. Thank you Daniel! – MrJman006 Apr 25 '21 at 18:03
Nice answer! Also like @f10bit 's answer you can use `-name` option instead of `-path` and have the directory name, to exclude that directory at any level. Instead of specying the whole path. – Vandit Goel Oct 22 '21 at 10:02
To understand this answer, it might help some newcomers to `find` to know that the implied Boolean ANDing is [short-circuit](https://en.wikipedia.org/wiki/Short-circuit_evaluation) logic. Evaluating from left to right, only if the current `-not` expression evaluates to true is the next expression evaluated. – user2153235 Dec 24 '22 at 05:51

score 279 · Answer 4 · edited May 23 '17 at 12:34

There is clearly some confusion here as to what the preferred syntax for skipping a directory should be.

GNU Opinion

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

From the GNU find man page

Reasoning

-prune stops find from descending into a directory. Just specifying -not -path will still descend into the skipped directory, but -not -path will be false whenever find tests each file.

Issues with -prune

-prune does what it's intended to, but are still some things you have to take care of when using it.

find prints the pruned directory.
- TRUE That's intended behavior, it just doesn't descend into it. To avoid printing the directory altogether, use a syntax that logically omits it.
-prune only works with -print and no other actions.
- NOT TRUE. -prune works with any action except -delete. Why doesn't it work with delete? For -delete to work, find needs to traverse the directory in DFS order, since -deletewill first delete the leaves, then the parents of the leaves, etc... But for specifying -prune to make sense, find needs to hit a directory and stop descending it, which clearly makes no sense with -depth or -delete on.

Performance

I set up a simple test of the three top upvoted answers on this question (replaced -print with -exec bash -c 'echo $0' {} \; to show another action example). Results are below

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

Conclusion

Both f10bit's syntax and Daniel C. Sobral's syntax took 10-25ms to run on average. GetFree's syntax, which doesn't use -prune, took 865ms. So, yes this is a rather extreme example, but if you care about run time and are doing anything remotely intensive you should use -prune.

Note Daniel C. Sobral's syntax performed the better of the two -prune syntaxes; but, I strongly suspect this is the result of some caching as switching the order in which the two ran resulted in the opposite result, while the non-prune version was always slowest.

Test Script

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

Thank you for a very good analysis. Regarding "I strongly suspect this is the result of some caching" you can run this command: sudo sh -c "free && sync && echo 3 > /proc/sys/vm/drop_caches && free" to clear the cache (see http://unix.stackexchange.com/questions/87908/how-do-you-empty-the-buffers-and-cache-on-a-linux-system). — ndemou, Nov 19 '14 at 09:40
After few tests on those two with `-prune` I can tell there is rarely any difference. Do keep in mind that which command start first will benefit from cpu performance, the later **cpu warm up > performance drop** cause minor slow down (I did purge cache before each command as @ndemou suggestion) — Huy.PhamNhu, Sep 28 '17 at 17:35
Try switch number among `name1() name2() name3()` in @BroSlow test script above to change execute order to get a visual about what I said. In real life, it is unnoticeable between those two though. — Huy.PhamNhu, Sep 28 '17 at 17:47
You should not be -o which means or. so you are pruning in the first step and then forgetting all about it in the next. — mjs, Nov 30 '19 at 15:12
This is the best answer, IMHO. The bash script is also super recommended to look at as a good design example. Just one question though, why do you use command `date` (and subtract the numbers it returns), instead of using `time` command? — Kiteloopdesign, Jul 26 '22 at 19:12

DimiDak · Answer 5 · 2022-08-02T12:48:51.047

227

This is the only one that worked for me.

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

Searching for "MyFile" excluding "Directory". Give emphasis to the stars * .

edited Aug 02 '22 at 12:48

answered Mar 15 '18 at 10:02

DimiDak

4,820
2
26
32

35

This method works on macOS while the accepted answer doesn't. I know original question is for Linux. – Xavier Rubio Jansana Oct 03 '18 at 07:27
12

Note that you can add multiple `! -path '*/Directory/*'` to your command in succession to ignore multiple directories – Aclwitt Oct 21 '19 at 17:09
1

In a `docker container` only works with `sh -c "find..."` – Marcello DeSales Jan 16 '20 at 00:35
3

Worked great for me to locate native `package.json` files: `find . -name package.json ! -path '*/node_modules/*'` – fIwJlxSzApHEZIl Mar 19 '21 at 18:46
`find $(realpath .) -name "*.py" ! -path "$VIRTUAL_ENV/*"` if your excluded dir is absolute path, you have to make the search dir absolute as well. – James H Apr 29 '21 at 11:05
1

Nice and concise. Works on Ubuntu 20.0.4 LTS – Homunculus Reticulli May 14 '21 at 09:14
Am I assuming correctly that this has the same problem as GetFree's answer, i.e. that it still traverses the excluded directories? – AndreKR Jul 24 '21 at 15:51
There she is `find . -size 0 ! -path './.git*'` – caduceus Jun 06 '23 at 15:40

Gabriel Staples · Answer 6 · 2023-01-13T19:31:18.810

Tested in Linux Ubuntu 18.04 and 20.04.

find is incredibly important and powerful, but it is so nuanced and confusing!

How do I exclude a specific directory when searching for *.js files using find?

Quick example: exclude all directories with a given prefix

This is a really useful example that doesn't answer the OP's question directly, but is even more useful in my opinion:

@Kamil Dziedzic asked in a comment below my answer (corrected for grammar and punctuation):

How can I ignore directories with a given prefix? For example, I would like to exclude directories starting with _.

Here is how:

# Ignore all directories (and their contents, via `-prune`) beginning with
# prefix "prefix" at the lowest level of the specified directory (`.`). 
find . -not \( -path "./prefix*" -type d -prune \) | sort -V

# Ignore all directories (and their contents, via `-prune`) beginning with
# prefix "prefix" at any level recursively within the specified directory.
find . -not \( -path "*/prefix*" -type d -prune \) | sort -V

So, for a directory prefix of _, use whichever of these you want:

find . -not \( -path "./_*" -type d -prune \) | sort -V
find . -not \( -path "*/_*" -type d -prune \) | sort -V

Explanation:

. means "current directory"
* is a find wildcard, matching any number of any character (like the regular expression .*)
$ and $ are escaped parenthesis. They must be escaped with the backslash so that they get passed to find as parameters to find rather than getting processed by your shell interpreter itself (such as bash or sh or whatever shell you use)
-not  says to ignore files which match the conditions within those parenthesis.
-path "./prefix*" says to match all paths which begin with ./prefix, meaning all paths which are at the lowest level of the . directory you specified in your find command. -path "*/prefix*" will match all paths which begin with anything, followed by /prefix, meaning any path beginning with prefix at any level within any dir in your search path.
-type d says to only match directories. This gets "and"ed with the -path just specified, making it match only files which begin with your specified prefix and are of type "directory".
-prune says to not traverse into matching directories. From man find: "if the file is a directory, do not descend into it." Therefore, without the -prune option, the directory ./prefixWhateverDir itself would be excluded, but files ./prefixWhateverDir/file1.c and ./prefixWhateverDir/file2.c within that directory would NOT be excluded (even ./prefixWhateverDir/prefixFile1.c and ./prefixWhateverDir/prefixFile2.c would not be excluded--also since they are not of -type d). Adding -prune avoids traversing into the excluded directory, thereby excluding files within that directory as well. This might seem weird, but keep in mind in Linux and Unix systems, directories are "files" too, just special types of files which can be a prefix in the path to other files is all. So, with that in mind, having to use -prune makes more sense.
Piping to sort -V with | sort -V just sorts the output to be nice and alphabetical is all.

If you think that -not or -prune is required, but not both, that is incorrect. See the new section I just added below called "Addressing other comments" to see a detailed example of running the above commands with both -not and -prune, only -not, and only -prune. They are not the same thing.

Quick summary and answer to the OP's question:

This answers the OP's question directly.

Follow these patterns. See also my comment here. These are the best and most-effective patterns I have found, period. The escaped parenthesis ($ and $) and the -prune option are very important for speed. Read below to find out why.

Best patterns to use:

Remove the -name '*.js' part of each command below, of course, if you are looking for a generic answer and not trying to solve the OP's original question, which involved also finding only files with extension .js in their name.

# Exclude one path, and its contents, saving time by *not* recursing down the
# excluded path at all.
find . -name '*.js' -not \( -path "./dir_to_exclude" -prune \)

# Add the wildcard asterisk (`*`) to the end of the match pattern, as
# in "./dir_to_exclude*", to exclude all files & folders beginning with the
# name `./dir_to_exclude`. Prune to save time by *not* recursing down the
# excluded paths at all.
# - You can add the asterisk to the end of the pattern to apply this pattern to
#   all examples below as well, if desired.
# - This example pattern would exclude "./dir_to_exclude", "./dir_to_exclude1",
#   "./dir_to_exclude2", "./dir_to_exclude99", "./dir_to_exclude_some_long_name",
#   "./dir_to_exclude_another_long_name", etc., as well as exclude all **files**
#   beginning with this match pattern but not otherwise in an excluded dir.
find . -name '*.js' -not \( -path "./dir_to_exclude*" -prune \)

# Exclude multiple paths and their contents, saving time by *not* recursing down
# the excluded paths at all.
find . -name '*.js' \
    -not \( -path "./dir_to_exclude1" -prune \) \
    -not \( -path "./dir_to_exclude2" -prune \) \
    -not \( -path "./dir_to_exclude3" -prune \)


# If you change your "starting point" path from `.` to something else, be sure
# to update the beginning of your `-path` with that as well, like this:

find "some_dir" -name '*.js' -not \( -path "some_dir/dir_to_exclude" -prune \)

find "some_dir" -name '*.js' \
    -not \( -path "some_dir/dir_to_exclude1" -prune \) \
    -not \( -path "some_dir/dir_to_exclude2" -prune \) \
    -not \( -path "some_dir/dir_to_exclude3" -prune \)

The above patterns are the best because when the -prune option is on with escaped parenthesis as shown above, and when you specify the folder name like that (nothing after the folder name in this case), it excludes both the folder and its contents.

If you remove the parenthesis and the -prune option, -not -path "./dir_to_exclude" will undesirably exclude only the directory name, but not its contents. If you don't follow my recommended patterns above, you'd have to use -not -path "./dir_to_exclude" to exclude only the folder name, and -not -path "./dir_to_exclude/*" to exclude only the folder contents, and -not -path "./dir_to_exclude" -not -path "./dir_to_exclude/*" to exclude both.

Additionally, removing the parenthesis and -prune option from my examples above takes 2x~100x longer. That's a HUGE speed difference! Using the parenthesis and -prune option causes find to NOT recurse down the excluded directories, whereas find . -not -path "./dir_to_exclude" -not -path "./dir_to_exclude/*" would still waste vast amounts of time recursing down the excluded directory.

Discussion of nuances and rules of thumb

When using find:

You must include either a wildcard (*) or the "starting point" path in the -path you are trying to match. Examples:

Match exact paths relative to the "starting point" path by prefixing your -path to match with the "starting point" path:

# 1. with the "starting point" being the current directory, `.`
find . -not -path "./dir_to_exclude/*"
# or (same thing)
find -not -path "./dir_to_exclude/*"

# 2. with the "starting point" being the root dir, `/`
find / -not -path "/dir_to_exclude/*"

# 3. with the "starting point" being "some_dir"
find "some_dir" -not -path "some_dir/dir_to_exclude/*"

Again, notice that in all -path matches above, you must explicitly prefix the path with the "starting point" path. Otherwise, you can use a wildcard:

Match wildcard paths to find your -path at any level or sub-directory within your search path. ie: prefix your -path with *. Examples:

# match "./dir_to_exclude/file1" as well as 
#       "./another_dir/dir_to_exclude/file1"
find . -not -path "*/dir_to_exclude/*"

# match "/dir_to_exclude/file1" as well as 
#       "/another_dir/dir_to_exclude/file1"
find / -not -path "*/dir_to_exclude/*"

# match "some_dir/dir_to_exclude/file1" as well as 
#       "some_dir/another_dir/dir_to_exclude/file1"
find "some_dir" -not -path "*/dir_to_exclude/*"

Again, notice that in all -path matches above, I explictly prefixed the path with the * wildcard char to match at any level.

Use -ipath to do case-insensitive path matches. From man find:

-ipath pattern
       Like -path.  but the match is case insensitive.

Examples:

# exclude "./dir_to_exclude/*", as well as "./DIR_TO_EXCLUDE/*", and 
# "./DiR_To_eXcluDe/*", etc.
find . -not -ipath "./dir_to_exclude/*"

When not using the escaped parenthesis and the -prune option, find will still recurse down the excluded paths, making it as slow as mud. ☹️

When not using the escaped parenthesis and the -prune option, find . -not -path "./dir_to_exclude/*" excludes only the contents of the excluded dir, but NOT the excluded dir itself, and find . -not -path "./dir_to_exclude" excluded only the directory name itself, but NOT the contents (files and folders) within that directory! Use both to exclude both. Examples:

# exclude the files and folders within the excluded dir, but
# leaving "./dir_to_exclude" itself
find . -not -path "./dir_to_exclude/*"

# exclude the dir name only, but leaving (NOT excluding) all files and
# folders within that dir!
find . -not -path "./dir_to_exclude"

# exclude both the folder itself, as well as its contents
find . \
    -not -path "./dir_to_exclude/*" \
    -not -path "./dir_to_exclude"

All of the above examples in this "rules of thumb" section are pure garbage and trash ☹️. I'm kidding and exaggerating, but the point is: I think they are not nearly as good, for the reasons explained. You should wrap every single one of them with the escaped parenthesis and the -prune option, like this :

find .          -not \( -path "./dir_to_exclude/*" -prune \)
find            -not \( -path "./dir_to_exclude/*" -prune \)
find /          -not \( -path "/dir_to_exclude/*" -prune \)
find "some_dir" -not \( -path "some_dir/dir_to_exclude/*" -prune \)

find .          -not \( -path "*/dir_to_exclude/*" -prune \)
find /          -not \( -path "*/dir_to_exclude/*" -prune \)
find "some_dir" -not \( -path "*/dir_to_exclude/*" -prune \)

find .          -not \( -ipath "./dir_to_exclude/*" -prune \)

find .          -not \( -path "./dir_to_exclude/*" -prune \)
find .          -not \( -path "./dir_to_exclude" -prune \)
find . \
    -not \( -path "./dir_to_exclude/*" -prune \) \
    -not \( -path "./dir_to_exclude" -prune \)

The -prune option is really important. Here is what it means, from man find (emphasis added):

-prune True; if the file is a directory, do not descend into it. If -depth is given, then -prune has no effect. Because -delete implies -depth, you cannot usefully use -prune and -delete together.

For example, to skip the directory src/emacs and all files and directories under it, and print the names of the other files found, do something like this:
find . -path ./src/emacs -prune -o -print

The above content is my latest information as of 4 Sept. 2022. The below content is my older answer, which still has a ton of useful information, but doesn't cover the nuances as well as what I've presented above. Read it to gain more knowledge and see some more examples, applying what you learned above to what I present below.

Generic examples

Notice that the ./ (or */, see below) before and the /* (or *, but see the caveat below) after the folder name to exclude are required in order to exclude dir_to_exclude, and anything within it!

Also, for speed, and to not traverse excluded directories, notice the really important escaped grouping parenthesis and the -prune option. Ex: find -not $ -path "*/dir_to_exclude/*" -prune $.

To see examples of these escaped grouping parenthesis in the manual pages, run man find, and then press / to search. Search for the pattern \(, for instance, using the regular expression pattern \\\(. Press Enter to begin searching the man pages. Press N for "next match" while searching.

Summary

These work:

# [my favorite #1] exclude contents of `dir_to_exclude` at the search root
find -not -path "./dir_to_exclude/*"

# exclude all files & folders beginning with the name `dir_to_exclude` at the
# search root   
find -not -path "./dir_to_exclude*"

# [my favorite #2] exclude contents of `dir_to_exclude` at any level within your
# search path
find -not -path "*/dir_to_exclude/*"

# exclude all files & folders beginning with the name `dir_to_exclude` at any
# level within your search path
find -not -path "*/dir_to_exclude*"

# To exclude multiple matching patterns, use `-not -path "*/matching pattern/*"`
# multiple times, like this
find -not -path "*/dir_to_exclude1/*" -not -path "*/dir_to_exclude2/*"

[USE THESE] These work too, and are BETTER because they cause find to NOT unnecessarily traverse down excluded paths!:
(This makes a huge difference in speed (is 2x~100x faster)! See here and here. You can also search the man find pages locally for the strings $ and $ with the escaped search strings \\$ and \\$, respectively).

find -not \( -path "./dir_to_exclude" -prune \)  # works to exclude *both* the 
                                                 # directory *and* its contents
                                                 # here, here but does *not*
                                                 # exclude the contents as well
                                                 # when the directory name is
                                                 # written like this in the
                                                 # examples above
find -not \( -path "./dir_to_exclude*" -prune \)
find -not \( -path "./dir_to_exclude/*" -prune \)
find -not \( -path "*/dir_to_exclude" -prune \)  # same note as just above
find -not \( -path "*/dir_to_exclude*" -prune \)
find -not \( -path "*/dir_to_exclude/*" -prune \)

# To exclude multiple matching patterns at once, use the `-not \( ... \)` 
# pattern multiple times, like this
find -not \( -path "*/dir_to_exclude1/*" -prune \) \
     -not \( -path "*/dir_to_exclude2/*" -prune \)

...but these do NOT work:

# These do NOT work!
find -not -path "dir_to_exclude"
find -not -path "dir_to_exclude/*"
find -not -path "./dir_to_exclude"
find -not -path "./dir_to_exclude/"

The key is that generally, to make it work, you must begin each matching pattern with either ./ or */, and end each matching pattern with either /* or *, depending on what you're trying to achieve. I say "generally", because there are two noted exceptions in the -not $ ... $-style section above. You can identify these two exceptions by the comments to the right of them which say: # works here but not above.

Further Explanation:

[BEST, depending on what you want] This WORKS! Exclude all files and folders inside dir_to_exclude at the root of where you are searching. Note that this excludes all subfiles and subfolders inside dir_to_exclude, but it does NOT exclude the dir_to_exclude dir itself.
```
find -not $ -path "./dir_to_exclude/*" -prune $
```
Also exclude the dir_to_exclude dir itself (and any file or folder with a name which begins with these characters). Caveat: this also excludes dir_to_exclude1, dir_to_exclude2, dir_to_exclude_anyTextHere, etc. It excludes ANY file or folder which merely begins with the text dir_to_exclude and is in the root directory of where you're searching.
```
find -not $ -path "./dir_to_exclude*" -prune $
```
[BEST, depending on what you want] to recursively exclude a dir by this name at any level in your search path. Simply add a wildcard * to the front of the path too, rather than using the . to indicate the search root directory.
```
find -not $ -path "*/dir_to_exclude/*" -prune $
```
Recursively exclude any file or folder with a name which begins with the characters dir_to_exclude at any level in your search path. (See also the caveat above).
```
find -not $ -path "*/dir_to_exclude*" -prune $
```

Summary:

In ./, the . at the beginning means "start in the current directory" (or in */, the * is a wildcard to pick up any characters up to this point), and in /* at the end, the * is a wildcard to pick up any characters in the path string after the / character. That means the following:

"./dir_to_exclude/*" matches all subfiles and subfolders within dir_to_exclude in the root search directory (./), but does NOT match the directory itself.
"./dir_to_exclude*" matches all files and folders within the root search directory (./), including dir_to_exclude, as well as all contents within it, but also with the caveat it will match any file or folder name beginning with the characters dir_to_exclude.
"*/dir_to_exclude/*" matches all subfiles and subfolders within dir_to_exclude in any directory at any level in your search path (*/), but does NOT match the directory itself.
"*/dir_to_exclude*" matches all files and folders at any level (*/) within your search path with a name which begins with dir_to_exclude.

Going further

From there, I like to pipe to grep to search for certain matching patterns in the paths of interest. Ex: search for any path that is NOT inside the dir_to_exclude directory, and which has desired_file_name.txt in it:

# Case-sensitive; notice I use `\.` instead of `.` when grepping, in order to
# search for the literal period (`.`) instead of the regular expression
# wildcard char, which is also a period (`.`).
find -not \( -path "./dir_to_exclude/*" -prune \) \
    | grep "desired_file_name\.txt"

# Case-INsensitive (use `-i` with your `grep` search)
find -not \( -path "./dir_to_exclude/*" -prune \) \
    | grep -i "desired_file_name\.txt"

# To make `dir_to_exclude` also case INsensitive, use the `find` `-ipath` option
# instead of `-path`:
find -not -ipath \( -path "./dir_to_exclude/*" -prune \) \
    | grep -i "desired_file_name\.txt"

To exclude multiple matching patterns, simply use -not $ -path "*/matching pattern/*" -prune $ multiple times. Ex:

# Exclude all ".git" and "..git" dirs at any level in your search path
find -not \( -path "*/.git/*" -prune \) -not \( -path "*/..git/*" -prune \)

I use the above example as part of my sublf alias here (update: that alias is being expanded and moved into a sublf.sh script in this folder here instead). This alias allows me to use the fzf fuzzy finder to quickly search for and open multiple files in Sublime Text. See the links above for the latest version of it.

alias sublf='FILES_SELECTED="$(find -not \( -path "*/.git/*" -prune \) \
-not \( -path "*/..git/*" -prune \) \
| fzf -m)" \
&& echo "Opening these files in Sublime Text:" \
&& echo "$FILES_SELECTED" \
&& subl $(echo "$FILES_SELECTED")'

Addressing other comments

1. Both `-prune` and `-not` are required to get the desired effect

Comment from @Ritin (fixed for formatting/wording):

@Gabriel Staples, both -not and -prune are not required. use either -prune or -not: find . $ -path '*frontend*' -o -path '*/\.*' -o -path "*node_modules*" $ -prune -o -type f |sort -V

My response:

@Ritin, that's incorrect. To get the effect I want, both -not and -prune are required. This is exactly what I'm talking about when I said at the beginning of my answer:

find is incredibly important and powerful, but it is so nuanced and confusing!

Run the following examples in my eRCaGuy_hello_world/cpp/ folder to see the difference:

both -not and -prune:

Command and output:
```
eRCaGuy_hello_world/cpp$ find . -not $ -path "./template*" -type d -prune $ | sort -V | grep -i '\./template'
./template_non_type_template_params_print_int_TODO.cpp
```
As you can see, this command leaves only the one file: ./template_non_type_template_params_print_int_TODO.cpp. It strips all directories which begin with ./template in their path, as well as all contents (files and folders) within them. That's the effect I want.

-not only:

Command and output:

eRCaGuy_hello_world/cpp$ find . -not \( -path "./template*" -type d \) | sort -V | grep -i '\./template'
./template_function_sized_array_param/print_array_calls_by_array_size.ods
./template_function_sized_array_param/readme.md
./template_function_sized_array_param/regular_func
./template_function_sized_array_param/regular_func.cpp
./template_function_sized_array_param/template_func
./template_function_sized_array_param/template_func.cpp
./template_non_type_template_params_print_int_TODO.cpp
./template_practice/explicit_template_specialization.cpp
./template_practice/research/Buckys C++ Programming Tutorials - 61 - Template Specializations - YouTube.desktop
./template_practice/research/Link to explicit (full) template specialization - cppreference.com%%%%%+.desktop
./template_practice/research/Link to template c++ - Google Search%%%%%.desktop
./template_practice/research/Link to template specialization - Google Search [videos]%%%%%.desktop
./template_practice/research/Link to template specialization - Google Search%%%%%.desktop
./template_practice/research/Template (C++) - Wikipedia.desktop
./template_practice/research/Template (C++) - Wikipedia.pdf
./template_practice/research/Template (C++) - Wikipedia_GS_edit.pdf
./template_practice/research/partial template specialization - cppreference.com.desktop
./template_practice/research/(7) Template Specialization In C++ - YouTube.desktop
./template_practice/run_explicit_template_specialization.sh

As you can see, this command strips out the two folders beginning with ./template, namely: ./template_function_sized_array_param and ./template_practice. It still recurses into those directories, however, leaving all of the contents (files and folders) within those directories. The file ./template_non_type_template_params_print_int_TODO.cpp is also present, as before.

-prune only:

Command and output:
```
eRCaGuy_hello_world/cpp$ find . $ -path "./template*" -type d -prune $ | sort -V | grep -i '\./template'
./template_function_sized_array_param
./template_practice
```
As you can see, this command only finds the ./template_function_sized_array_param and ./template_practice folders themselves, but the -prune option says to not recurse down into those directories, so it finds none of their contents (files and folders) within them. It also erroneously strips out the ./template_non_type_template_params_print_int_TODO.cpp file, which I don't want. Using -prune only appears to be the exact opposite of using -not only.

Using both -not and -prune together produces the effect I want.

References:

@holms, I don't have a Mac, but the [MacOs manual for `find`](https://ss64.com/osx/find.html) shows that `-not` and `-path` are both supported, so any idea why it's not working, or how to make it work on Mac? — Gabriel Staples, Nov 24 '21 at 16:38
Actually, didn't work for me. The reason is that "this works" needs to be replaced by `find -not -path "./dir_to_exclude*"`, without the last slash. Your version still lists the dir_to_exclude. — emk2203, Dec 28 '21 at 12:51
@emk2203, I see what you mean and I've massively updated my answer as a result. I still prefer the matching pattern `"./dir_to_exclude/*"`, however, as `"./dir_to_exclude*"` will have the unintended side-effect of matching any file or folder which begins with the string `dir_to_exclude`, such as `dir_to_exclude1`, `dir_to_exclude2`, `dir_to_exclude some other string`, etc. — Gabriel Staples, Jan 03 '22 at 01:33
The situation where I encountered it was when piping file names to `tar`. With the `dir_to_exclude` still in the output, even if there are no files, the dir and its contents get compressed and added to the archive nonetheless. I agree with your concerns, but there are cases when you have to exclude the directory as well or the desired action fails. — emk2203, Jan 03 '22 at 21:12
Really great answer. Congrats. Yeah, the situation with the folder itelf not being excluded is concerning. For example, I came to this thread because I want to exclude root-level ./proc* and that ./proc folder itself. Which is easy because it's root level - thanks! But if it wasn't then, as an example, folders under Maildir would be excluded if they begin with 'proc', like foo/processing or foo/processed. Does anyone have a solution to this? (Note: This is still a part of the top-level question, just looking for a more complete solution, and shouldn't need to be a different question.) — TonyG, Aug 31 '22 at 15:18
@TonyG, I need to update my answer. There's a lot more to be yet told, and there are many more subtleties yet to explain. You asked: "I want to exclude root-level `./proc*` and that `./proc` folder itself." To do that, here's what you need: `find / -not $ -path "/proc" -prune $`. When the `-prune` option is on with parenthesis like that, and you specify the folder name like that, it excludes both the folder _and_ its contents. — Gabriel Staples, Aug 31 '22 at 16:18
Leaving this for posterity: If you can, be explicit about an absolute path: `find / -not $ -path "/proc/*" -prune $ -not $ -path "/proc" $`. Note the first group for "/proc/*". That works. However, contrary to the current Answer, "./proc/*" does not work - that is, when the path is `/` and the filter path has a period to search relative to the search path. I don't understand this anomaly, just ponint it out. See also my note below about order of arguments. https://stackoverflow.com/questions/4210042/how-do-i-exclude-a-directory-when-using-find#comment129897610_47341478 — TonyG, Aug 31 '22 at 16:32
I see we're both in here at the same time. Good follow-up! Looking forward to more. — TonyG, Aug 31 '22 at 16:33
@TonyG, I just massively updated my answer. See the all-new content in the first half of my answer. — Gabriel Staples, Sep 05 '22 at 04:24
How can I ignore directories with given prefix. For example I would like to exclude directories starting with `_`. — Kamil Dziedzic, Jan 02 '23 at 16:32
@KamilDziedzic, it took some effort for me to figure out, but the answer is: `find . -not $ -path "./_*" -type d -prune $ | sort -V` or `find . -not $ -path "*/_*" -type d -prune $ | sort -V`, depending on what you want to do. See the top of my answer. I just added an entire section dedicated just to you. — Gabriel Staples, Jan 03 '23 at 18:12
@Gabriel Staples, both -not and prune are not required. use either prune or -not ```find . $ -path '*frontend*' -o -path '*/\.*' -o -path "*node_modules*" $ -prune -o -type f |sort -V``` — Ritin, Jan 04 '23 at 03:30
@Ritin, that is incorrect. Both `-prune` and `-not` are required to get my desired effect. See the new section I just added to the bottom of the question, called "Addressing other comments" to see a detailed example of running the commands at the top of my answer with both `-not` and `-prune`, only `-not`, and only `-prune`. Using one or the other is definitely not the same thing. This is exactly what I'm talking about when I said at the top of my answer: "`find` is incredibly important and powerful, but _it is so nuanced and confusing!_" — Gabriel Staples, Jan 04 '23 at 15:46
@Gabriel Staples, must have missed your desired effect. Great explanation though. Thanks. — Ritin, Jan 05 '23 at 15:05

score 79 · Answer 7 · answered Nov 17 '10 at 23:01

79

One option would be to exclude all results that contain the directory name with grep. For example:

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

answered Nov 17 '10 at 23:01

Joshua

5,336
1
28
42

69

This will make your search very slow – Dorian Feb 19 '13 at 12:01
7

This one worked for me, others (which use `-prune`) - doesn't. – Andron Mar 28 '13 at 11:03
7

Slow in large results, but useful in smaller sets. But how to exclude multiple directories using grep? Of course this way: `find . -name '*.js' | grep -v excludeddir | grep -v excludedir2 | grep -v excludedir3` but there may be some one grep way. – Timo Kähkönen May 01 '13 at 09:47
+1 because this gave me the idea to use grep to add color to find. – Nick Mar 12 '14 at 13:22
Where exactly would I add the `-exec` to execute something on found files? I'm looking for something like this where I can exclude paths based on regexp and grep seems to be nice but don't know how to pipe this to tar. – HMR May 24 '14 at 00:35
7

If you want to perform multiple greps then you would be better off writing it as regular expressions: `egrep -v '(dir1|dir2|dir3)'`. However, in this specific case study, it would be better to exclude directories within `find` itself. – Laurence Nov 10 '14 at 09:58
1

yes, and you don't need parentheses and it would be better to use ^ to ensure it matches directoryname at the start of the string eg: find . -name '*.js' | egrep -v "^\./excludeddir1|^\./excludeddir2" – Sofija Sep 03 '15 at 11:14
1

This is good because it lets you exclude items from a top level search, e.g. a directory search with `-maxdepth 1` – M1ke Sep 03 '15 at 11:21
true, and just noticed, ^ is enough first time, eg this regex will do same and is simpler "^\./excludeddir1|\./excludeddir2" ... might make a difference for lots of top level search to exclude – Sofija Sep 03 '15 at 11:30
Why dip into egrep with a nasty regex when `grep -ve dir1 -edir2 -edir3` works just as well (and is probably faster)? – CSTobey Aug 23 '16 at 15:13
This is also useful if you want to exclude a directory that appears at multiple levels within your hierarchy e.g. `grep -v build` – j b Feb 01 '19 at 10:25
This is the *only* solution that helped me find all `package.json` files that weren't inside of a `node_modules` folder. `find . -name 'package.json' | grep -v node_modules` – fIwJlxSzApHEZIl Jun 05 '19 at 17:08
I've been here several times over the years and this has never worked. I now realize due to comment here https://stackoverflow.com/a/16595367/3281336 that I needed to change `-path node_modules` to `-path ./node_modules`. The syntax of the string after -path must match the output of what find would print if it were going to print that directory! – PatS Aug 05 '19 at 17:52
Won't work if reading the excluded directory causes an error that terminates `find`. Also extremely inefficient. – ivan_pozdeev Dec 18 '19 at 19:38
1

re *This will make your search very slow* Maybe, but at least it works. The whole efficiency thing is somewhat besides the point if you are typing on the terminal and reasonably deep in the file hierarchy, i.e. not at `/` or `~`. If this is being executed repeatedly within a program, then sure, messing around with `prune` (who pretty much no proponent here bothered to explain the syntax of) is better. – JL Peyret Jun 18 '20 at 19:08
Seconding JL Peyret- this *may* be slow but it *just works*. Compare to all the issues people had with the -prune and -not -path answers. When I want to do a search quickly at the command line (the usual case), this is the first thing to try. If writing a script that has to be fast, maybe not. – ttulinsky Aug 03 '20 at 05:34
Ok, this is pretty smart. Not having to remember new syntax I mean. – Vasantha Ganesh Jul 28 '21 at 10:37

mpapis · Answer 8 · 2013-04-03T11:44:25.243

48

I prefer the -not notation ... it's more readable:

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

edited Apr 03 '13 at 11:44

answered Nov 17 '10 at 23:22

mpapis

52,729
14
121
158

6

Sorry, it doesn't work. The man page for `find` says: "To ignore a directory and the files under it, use -prune". – Christian Davén Aug 25 '12 at 20:25
11

This is wrong. It doesn't prevent find from entering the directory and traversing all the files inside. – GetFree Apr 01 '13 at 01:37
`find . -iname '*' -and -not -path './somePath'` doesn't prevent it from entering said directory. – Lemmings19 May 30 '13 at 00:00
This helped me with .git path `find . -iname '*' -not -path './.git/*'` – Mark Shust at M.academy Sep 27 '13 at 20:01
11

@rane: More specifically `find . -not -path "*/.git*"` would be what you want. – Jess Nov 28 '13 at 17:50
I used find * and it didn't list hidden directories like .git. Might be what you're looking for – justin Mar 16 '14 at 12:05
@GetFree: There never was a requirement to /not/ descend into the directory. I'll give you that this is less efficient. – Engineer2021 Apr 21 '15 at 16:02
This is great! I used it to delete `data/*` sub-dirs except for the top-level directory 'data', leaving `data/*` files in place (this handles deleting unpacked zip/tgz archives, without deleting the archives themselves). `find ./data -type d -and -not -regex "^./data$" -prune -exec rm -rf {} \;` – stason Oct 17 '18 at 02:54

Drew Frezell · Answer 9 · 2010-11-17T23:07:40.470

39

Use the -prune option. So, something like:

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

The '-type d -name proc -prune' only look for directories named proc to exclude.
The '-o' is an 'OR' operator.

edited Nov 17 '10 at 23:07

answered Nov 17 '10 at 23:01

Drew Frezell

2,628
21
13

4

This is the only pure-"find" solution that worked for me. The directories I wished to exclude are NOT immediately below the current working directory. – Lambart Apr 15 '13 at 23:06
10

However, adding `-print` to the end may improve results. `find . -type d -name .hg -prune -o -name data` ignored the contents of the (multiple) `.hg` directories, but listed the `.hg` directories themselves. With `-print`, it only listed the "data" directories I was seeking. – Lambart Nov 04 '13 at 19:39
yeah, significantly better explained than the accepted answer. and it works. Here's a flavor that finds markdowns, except those under `/node_modules/` : `find . -name node_modules -prune -o -name '*.md'` Nothing wrong with wanting to add extra stuff like -print, but at least lets have something basic that works first. – JL Peyret Jun 18 '20 at 19:14

wisbucky · Answer 10 · 2017-11-29T19:58:44.363

-prune definitely works and is the best answer because it prevents descending into the dir that you want to exclude. -not -path which still searches the excluded dir, it just doesn't print the result, which could be an issue if the excluded dir is mounted network volume or you don't permissions.

The tricky part is that find is very particular about the order of the arguments, so if you don't get them just right, your command may not work. The order of arguments is generally as such:

find {path} {options} {action}

{path}: Put all the path related arguments first, like . -path './dir1' -prune -o

{options}: I have the most success when putting -name, -iname, etc as the last option in this group. E.g. -type f -iname '*.js'

{action}: You'll want to add -print when using -prune

Here's a working example:

# 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

+1 on this. Consider these statements: `find / -type f -not $ -path "/proc" -prune $ -not $ -path "/proc/*" -prune $ -print | more` and `find / -not $ -path "/proc" -prune $ -not $ -path "/proc/*" -prune $ -type f -print | more`. The output is different simply when `-type f' is moved from front to back. The second form has the correct result : the folders are eliminated before it checks for files. In the first form, it looks for files first, and filenames don't match the path filter. (Ubuntu 20) — TonyG, Aug 31 '22 at 16:03

score 19 · Answer 11 · answered Mar 07 '18 at 10:20

There are plenty of good answers, it just took me some time to understand what each element of the command was for and the logic behind it.

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

find will start finding files and directories in the current directory, hence the find ..

The -o option stands for a logical OR and separates the two parts of the command :

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

Any directory or file that is not the ./misc directory will not pass the first test -path ./misc. But they will be tested against the second expression. If their name corresponds to the pattern *.txt they get printed, because of the -print option.

When find reaches the ./misc directory, this directory only satisfies the first expression. So the -prune option will be applied to it. It tells the find command to not explore that directory. So any file or directory in ./misc will not even be explored by find, will not be tested against the second part of the expression and will not be printed.

Everyone's got a solution but yours explained it the best. I was adamant to have -name be used first rather than -path. Your explanation was adequate to arrive at what I wanted. find . -name "*.txt" -print -o -path ./misc -prune — Vendetta V, Apr 24 '20 at 17:27

score 18 · Answer 12 · answered Jan 18 '16 at 17:06

18

This is the format I used to exclude some paths:

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

I used this to find all files not in ".*" paths:

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

answered Jan 18 '16 at 17:06

user1882879

215
2
5

1

I tried this and it still descends into the directories, so speed is definitely not improved. – Br.Bill Aug 29 '18 at 18:37

score 16 · Answer 13 · answered Aug 30 '17 at 04:05

The -path -prune approach also works with wildcards in the path. Here is a find statement that will find the directories for a git server serving multiple git repositiories leaving out the git internal directories:

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

cycollins · Answer 14 · 2019-09-03T21:45:57.900

a good trick for avoiding printing the pruned directories is to use -print (works for -exec as well) after the right side of the -or after -prune. For example, ...

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

will print the path of all files beneath the current directory with the `.j2" extension, skipping all hidden directories. Neat. But it will also print the print the full path of each directory one is skipping, as noted above. However, the following does not, ...

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

because logically there's a hidden -and after the -iname operator and before the -print. This binds it to the right part of the -or clause due to boolean order of operations and associativity. But the docs say there's a hidden -print if it (or any of its cousins ... -print0, etc) is not specified. So why isn't the left part of the -or printing? Apparently (and I didn't understand this from my first reading the man page), that is true if there there is no -print -or -exec ANYWHERE, in which case, -print is logically sprinkled around such that everything gets printed. If even ONE print-style operation is expressed in any clause, all those hidden logical ones go away and you get only what you specify. Now frankly, I might have preferred it the other way around, but then a find with only descriptive operators would apparently do nothing, so I guess it makes sense as it is. As mentioned above, this all works with -exec as well, so the following gives a full ls -la listing for each file with the desired extension, but not listing the first level of each hidden directory, ...

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

For me (and others on this thread), find syntax gets pretty baroque pretty quickly, so I always throw in parens to make SURE I know what binds to what, so I usually create a macro for type-ability and form all such statements as ...

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

It's hard to go wrong by setting up the world into two parts this way. I hope this helps, though it seems unlikely for anyone to read down to the 30+th answer and vote it up, but one can hope. :-)

score 12 · Answer 15 · edited Oct 08 '15 at 19:21

12

To exclude multiple directories:

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

To add directories, add -o -path "./dirname/*":

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

But maybe you should use a regular expression, if there are many directories to exclude.

edited Oct 08 '15 at 19:21

Peter Mortensen

30,738
21
105
131

answered Mar 19 '14 at 11:03

JBENOIT

421
3
14

score 12 · Answer 16 · answered Mar 25 '21 at 06:45

12

If anyone's researching on how to ignore multiple paths at once. You can use bash arrays (works perfectly on GNU bash, version 4.4.20(1)-release)

#!/usr/bin/env bash

# This script helps ignore unnecessary dir paths while using the find command

EXCLUDE_DIRS=(
    "! -path /*.git/*"
    "! -path /*go/*"
    "! -path /*.bundle/*"
    "! -path /*.cache/*"
    "! -path /*.local/*"
    "! -path /*.themes/*"
    "! -path /*.config/*"
    "! -path /*.codeintel/*"
    "! -path /*python2.7/*"
    "! -path /*python3.6/*"
    "! -path /*__pycache__/*"
)
find $HOME -type f ${EXCLUDE_DIRS[@]}

# if you like fzf

find $HOME -type f ${EXCLUDE_DIRS[@]} | fzf --height 40% --reverse

Also for some reason, you won't be able to ignore /bin/ directory paths.

answered Mar 25 '21 at 06:45

Bhupesh Varshney

1,522
14
19

I love that this works without using `-prune`! – alec Aug 19 '21 at 20:22
For `__pycache__` to be ignored (in any nested directory as well as all it's contents) I needed to replace `/*__pycache__/*` with `./*__pycache__/*`. – ideasman42 Oct 17 '21 at 23:15
What also works is to store the arguments of excluded dirs without the quotes in a file, one for each line, and then call it with `find $HOME -type f $(< ~/excludelist)`. File has first line with `! -path /*.git/*`, second line with `! -path /*.mozilla/*` and so forth. – emk2203 Oct 19 '21 at 09:20

score 9 · Answer 17 · answered Jun 03 '22 at 09:45

9

If you are looking for a high-performance answer, then it is:

find . -type d -name node_modules -prune -false -o -type f

Use -false to exclude node_modules itself.

It will be 3x faster than -not -path approach in a directory with 10000 files in node_modules.

find . -type f -not -path '*node_modules*'

And if node_modules has more files, you shall get a much higher performance.

answered Jun 03 '22 at 09:45

tianjianchn

431
5
7

(shoot me now), is there a way to exclude from the exclusion? i.e. skip all hidden folders `*/.*` except `*/.vscode`? – Frank N Jun 29 '22 at 07:34
@FrankNocke try something like `find . $ -type d -name '.?*' ! -name '.vscode' $ -prune -false -o -name '*.json'` – tianjianchn Jul 01 '22 at 05:59
Wow. this is a wonderful use of `-prune`! – alxndr Aug 23 '22 at 18:37

score 8 · Answer 18 · edited Oct 08 '15 at 19:20

8

For a working solution (tested on Ubuntu 12.04 (Precise Pangolin))...

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

will search for MP3 files in the current folder and subfolders except in dir1 subfolder.

Use:

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

...to exclude dir1 AND dir2

edited Oct 08 '15 at 19:20

Peter Mortensen

30,738
21
105
131

answered Dec 09 '13 at 10:12

james dupin

81
1
1

Doesn't work for me. Neither do any of the above answers. RedHat. – Chozang Jan 14 '20 at 19:45

score 7 · Answer 19 · answered May 29 '20 at 11:01

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

The example above finds all *.js files under the current directory, excluding folders .git and .hg, does not matter how deep these .git and .hg folders are.

Note: this also works:

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

but I prefer the ** notation for consistency with some other tools which would be off topic here.

score 6 · Answer 20 · answered Aug 29 '14 at 20:41

6

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

seems to work the same as

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

and is easier to remember IMO.

answered Aug 29 '14 at 20:41

dansch

6,059
4
43
59

Victoria Stuart · Answer 21 · 2019-07-23T16:38:48.143

TLDR: understand your root directories and tailor your search from there, using the -path <excluded_path> -prune -o option. Do not include a trailing / at the end of the excluded path.

Example:

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

To effectively use the find I believe that it is imperative to have a good understanding of your file system directory structure. On my home computer I have multi-TB hard drives, with about half of that content backed up using rsnapshot (i.e., rsync). Although backing up to to a physically independent (duplicate) drive, it is mounted under my system root (/) directory: /mnt/Backups/rsnapshot_backups/:

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

The /mnt/Backups/rsnapshot_backups/ directory currently occupies ~2.9 TB, with ~60M files and folders; simply traversing those contents takes time:

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

Thus, anytime I need to search for a file on my / (root) partition, I need to deal with (avoid if possible) traversing my backups partition.

EXAMPLES

Among the approached variously suggested in this thread (How to exclude a directory in find . command), I find that searches using the accepted answer are much faster -- with caveats.

Solution 1

Let's say I want to find the system file libname-server-2.a, but I do not want to search through my rsnapshot backups. To quickly find a system file, use the exclude path /mnt (i.e., 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!

... finds that file in just a few seconds, while this take much longer (appearing to recurse through all of the "excluded" directories):

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

Solution 2

The other solution offered in this thread (SO#4210042) also performs poorly:

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

SUMMARY | CONCLUSIONS

Use the approach illustrated in "Solution 1"

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

i.e.

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

noting that whenever you add the trailing / to the excluded path, the find command then recursively enters (all those) /mnt/* directories -- which in my case, because of the /mnt/Backups/rsnapshot_backups/* subdirectories, additionally includes ~2.9 TB of files to search! By not appending a trailing / the search should complete almost immediately (within seconds).

"Solution 2" (... -not -path <exclude path> ...) likewise appears to recursively search through the excluded directories -- not returning excluded matches, but unnecessarily consuming that search time.

Searching within those rsnapshot backups:

To find a file in one of my hourly/daily/weekly/monthly rsnapshot backups):

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

Excluding a nested directory:

Here, I want to exclude a nested directory, e.g. /mnt/Vancouver/projects/ie/claws/data/* when searching from /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

Aside: Adding -print at the end of the command suppresses the printout of the excluded directory:

$ 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

It's not the size of the files that slows `find`, it's the *number of directory entries* it must examine. So it's much worse if you have many, many small files (especially if they are all multiply linked!) than if you just have a handful of multi-gigabyte files. — Toby Speight, Oct 02 '18 at 09:44
@TobySpeight: good point. I mentioned the search space size to indicate scale, which also contains many files. A quick search of root (/) with `sudo ls -R / | wc -l` indicates ~76.5M files (most of which are backed up except "non-config" system files); `/mnt/Vancouver/` with `ls -R | wc -l` indicates ~2.35M files; `/home/victoria/` contains 0.668M files. — Victoria Stuart, Oct 02 '18 at 15:51
None of the examples here works for me to actually NOT descend into a directory with "-prune" (I am trying to avoid searching under ~/Library): ``` find . -not $ -path ./Library/ -prune $ -name IMG_3968\* ./Pictures/2021/TX/Galveston/IMG_3968.jpeg find: ./Library/Application Support/com.expressvpn.ExpressVPN/data: Permission denied find: ./Library/Saved Application State/com.installbuilder.appinstaller.savedState: Permission denied ./tmp/wd/Heroes/2021-01-25/IMG_3968.jpeg ``` As you see, it actually *goes* quite deeply into ./Library. — Vlad K., Jul 25 '22 at 18:36

score 6 · Answer 22 · answered Feb 27 '20 at 18:43

You can also use regular expressions to include / exclude some files /dirs your search using something like this:

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

This will only give you all js, vue, css, etc files but excluding all files in the node_modules and vendor folders.

score 5 · Answer 23 · edited Apr 13 '17 at 12:22

5

None of previous answers is good on Ubuntu. Try this:

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

I have found this here

edited Apr 13 '17 at 12:22

Community

1
1

answered Sep 23 '13 at 18:25

Sixro

402
4
16

I don't see any reason why any of the answers with more than 100 points shouldn't work on Ubuntu. – Axel Beckert Sep 02 '15 at 00:10
find is everywhere the same implementation on all Linux distributions — the one from the GNU Project. The only difference might be the versions. But the changes in the past decade were not that invasive, except maybe for permission matching. – Axel Beckert Apr 03 '20 at 09:21

Siju V · Answer 24 · 2016-06-25T10:48:24.960

5

You can use the prune option to achieve this. As in for example:

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

Or the inverse grep “grep -v” option:

find -iname example.com | grep -v beta

You can find detailed instructions and examples in Linux find command exclude directories from searching.

edited Jun 25 '16 at 10:48

answered Jul 21 '15 at 03:52

Siju V

143
1
5

The grep solution is the only one that excludes all directories by the same name. When trying to exclude "node_modules" that is quite useful. – bmacnaughton May 08 '17 at 03:40
3

@bmacnaughton - not true! I came here specifically looking to exclude "node_modules" and after reading many fine answers I settled on `find . -type f -print -o -path "*/node_modules" -prune` ... using the wildcard this skips "node_modules" at any level; using `-print` on the first alternative `-type f -print` makes only that part print, so the "node_modules" directories themselves are not listed. (it can also be reversed: `find . -path "*/node_modules" -prune -o -type f -print`) – Stephen P Feb 22 '18 at 20:34
what is */ doing there. What is the exact file you want to exclude.Are ypu using it as wildcard? – Siju V Feb 23 '18 at 00:37
1

@StephenP, thanks for pointing this out; I learned the difference between using `./node_modules` and `*/node_modules` from it. For my case, where `node_modules` only exists in the the directory I start the search in (and under that `node_modules` directory), I can use `find . -type f -print -o -path "./node_modules" -prune` because there won't be a `node_modules` directory under any other directory. – bmacnaughton Feb 25 '18 at 15:31
1

@SijuV - in the directory where I was searching there was a `node_modules` subdirectory, but there were also subdirectories that had their own _node_modules_ ... using `./node_modules` matches only the subdirectory `node_modules` under the current directory `.` and prunes it; using `*/node_modules` matches and prunes the directory at any depth, because the `*` as a [glob](http://tldp.org/LDP/abs/html/globbingref.html) matches any leading path prefix, such as `./test5/main/node_modules`, not only the `./` prefix. The `*` is a wildcard, but as a glob not as a regex. – Stephen P Feb 26 '18 at 17:53
If this is a project using git, you might just do `git ls-files |grep "*.js"`, since presumably the .gitignore file specifies which files you usually want to ignore (like `node_modules`) and `git ls-files` shows all project files (ignoring those in `.gitignore`). – Peter W Jun 22 '18 at 00:23

score 5 · Answer 25 · edited Feb 12 '19 at 19:56

5

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

edited Feb 12 '19 at 19:56

Dima Lituiev

12,544
10
41
58

answered Nov 17 '10 at 23:01

The Archetypal Paul

41,321
20
104
134

1

Can't get this one to work. `find ~/Projects -name '*.js' -\! -name 'node_modules' -prune` is still turning up files with `node_modules` in their path – mpen May 02 '17 at 16:17
3

@mpen , From https://stackoverflow.com/questions/4210042/how-to-exclude-a-directory-in-find-command/16595367#16595367, I learned that the syntax you want is `find ~/Projects -path ~/Projects/node_modules -prune -o -name '*.js' -print`. The name of that path must match exactly what find would print if it were going to print the directory. – PatS Aug 05 '19 at 18:00

EIIPII · Answer 26 · 2020-02-25T15:40:36.530

5

The following commands works:

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

If You have a problem with find, use the -D tree option to view the expression analysis information.

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

Or the -D all, to see all the execution information.

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

edited Feb 25 '20 at 15:40

answered Feb 25 '20 at 15:29

EIIPII

1,791
1
17
10

score 4 · Answer 27 · edited Oct 08 '15 at 19:22

4

This is suitable for me on a Mac:

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

It will exclude vendor and app/cache dir for search name which suffixed with php.

edited Oct 08 '15 at 19:22

Peter Mortensen

30,738
21
105
131

answered Mar 18 '15 at 07:56

jiahut

1,451
15
14

Better put single quotes around '*.php' or you're not going to find what you're looking for. – Br.Bill Aug 29 '18 at 18:42

score 3 · Answer 28 · answered May 30 '13 at 16:56

I was using find to provide a list of files for xgettext, and wanted to omit a specific directory and its contents. I tried many permutations of -path combined with -prune but was unable to fully exclude the directory which I wanted gone.

Although I was able to ignore the contents of the directory which I wanted ignored, find then returned the directory itself as one of the results, which caused xgettext to crash as a result (doesn't accept directories; only files).

My solution was to simply use grep -v to skip the directory that I didn't want in the results:

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

Whether or not there is an argument for find that will work 100%, I cannot say for certain. Using grep was a quick and easy solution after some headache.

score 3 · Answer 29 · answered Nov 16 '17 at 19:56

3

For those of you on older versions of UNIX who cannot use -path or -not

Tested on SunOS 5.10 bash 3.2 and SunOS 5.11 bash 4.4

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

answered Nov 16 '17 at 19:56

JaredTS486

436
5
16

Could pass more than the specified directory. – MUY Belgium Mar 23 '18 at 09:44

score 2 · Answer 30 · edited May 23 '17 at 12:02

how-to-use-prune-option-of-find-in-sh is an excellent answer by Laurence Gonsalves on how -prune works.

And here is the generic solution:

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

To avoid typing /path/to/seach/ multiple times, wrap the find in a pushd .. popd pair.

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

From https://stackoverflow.com/questions/4210042/how-to-exclude-a-directory-in-find-command/16595367#16595367, I learned that the syntax used for the `-path` must match the name that find would print if it were to print the directory so, for example, `find . -path ./.git -prune -o -print`, or `find $HOME/foo -path $HOME/foo/.git -prune -o -print` Some of the answers just say `-path somedir` which unfortunately is not exact enough to be useful. — PatS, Aug 05 '19 at 18:03

score 2 · Answer 31 · edited May 12 '17 at 08:56

2

I tried command above, but none of those using "-prune" works for me. Eventually I tried this out with command below:

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

edited May 12 '17 at 08:56

ImportanceOfBeingErnest

321,279
53
665
712

answered May 12 '17 at 07:08

Jolly Liu

21
1

score 2 · Answer 32 · answered Mar 27 '18 at 10:26

2

For what I needed it worked like this, finding landscape.jpg in all server starting from root and excluding the search in /var directory:

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

find / -maxdepth 1 -type d lists all directories in /

grep -v /var excludes `/var' from the list

xargs -I '{}' find '{}' -name landscape.jpg execute any command, like find with each directory/result from list

answered Mar 27 '18 at 10:26

adrianTNT

3,671
5
29
35

Wait a second, `/` is not excluded yet. You may need `sed 1d`. – Simba Jul 01 '19 at 10:12

score 2 · Answer 33 · answered Oct 18 '20 at 07:56

I consider myself a bash junkie, BUT ... for the last 2 years have not find a single bash user friendly solution for this one. By "user-friendly" I mean just a single call away, which does not require me to remember complicated syntax + I can use the same find syntax as before , so the following solution works best for those ^^^

Copy paste this one in your shell and source the ~/.bash_aliases :

cat << "EOF" >> ~/.bash_aliases
# usage: source ~/.bash_aliases , instead of find type findd + rest of syntax
findd(){
   dir=$1; shift ;
   find  $dir -not -path "*/node_modules/*" -not -path "*/build/*" \
      -not -path "*/.cache/*" -not -path "*/.git/*" -not -path "*/venv/*" $@
}
EOF

Of course in order to add or remove dirs to exclude you would have to edit this alias func with your dirs of choice ...

Meir Gabay · Answer 34 · 2021-03-20T09:52:21.687

Another example when using multiple patterns -o -name

To search in the root directory / for all *.tpl, *.tf files, excluding files which reside in /src/.terraform/ and /code/.

$ find / -type f \( -name '*.tf' -o -name '*.tpl' \) \
  -and \( -not -path '/src/.terraform/*' -and -not -path '/code/*' \)


/src/debug.tf
/src/nodegroup-infra.tpl
/src/variables.tf.tpl

I tested the above command with hyperfine; The test was conducted on a system with 3k directories and 12k files. I think it's fair to say that it's fast enough ~70ms

Benchmark #1: ./entrypoint.sh
  Time (mean ± σ):      69.2 ms ±   1.4 ms    [User: 22.6 ms, System: 43.6 ms]
  Range (min … max):    66.4 ms …  72.2 ms    42 runs

Sample Directory Structure

/code/ directory tree

bash-5.0# tree /code
/code
├── debug.tf
├── entrypoint.sh
├── nodegroup-infra.tpl
├── tftemplate.sh
└── variables.tf.tpl

0 directories, 5 files

/src/ directory tree

bash-5.0# tree /src
/src
├── Dockerfile
├── debug.tf
├── entrypoint.sh
├── nodegroup-infra.tpl
├── terraform.tfstate
├── terraform.tfstate.backup
└── variables.tf.tpl

0 directories, 7 files

/ root directory tree summary

$ tree /
...
3382 directories, 12164 files

score 2 · Answer 35 · edited Sep 25 '21 at 21:08

2

You can also use

find  -type f -not -name .directoryname -printf "%f\n"

edited Sep 25 '21 at 21:08

Muhammad Dyas Yaskur

6,914
10
48
73

answered Sep 25 '21 at 17:13

mfmarb

45
7

score 2 · Answer 36 · answered Nov 29 '21 at 16:11

If anyone looking to add find command inside Makefile, here is how we exclude directory

! -path "*/directoryName/*"

Below is the example to format all golang file excluding protobuf go files and all files under vendor directory:

find . ! -name '*.pb.go' -name '*.go' ! -path "*/vendor/*" -exec gofmt -s -w '{}' +

score 1 · Answer 37 · answered Dec 31 '14 at 11:44

This works because find TESTS the files for the pattern "*foo*":

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

but it does NOT work if you don't use a pattern (find does not TEST the file). So find makes no use of its former evaluated "true" & "false" bools. Example for not working use case with above notation:

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

There is no find TESTING! So if you need to find files without any pattern matching use the -prune. Also, by the use of prune find is always faster while it really skips that directories instead of matching it or better not matching it. So in that case use something like:

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

or:

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

Regards

score 1 · Answer 38 · edited Oct 08 '15 at 19:23

1

I found the functions name in C sources files exclude *.o and exclude *.swp and exclude (not regular file) and exclude dir output with this command:

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

edited Oct 08 '15 at 19:23

Peter Mortensen

30,738
21
105
131

answered Apr 22 '15 at 10:47

Ivan Ivanovich

880
1
6
15

Alberto · Answer 39 · 2016-01-15T14:19:02.347

1

Better use the exec action than the for loop:

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

The exec ... '{}' ... '{}' \; will be executed once for every matching file, replacing the braces '{}' with the current file name.

Notice that the braces are enclosed in single quote marks to protect them from interpretation as shell script punctuation^*.

Notes

^* From the EXAMPLES section of the find (GNU findutils) 4.4.2 man page

edited Jan 15 '16 at 14:19

answered Aug 28 '15 at 08:25

Alberto

5,021
4
46
69

1

Very old question, but still with room for improvements. I found it by chance trying to solve a similar problem, and none of the answers were satisfactory. – Alberto Aug 28 '15 at 08:27
I use the `exec` action often and find it very useful. I typically add quotes between the `{}` in case there are spaces in the file paths which gives `"{}"`. – Ludovic Kuty Dec 31 '15 at 08:06
@lkuty I was about to edit my post to reflect your comment, but after a quick test (without quoting, `{}` does work for files with whitespaces in their names) and a look into the man pages, it seems that quoting is only necessary to avoid them to be misinterpreted as shell script punctuation. In this case, you would use single quoting: `'{}'` – Alberto Jan 15 '16 at 13:52
I think that I had to use it to make `cp` or `mv` or `rm`. I will check it out – Ludovic Kuty Jan 15 '16 at 17:22

score 1 · Answer 40 · edited Oct 08 '15 at 19:28

1

For FreeBSD users:

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

edited Oct 08 '15 at 19:28

Peter Mortensen

30,738
21
105
131

answered Aug 31 '15 at 11:27

riba

186
2
7

2

This is the same as GetFree's answer. – Kenster Aug 31 '15 at 11:46

score 0 · Answer 41 · answered Apr 22 '16 at 09:57

0

If search directories has pattern (in my case most of the times); you can simply do it like below:

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

In above example; it searches in all the sub-directories starting with "n".

answered Apr 22 '16 at 09:57

Prince Bhanwra

153
1
6

score 0 · Answer 42 · answered Oct 06 '16 at 15:33

I have found the suggestions on this page and a lot of other pages just do not work on my Mac OS X system. However, I have found a variation which does work for me.

The big idea is to search the Macintosh HD but avoid traversing all the external volumes, which are mostly Time Machine backups, image backups, mounted shares, and archives, but without having to unmount them all, which is often impractical.

Here is my working script, which I have named "findit".

#!/usr/bin/env bash
# inspired by http://stackoverflow.com/questions/4210042/exclude-directory-from-find-command Danile C. Sobral
# using special syntax to avoid traversing. 
# However, logic is refactored because the Sobral version still traverses 
# everything on my system

echo ============================
echo find - from cwd, omitting external volumes
date
echo Enter sudo password if requested
sudo find . -not \( \
-path ./Volumes/Archive -prune -o \
-path ./Volumes/Boot\ OS\ X -prune -o \
-path ./Volumes/C \
-path ./Volumes/Data -prune -o \
-path ./Volumes/jas -prune -o \
-path ./Volumes/Recovery\ HD -prune -o \
-path ./Volumes/Time\ Machine\ Backups -prune -o \
-path ./Volumes/SuperDuper\ Image -prune -o \
-path ./Volumes/userland -prune \
\) -name "$1" -print
date
echo ============================
iMac2:~ jas$

The various paths have to do with external archive volumes, Time Machine, Virtual Machines, other mounted servers, and so on. Some of the volume names have spaces in them.

A good test run is "findit index.php", because that file occurs in many places on my system. With this script, it takes about 10 minutes to search the main hard drive. Without those exclusions, it takes many hours.

score 0 · Answer 43 · answered Apr 25 '17 at 20:49

0

Not sure if this would cover all edge cases, but following would be pretty straight forward and simple to try:

ls -1|grep -v -e ddl -e docs| xargs rm -rf

This should remove all files/directories from the current directory excpet 'ddls' and 'docs'.

answered Apr 25 '17 at 20:49

Arnab

1,308
1
13
18

https://unix.stackexchange.com/questions/128985/why-not-parse-ls-and-what-to-do-instead It is not recommended to pipe the output of "ls" – Ferdi Aug 05 '20 at 15:26

score -1 · Answer 44 · answered Sep 02 '19 at 13:28

Instead of:

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

...and since you don't define which subdirectory you want to exclude, you could use:

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

This syntax will exclude all subdirectories.

Take a look at the example below: under my tmp directory I have an huge "archive" subdirectory which contains 17000-4640=12360 files. And this directory is located on a slow NFS. While the 1st syntax scans the "archive" subdirectory and performs poorly, the 2nd syntax only scans the "*pdf" files contained in my current dir and performs... not that bad.

[tmp]$ time (find . -name "*pdf" | wc -l)
17000

real    0m40.479s
user    0m0.423s
sys     0m5.606s

[tmp]$ time (find *pdf -maxdepth 0 -name "*pdf" | wc -l)
4640

real    0m7.778s
user    0m0.113s
sys     0m1.136s

That 2nd syntax is quite interesting: in the following example I want to check if file or60runm50958.pdf exists and is more than 20 minutes old. See for yourself how the 2nd syntax is more efficient. This is because it avoids scanning the archive subdirectory.

[tmp]$ time find . -name or60runm50958.pdf -mmin +20
./or60runm50958.pdf

real    0m51.145s
user    0m0.529s
sys     0m6.243s

[tmp]$ time find or60runm50958.pdf -maxdepth 0 -name or60runm50958.pdf -mmin +20
or60runm50958.pdf

real    0m0.004s
user    0m0.000s
sys     0m0.002s

score -2 · Answer 45 · answered Mar 10 '17 at 15:24

i wanted to know the number of directories, files an MB of just the current directory - and that code does exactly what i want :-)

the source

- ...    2791037 Jun  2  2011 foo.jpg
- ... 1284734651 Mär 10 16:16 foo.tar.gz
- ...          0 Mär 10 15:28 foo.txt
d ...       4096 Mär  3 17:12 HE
d ...       4096 Mär  3 17:21 KU
d ...       4096 Mär  3 17:17 LE
d ...          0 Mär  3 17:14 NO
d ...          0 Mär  3 17:15 SE
d ...          0 Mär  3 17:13 SP
d ...          0 Mär  3 17:14 TE
d ...          0 Mär  3 19:20 UN

the code

format="%s%'12d\n"

find . -type d -not -path "./*/*" | wc -l | awk -v fmt=$format '{printf fmt, " Anzahl Ordner  = ", $1-1}'
find . -type f -not -path "./*/*" | wc -l | awk -v fmt=$format '{printf fmt, " Anzahl Dateien = ", $1}'
  du . -hmS --max-depth=0 | awk -v fmt=$format '{printf fmt, " Groesse (MB)   = ", $1}'

note: the extra format="%s%'12d\n" is necessary for awk to format the numbers.

the result

Anzahl Ordner  =            8
Anzahl Dateien =            3
Groesse (MB)   =        1.228

Please translate non-English code/output citations. Note that you can switch the typical Linux tool output from German back to English by running the tools in a shell with `LC_ALL=C`. — HelpingHand, Sep 25 '21 at 17:36

score -2 · Answer 46 · answered Dec 10 '20 at 06:41

#find command in linux
def : find command used to locate /search files in unix /linux system ,
      find  search for files in a directory hierarchy

1)exec   Show diagnostic information relating to -exec, -execdir, -ok and -okdir
2)-options
  -H =do not follow symoblic links while except while procesing .
  -L = follow symbolic links
  -P =never follow symbolic links

  -type c
             File is of type c:

             b      block (buffered) special

             c      character (unbuffered) special

             d      directory

             p      named pipe (FIFO)

             f      regular file

             l      symbolic  link;  this  is  never true if the -L option or the -follow option is in effect, unless the
                    symbolic link is broken.  If you want to search for symbolic links when -L is in effect, use -xtype.

             s      socket

             D      door (Solaris)

    -Delete
    Delete files; true if removal succeeded.  If the removal failed, an error message  is  issued.
    If  -delete
    #fails, find's exit status will be nonzero (when it eventually exits).


find /home/mohan/a -mindepth 3 -maxdepth 3 -type f -name "*.txt" |xargs rm -rf
find -type d -name
find -type f -Name
find /path/ -type f -iname (i is case insenstive)

#find directores a/b/c and only delete c directory inside have "*.txt "
find /home/mohan/a -mindepth 3 -maxdepth 3 -type f -name "*.txt" |xargs rm -rf
find /home/mohan/a -mindepth 3 -maxdepath 3 -type f -name "*.txt" -delete


#delete particular directory have empty file and only  we can delete empty files
find /home/mohan -type f -name "*.txt" -empty -DELETE


#find multiple files and also find empty files
find /home/mohan -type f \( -name "*.sh" -o  -name "*.txt" \) -empty

#delete empty files two or more Files
find /home/mohan -type f \( -nmae "*.sh" -o -name "*.txt" \) -empty -delete


#How to append contents of multiple files into one file
find . -type f -name '*.txt' -exec cat {} + >> output.file

#last modified files finding using less than 1 min (-n)
ls -lrth|find . -type f -mmin -1

#last modified files more than 1 min (+n)
ls -lrth|find . -type f -mmin +1


#last modified files exactly one mins
find . -type f -mmin 1

last modifiedfiles exactly in one day by using command (-mtime)
find . -type f -mtime 10

#last modified more than 10 days
find . -type  f -mtime +10

#last modified less than 10 days
find . -type f -mtime -10

#How to Find Modified Files and Folders Starting from a Given Date to the Latest Date
find . -type f  -newermt "17-11-2020"

#How to Find a List of “sh” Extension Files Accessed in the Last 30 Days--- -matdimtype
ls -lrt|find . -type f -iname ".sh" -atime -30

#How to Find a List of Files Created Today, -1 means less than min,
ls -lrt | find . -type f -ctime -1 -ls

How do I exclude a directory when using `find`?

46 Answers46

Quick example: exclude all directories with a given prefix

Quick summary and answer to the OP's question:

Discussion of nuances and rules of thumb

Generic examples

Summary

Further Explanation:

Summary:

Going further

Addressing other comments

1. Both `-prune` and `-not` are required to get the desired effect

References:

See also:

Sample Directory Structure

Notes

Linked

Related

How do I exclude a directory when using `find`?

46 Answers46

Quick example: exclude all directories with a given prefix

Quick summary and answer to the OP's question:

Discussion of nuances and rules of thumb

Generic examples

Summary

Further Explanation:

Summary:

Going further

Addressing other comments

1. Both -prune and -not are required to get the desired effect

References:

See also:

Sample Directory Structure

Notes

Linked

Related

1. Both `-prune` and `-not` are required to get the desired effect