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:
ls
is NOT allowed, we could only use find
and sed
.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.
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'
The reason is (according to the manpage on my system):-
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.
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
.
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
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 :)
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?
-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.
Normally the native way we do things in linux and the way we think is from left to right.
So you would go and write what you are looking for first:
find / -name "*.php"
Then you probably hit enter and realize you are getting too many files from
directories you wish not to.
Let's exclude /media to avoid searching your mounted drives.
You should now just APPEND the following to the previous command:
-print -o -path '/media' -prune
so 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
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."
Show everything including dir itself but not its long boring contents:
find . -print -name dir -prune
Prune is a do not recurse at any directory switch.
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 desend into any sub directories.
Take this example:
You have the following directories
If you run find -name test2
:
It will return both directories
If you run find -name test2 -prune
:
It will return only /home/test2 as it will not descend into /home/test2 to find /home/test2/test2
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
Source: Stackoverflow.com