What is this strange syntax inside `find -exec`? - bash

Question

Recently I've came across a strange bash script, which is used to call a custom bash function from inside find -exec. I've developed following simple script to demonstrate the functionality I need to get explained.
In the following example, function foo will be called for each find result.
foo()
{
echo "$#"
}
export -f foo
find . -exec bash -c 'foo "$#"' bash {} \;
Can someone explain how the part after -exec is interpreted?
UPDATE:
To further simplify this, after exporting foo as above, following gets executed for each find result (assume there is a file named my_file).
bash -c 'foo "$#"' bash my_file
And this produces the output myfile. I don't understand how this works. What does the second bash does there? Any detailed explanation is appreciated.
(Please note that this question is not about find command. Also please ignore the functionality of function foo, I just wanted to export some function)

Answer 1

To understand you need to know 4 things:
The find action -exec allows you to apply a command on the found files and directories.
The -c bash option is documented as follows:
BASH(1)
...
OPTIONS
...
-c If the -c option is present, then commands are read from
the first non-option argument command_string.
If there are arguments after the command_string, they
are assigned to the positional parameters, starting with $0.
...
If bash is started with the -c option, then $0 is set to the first
argument after the string to be executed, if one is present.
Otherwise, it is set to the filename used to invoke bash, as given
by argument zero.
In bash, $# expands as all positional parameters ($1, $2...) starting at parameter $1.
In a bash function, the positional parameters are the arguments passed to the function when it is called.
So, in your case, the command executed for each found file or directory is:
bash -c 'foo "$#"' bash <the-file>
The positional parameters are thus set to:
$0 = bash
$1 = <the-file>
and bash is asked to execute 'foo "$#"' in this context. "$#" is first expanded as "<the-file>". So, function foo is called with one single argument: "<the-file>". In the context of function foo the positional parameters are thus:
$1 = "<the-file>"
and echo "$#" expands as echo "<the-file>".
All this just prints the names of all found files or directories. It is almost as if you had any of:
find . -exec echo {} \;
find . -print
find .
find
(for find versions that accept the last one).
Almost as if, only, because if file or directory names contain spaces, depending on your use of find and of quotes, you will get different results. So, if you intend to have a more complex foo function, you should pay attention to the quotes. Examples:
$ touch "filename with spaces" plain
$ ls -1
filename with spaces
plain # 2 files
$ foo() { echo "$#"; } # print arguments
$ find . -type f
./filename with spaces
./plain
$ find . -type f -exec bash -c 'foo "$#"' bash {} \;
./filename with spaces
./plain
$ find . -type f -exec bash -c 'foo $#' bash {} \;
./filename with spaces
./plain
The 3 find commands apparently do the same but:
$ bar() { echo $#; } # print number of arguments
$ wc -w < <(find . -type f)
4 # 4 words
$ find . -type f -exec bash -c 'bar "$#"' bash {} \;
1 # 1 argument
1 # per file
$ find . -type f -exec bash -c 'bar $#' bash {} \;
3 # 3 arguments
1 # 1 argument
With find . -type f -exec bash -c 'bar "$#"' bash {} \;, the first file name is passed to function bar as one single argument, while in all other cases it is considered as 3 separate arguments.