Build find command from arguments

Question

I often need to find a file, but I'm not sure what the name is, something like this:

$ find -iname '*foo*' -o -iname '*bar*' -o -iname '*blah*'

This is a little tedious. I'd like to create an alias that's easier to use, like this:

$ findany foo bar blah

Here's my attempt:

findany() {
    args=("-iname" "'*$1*'")
    shift

    while [ $# -gt 0 ]; do
        args+=("-o" "-iname" "'*$1*'")
        shift
    done

    find ${args[@]}
}

The problem is it never yields any results, even though the files are right there:

$ ls
bar.txt  blah.txt  foo.txt

$ findany foo bar blah
# nothing

If I add echo in front of the command, it looks correct:

$ findany foo bar blah                     
find -iname '*foo*' -o -iname '*bar*' -o -iname '*blah*'

And if I copy the output above and run it, it works fine:

$ find -iname '*foo*' -o -iname '*bar*' -o -iname '*blah*'
./bar.txt
./foo.txt
./blah.txt

I figure it has to do with argument splitting or quotes but I'm not sure how to debug it.

I normally use zsh but I verified the same behavior in bash.

Answer 1

You were very close! But for some reason you'd included single quotes in the file names themselves, so they'd never match.

Also you must quote "${args[@]}" to have it work properly. Otherwise it's subject to word splitting, and any globs will expand in the shell before find sees them.

Try this instead (specifically for bash):

findany() {
    local args=('-iname' "*$1*")
    shift

    while [ "$#" -gt 0 ]; do
        args+=('-o' '-iname' "*$1*")
        shift
    done

    find . "${args[@]}"
}

Answer 2

With zsh, you could just use:

set -o extendedglob # usually in your ~/.zshrc, here used for (#i) for
                    # case insensitive matching

print -rC1 -- **/*(#i)(foo|bar|blah)*(ND)

To build that pattern from an array, you can use the j[|] parameter expansion flag to join the elements of the array with | combined with either the ~ parameter expansion flag so that that | be treated as a glob pattern operator, or with the ~ parameter expansion operator so that any wildcard character in the joined string (even those found in array elements) are treated as patterns.

findany1() print -rC1 -- **/*(#i)(${(~j[|])argv})*(ND)

Or:

findany2() print -rC1 -- **/*(#i)(${(j[|])~argv})*(ND)

For instance findany1 '??' would find the files whose name contains ?? while findany2 would find the files whose name contains at least 2 characters. You'd need findany2 '\?\?' or findany2 '[?][?]' to find the files whose name contains ?? with findany2.

To make the same distinction with find, that'd be:

findany2() (
  for arg do
    argv+=( -o -iname "$arg" )
    shift
  done
  shift
  find . "$@"
)

findany1() (
  set -o extendedglob
  for arg do
    argv+=( -o -iname "${arg//(#m)[][\\?*]/\\$MATCH}" )
    shift
  done
  shift
  find . "$@"
)

Where we escape the wildcards recognised by find (?, *, [...] and \) with \ (the only quoting operator supported by find/fnmatch()).

Answer 3

$ find -iname '*foo*' -o -iname '*bar*' -o -iname '*blah*'

that's one way to go about it, but frankly, it is result-wise similar to

shopt -s globstar  ## enable recursive globbing operator **
shopt -s extglob   ## enable (|) pattern lists
shopt -s nocasematch  ## take a guess!

echo **/*@(foo|bar|blah)*

(but it does that without help of find).

We can very quickly build a shell script from that.

#! /bin/bash -
shopt -s globstar  ## enable recursive globbing operator **
shopt -s extglob   ## enable (|) pattern lists
shopt -s nullglob  ## don't error if nothing matches
shopt -s nocasematch  ## take a guess!

IFS='|' # "$*" joins with the first character of IFS
pattern="**/*@(${*})*"

IFS= # do globbing but not splitting upon unquoted expansion:
matches=( $pattern )

for element in "${matches[@]}"; do
  printf '%s\n' "${element}"
done

If you want to have it as a function, just put pattern=… to done in a function declaration.