275

I don't quite understand the example given from the man find, can anyone give me some examples and explanations? Can I combine regular expression in it?

The more detailed question is like this:

Write a shell script, changeall, which has an interface like changeall [-r|-R] "string1" "string2". It will find all files with an suffix of .h, .C, .cc, or .cpp and change all occurrences of string1 to string2. -r is option for staying in current dir only or including subdir's.

NOTE:

  1. For non-recursive case, ls is NOT allowed, we could only use find and sed.
  2. I tried find -depth but it was NOT supported. That's why I was wondering if -prune could help, but didn't understand the example from man find.

EDIT2: I was doing assignment, I didn't ask question in great details because I would like to finish it myself. Since I already done it and hand it in, now I can state the whole question. Also, I managed to finish the assignment without using -prune, but would like to learn it anyway.

Lii
  • 11,553
  • 8
  • 64
  • 88
derrdji
  • 12,661
  • 21
  • 68
  • 78

10 Answers10

550

The thing I'd found confusing about -prune is that it's an action (like -print), not a test (like -name). It alters the "to-do" list, but always returns true.

The general pattern for using -prune is this:

find [path] [conditions to prune] -prune -o \
            [your usual conditions] [actions to perform]

You pretty much always want the -o (logical OR) immediately after -prune, because that first part of the test (up to and including -prune) will return false for the stuff you actually want (ie: the stuff you don't want to prune out).

Here's an example:

find . -name .snapshot -prune -o -name '*.foo' -print

This will find the "*.foo" files that aren't under ".snapshot" directories. In this example, -name .snapshot makes up the [conditions to prune], and -name '*.foo' -print is [your usual conditions] and [actions to perform].

Important notes:

  1. If all you want to do is print the results you might be used to leaving out the -print action. You generally don't want to do that when using -prune.

    The default behavior of find is to "and" the entire expression with the -print action if there are no actions other than -prune (ironically) at the end. That means that writing this:

     find . -name .snapshot -prune -o -name '*.foo'              # DON'T DO THIS

    is equivalent to writing this:

     find . \( -name .snapshot -prune -o -name '*.foo' \) -print # DON'T DO THIS

    which means that it'll also print out the name of the directory you're pruning, which usually isn't what you want. Instead it's better to explicitly specify the -print action if that's what you want:

     find . -name .snapshot -prune -o -name '*.foo' -print       # DO THIS

  2. If your "usual condition" happens to match files that also match your prune condition, those files will not be included in the output. The way to fix this is to add a -type d predicate to your prune condition.

    For example, suppose we wanted to prune out any directory that started with .git (this is admittedly somewhat contrived -- normally you only need to remove the thing named exactly .git), but other than that wanted to see all files, including files like .gitignore. You might try this:

    find . -name '.git*' -prune -o -type f -print               # DON'T DO THIS

    This would not include .gitignore in the output. Here's the fixed version:

    find . -name '.git*' -type d -prune -o -type f -print       # DO THIS

Extra tip: if you're using the GNU version of find, the texinfo page for find has a more detailed explanation than its manpage (as is true for most GNU utilities).

John Smith
  • 835
  • 1
  • 7
  • 19
Laurence Gonsalves
  • 137,896
  • 35
  • 246
  • 299
  • 18
    and +1 for you for the nicely done explanation (and especially the important note). You should submit this to the find developpers (as the man page doesn't explain "prune" for normal human beings ^^ It took me many tries to figure it out, and I didn't see that side effect you warns us about) – Olivier Dulac Jan 16 '13 at 16:25
  • 1
    You can also use this in conjunction with an `-exec` clause to 'mark' a directory with a particular file indicating it should not be descended into. For this you need to use the multiline `-exec` version shown in https://unix.stackexchange.com/a/507025/369126 and could look like: `find $dir -type d -exec sh -c 'test -f $1/DONTBACKUP' sh {} \; -prune -o morestuff` We start at `$dir` , and any directory found is tested for it containing a file called `DONTBACKUP`. If it's there (exit status of the `-exec` is 0, i.e. succes) that dir is skipped, otherwise we continue with `morestuff` – plijnzaad Dec 09 '21 at 15:51
  • 1
    At the expense of more compute cycles, I am often able to avoid `-prune` using `\! -path`. For example, to avoid descending into folders named `archive`, I use `find folder1 folder2 \! -path '*/archive/*'`. – user2153235 Jan 05 '22 at 23:37
  • In my case it returns the excluding directory (but not the content) with this command: `find . -name "*.c" -o -path "./build" -prune`. So it returns a bunch of `*.c` files that are not in `./build/` and `./build/` – Puck Jan 26 '22 at 14:28
  • 1
    @Puck You need to add an explicit `-print` action to get the right behavior. You've got your clauses backward from the way recommended in the answer. I'd normally write what you're trying to do as: `find . -path "./build" -prune -o -name "*.c" -print`. However, if you prefer the pruned stuff last that can work too, but you need to insert the print action before the `-o`: `find . -name "*.c" -print -o -path "./build" -prune`. See "Important note" #1 for more details. – Laurence Gonsalves Jan 26 '22 at 17:05
  • 1
    @user2153235 This is a great tip! `\! -path` is a lot easier to understand, and works well for the common case of pruning by path name. However, `-prune` is more versatile, because it can prune based on any predicate, not just the path. – Laurence Gonsalves Jan 26 '22 at 17:08
37

Normally, the native way we do things in Linux, and the way we think, is from left to right.

You would go and write what you are looking for first:

find / -name "*.php"

Then, you hit ENTER and realize you are getting too many files from directories you wish not to.

So, you think "let's exclude /media to avoid searching mounted drives."

You should now just append the following to the previous command:

-print -o -path '/media' -prune

and the final command is:

find / -name "*.php" -print -o -path '/media' -prune

|<--      Include      -->|<--      Exclude      -->|

I think this structure is much easier and correlates to the right approach.

Zach Young
  • 10,137
  • 4
  • 32
  • 53
AmitP
  • 5,353
  • 4
  • 35
  • 27
31

Beware that -prune does not prevent descending into any directory as some have said. It prevents descending into directories that match the test it's applied to. Perhaps some examples will help (see the bottom for a regex example). Sorry for this being so lengthy.

$ find . -printf "%y %p\n"    # print the file type the first time FYI
d .
f ./test
d ./dir1
d ./dir1/test
f ./dir1/test/file
f ./dir1/test/test
d ./dir1/scripts
f ./dir1/scripts/myscript.pl
f ./dir1/scripts/myscript.sh
f ./dir1/scripts/myscript.py
d ./dir2
d ./dir2/test
f ./dir2/test/file
f ./dir2/test/myscript.pl
f ./dir2/test/myscript.sh

$ find . -name test
./test
./dir1/test
./dir1/test/test
./dir2/test

$ find . -prune
.

$ find . -name test -prune
./test
./dir1/test
./dir2/test

$ find . -name test -prune -o -print
.
./dir1
./dir1/scripts
./dir1/scripts/myscript.pl
./dir1/scripts/myscript.sh
./dir1/scripts/myscript.py
./dir2

$ find . -regex ".*/my.*p.$"
./dir1/scripts/myscript.pl
./dir1/scripts/myscript.py
./dir2/test/myscript.pl

$ find . -name test -prune -regex ".*/my.*p.$"
(no results)

$ find . -name test -prune -o -regex ".*/my.*p.$"
./test
./dir1/test
./dir1/scripts/myscript.pl
./dir1/scripts/myscript.py
./dir2/test

$ find . -regex ".*/my.*p.$" -a -not -regex ".*test.*"
./dir1/scripts/myscript.pl
./dir1/scripts/myscript.py

$ find . -not -regex ".*test.*"                   .
./dir1
./dir1/scripts
./dir1/scripts/myscript.pl
./dir1/scripts/myscript.sh
./dir1/scripts/myscript.py
./dir2
Dennis Williamson
  • 346,391
  • 90
  • 374
  • 439
20

Adding to the advice given in other answers (I have no rep to create replies)...

When combining -prune with other expressions, there is a subtle difference in behavior depending on which other expressions are used.

@Laurence Gonsalves' example will find the "*.foo" files that aren't under ".snapshot" directories:-

find . -name .snapshot -prune -o -name '*.foo' -print

However, this slightly different short-hand will, perhaps inadvertently, also list the .snapshot directory (and any nested .snapshot directories):-

find . -name .snapshot -prune -o -name '*.foo'

According to the posix manpage, the reason is:

If the given expression does not contain any of the primaries -exec, -ls, -ok, or -print, the given expression is effectively replaced by:

( given_expression ) -print

That is, the second example is the equivalent of entering the following, thereby modifying the grouping of terms:-

find . \( -name .snapshot -prune -o -name '*.foo' \) -print

This has at least been seen on Solaris 5.10. Having used various flavors of *nix for approx 10 years, I've only recently searched for a reason why this occurs.

KyleMit
  • 30,350
  • 66
  • 462
  • 664
crw
  • 655
  • 7
  • 17
4

I am no expert at this (and this page was very helpful along with http://mywiki.wooledge.org/UsingFind)

Just noticed -path is for a path that fully matches the string/path that comes just after find (. in theses examples) where as -name matches all basenames.

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

blocks the .git directory in your current directory ( as your finding in . )

find . -name .git  -prune -o -name file  -print

blocks all .git subdirectories recursively.

Note the ./ is extremely important!! -path must match a path anchored to . or whatever comes just after find if you get matches with out it (from the other side of the or '-o') there probably not being pruned! I was naively unaware of this and it put me of using -path when it is great when you don't want to prune all subdirectory with the same basename :D

sabgenton
  • 1,823
  • 1
  • 12
  • 20
3

find builds a list of files. It applies the predicate you supplied to each one and returns those that pass.

This idea that -prune means exclude from results was really confusing for me. You can exclude a file without prune:

find -name 'bad_guy' -o -name 'good_guy' -print  // good_guy

All -prune does is alter the behavior of the search. If the current match is a directory, it says "hey find, that file you just matched, dont descend into it". It just removes that tree (but not the file itself) from the list of files to search.

It should be named -dont-descend.

seeker_of_bacon
  • 1,939
  • 2
  • 19
  • 20
2

Prune is a "do not recurse at this file" switch (action).

From the man page

If -depth is not given, true; if the file is a directory, do not descend into it. If -depth is given, false; no effect.

Basically it will not descend into any sub directories.

Take this example:

You have the following directories:

% find home
home
home/test1
home/test1/test1
home/test2
home/test2/test2

find home -name test2 will print both the parent and the child directories named test2:

% find home -name test2
home/test2
home/test2/test2

Now, with -prune...

find home -name test2 -prune will print only /home/test2; it will not descend into /home/test2 to find /home/test2/test2:

% find home -name test2 -prune
home/test2
Zach Young
  • 10,137
  • 4
  • 32
  • 53
AdamW
  • 1,061
  • 10
  • 14
  • 2
    not 100% true: it is "do pruning when matching condition, and if it's a directory, take it out of the to-do list, ie don't enter it as well". -prune also works on files. – Olivier Dulac Jan 16 '13 at 16:29
2

Show everything including dir itself but not its long boring contents:

find . -print -name dir -prune
Devon
  • 1,019
  • 9
  • 20
1

If you read all the good answers here my understanding now is that the following all return the same results:

find . -path ./dir1\*  -prune -o -print

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

find . -path ./dir1\*  -o -print
#look no prune at all!

But the last one will take a lot longer as it still searches out everything in dir1. I guess the real question is how to -or out unwanted results without actually searching them.

So I guess prune means don't decent past matches but mark it as done...

http://www.gnu.org/software/findutils/manual/html_mono/find.html "This however is not due to the effect of the ‘-prune’ action (which only prevents further descent, it doesn't make sure we ignore that item). Instead, this effect is due to the use of ‘-o’. Since the left hand side of the “or” condition has succeeded for ./src/emacs, it is not necessary to evaluate the right-hand-side (‘-print’) at all for this particular file."

sabgenton
  • 1,823
  • 1
  • 12
  • 20
0

There are quite a few answers; some of them are a bit too much theory-heavy. I'll leave why I needed prune once so maybe the need-first/example kind of explanation is useful to someone :)

Problem

I had a folder with about 20 node directories, each having its node_modules directory as expected.

Once you get into any project, you see each ../node_modules/module. But you know how it is. Almost every module has dependencies, so what you are looking at is more like projectN/node_modules/moduleX/node_modules/moduleZ...

I didn't want to drown with a list with the dependency of the dependency of...

Knowing -d n / -depth n, it wouldn't have helped me, as the main/first node_modules directory I wanted of each project was at a different depth, like this:

Projects/MysuperProjectName/project/node_modules/...
Projects/Whatshisname/version3/project/node_modules/...
Projects/project/node_modules/...
Projects/MysuperProjectName/testProject/november2015Copy/project/node_modules/...
[...]

How can I get the first a list of paths ending at the first node_modules and move to the next project to get the same?

Enter -prune

When you add -prune, you'll still have a standard recursive search. Each "path" is analyzed, and every find gets spit out and find keeps digging down like a good chap. But it's the digging down for more node_modules what I didn't want.

So, the difference is that in any of those different paths, -prune will find to stop digging further down that particular avenue when it has found your item. In my case, the node_modules folder.

Community
  • 1
  • 1
Neithan Max
  • 11,004
  • 5
  • 40
  • 58