mjhjmtu

I need to recursively iterate through all the subdirectories of a folder.
Within the subdirectories, if there's a file with an extension '.xyz' then I need to run a specific command in that folder once.

Here's what I have so far

recursive() wc -l)
if [[ $file_count -gt 0 ]]; then
 echo "Match found. Going to execute a command"
 #execute command
fi
 done


(cd /target; recursive)

But the problem is that the "Match found.." message is displayed more than once per folder when there's a match. Is there a simpler way to do this while fixing this problem?

find has a builtin flag to print strings, which is pretty useful here:

find -iname "*.xyz" -printf "%hn" prints the names of all directories that contain a file that matches your pattern (the %h is just find's magic syntax that expands to the file directory and n is, of course, a linebreak).

Therefore, this does what you want:

COMMAND='echo'
find `pwd` -iname "*.pdf" -printf "%hn" | sort -u | while read i; do 
 cd "$i" && pwd && $COMMAND
done

There are a few things that are going on here. To execute commands only once, we just pipe it through sort with the -u flag, which drops all duplicate entries. Then we loop over everything with while. Also note that I used find `pwd`, which is a nice trick to make find output absolute paths, instead of relative ones, which allows us to use cd without having to worry about any relative paths.

Edit: Be careful with your directory names when executing this script, as directory names containing a newline (n) or even just can break the script (maybe other uncommon characters too, but I haven't tested any more than that). Fixing this is hard and I don't know how to do it, so I can only suggest not using such directories.

You're re-inventing find.

Try something like this (using GNU findutils and GNU sort):

find /target -iname '*.xyz' -printf '%h00' | sort -z -u | 
 xargs -0 -r -I sh -c "cd ; yourcommandhere"

The -printf prints the directory names (%h) where '*.xyz' files are found, with NUL bytes (00) as the delimiter. sort is used to eliminate duplicates, and then xargs is used to cd into each directory and run yourcommandhere.

You can also write a script to run with xargs. e.g.

find /target -iname '*.xyz' -printf '%h00' | sort -z -u | 
 xargs -0 -r /path/to/myscript.sh

simple myscript.sh example:

#!/bin/sh

for d in "$@" ; do
 cd "$d"
 echo "Match found in $d. Going to execute command"
 # execute command
done

This second version will be significantly faster if there are many matching directories - it only has to fork a shell once (which then iterates over every argument) rather than forking a shell once per directory.

BTW, neither printf nor sort nor xargs are actually needed here....but they do make it a lot easier to read and understand what's happening. Just as importantly, by eliminating the duplicates early (with the printf and sort), it runs a lot faster than using bash only and eliminates the (fairly minimal) risk of executing the command more than once in any given directory.

Here's another way of doing the same thing, without sort or xargs:

find /target -iname '*.xyz' -exec bash -c 
 'typeset -A seen
 for f in "$@"; do
 d="$(dirname "$f")";
 if [[ ! -v $seen[$d] ]]; then
 echo "Match found in $d. Going to execute command"
 # Execute command
 seen["$d"]=1
 fi
 done' +

This uses an associative array in bash ($seen) to keep track of which directories have already been seen and processed. Note that if there are many thousands of matching *.xml files (enough to exceed the maximum command-line length, so that the bash script is forked more than once) then your command may be run more than once in any given directory.

The script executed by find's -exec option can be a standalone script, as with the xargs version above.

BTW, any of the variants here could just as easily execute an awk or perl or whatever script instead of a sh or bash script.