When I run this command in the shell (in a non-empty directory):

find . -exec invalid_command_here {} \;

I get this:

find: invalid_command_here: No such file or directory
find: invalid_command_here: No such file or directory
find: invalid_command_here: No such file or directory

(and so on for each file)

I need find to fail after the first error. Is there any way to get this to work? I can't use xargs, as I have spaces in my path, but I need the script calling this to return an error code.


This is a limitation of find. The POSIX standard specifies that the return status of find is 0 unless an error occurred while traversing the directories; the return status of executed commands doesn't enter into it.

You can make commands write their status to a file or to a descriptor:

find_status_file=$(mktemp findstatus)
: >"$find_status_file"
find … -exec sh -c 'trap "echo \$?" EXIT; invalid_command "$0"' {} \;
if [ -s "$find_status_file" ]; then
  echo 1>&2 "An error occurred"
rm -f "$find_status_file"

Another method, as you discovered, is to use xargs. The xargs commands always processes all files, but returns the status 1 if any of the commands returns a nonzero status.

find … -print0 | xargs -0 -n1 invalid_command

Yet another method is to eschew find and use recursive globbing in the shell instead: **/ means any depth of subdirectories. This requires version 4 or above of bash; macOS is stuck at version 3.x so you'd have to install it from a port collection. Use set -e to halt the script on the first command returning a nonzero status.

shopt -s globstar
set -e
for x in **/*.xml; do invalid_command "$x"; done

Beware that in bash 4.0 through 4.2, this works but traverses symbolic links to directories, which is usually not desirable.

If you use zsh instead of bash, recursive globbing works out of the box with no gotchas. Zsh is available by default on OSX/macOS. In zsh, you can just write

set -e
for x in **/*.xml; do invalid_command "$x"; done
  • The xargs approach works in general but somehow breaks on bash -c commands. For example: find . -name '*.xml' -print0 | xargs -0 -n 1 -I '{}' bash -c "foo {}". This is executed multiple times whereas find . -name '2*.xml' -print0 | xargs -0 -n 1 -I '{}' foo {} is executed once and fails. Any idea why? – DKroot Mar 11 '19 at 3:26
  • @DKroot Never use {} inside bash -c. This takes the file name and inserts it directly inside the shell command. If the file name contains characters which have a special meaning in the shell such as spaces, the shell interprets these special characters as such. If you need a shell, pass {} as a separate argument, e.g. bash -c 'foo "$0"' {} (note the double quotes around $0, as well). – Gilles 'SO- stop being evil' Mar 11 '19 at 8:14
  • OK, quoting questions aside, why does the following not stop on the first error?? find . -name '*' -print0 | xargs -0 -n 1 -I '{}' bash -c 'foo "$0"' {} – DKroot Mar 27 '19 at 14:23
  • @DKroot Why would it stop on an error? xargs always runs the command on all the items. – Gilles 'SO- stop being evil' Mar 27 '19 at 22:09
  • I'm trying to use this answer: the xargs (find . -print0 | xargs -0 -n1 invalid_command) approach. This stops on the first error correctly: find . -name '*' -print0 | xargs -0 -n 1 -I '{}' foo {}. Great! But the same approach doesn’t work with bash -c (above). The only difference between the two is bash -c. – DKroot Mar 28 '19 at 21:26

I can use this instead:

find . -name *.xml -print0 | xargs -n 1 -0 invalid_command

xargs is one option. However, it's actually trivially easy to do this with find as well by using + instead of \;

-exec  utility_name  [argument ...]   {} +

From the POSIX documentation:

If the primary expression is punctuated by a plus sign, the primary shall always evaluate as true, and the pathnames for which the primary is evaluated shall be aggregated into sets. The utility utility_name shall be invoked once for each set of aggregated pathnames. Each invocation shall begin after the last pathname in the set is aggregated, and shall be completed before the find utility exits and before the first pathname in the next set (if any) is aggregated for this primary, but it is otherwise unspecified whether the invocation occurs before, during, or after the evaluations of other primaries. If any invocation returns a non-zero value as exit status, the find utility shall return a non-zero exit status. An argument containing only the two characters “{}” shall be replaced by the set of aggregated pathnames, with each pathname passed as a separate argument to the invoked utility in the same order that it was aggregated. The size of any set of two or more pathnames shall be limited such that execution of the utility does not cause the system’s {ARG_MAX} limit to be exceeded. If more than one argument containing only the two characters “{}” is present, the behavior is unspecified.

You must log in to answer this question.

Not the answer you're looking for? Browse other questions tagged .