glob variable mandatorily in the double quotes

Question

This link: Wildcards inside quotes in my case not solve the problem.
The file "a.sh" contain:

file="path with wildcard*"

The file "b.sh" contain:

. a.sh
[ -f "$file" ] && echo ok

Because

"$file"

not expand wildcard, instead

$file

expand wildcard, but with error: "binary operator expected"

How do I solve this puzzle? It is not possible to take the wildcard out of the double quotes.

Edit:
I want achieve a single match from wildcard. If there are more matches, the condition must return false, in any case not must return an error.

Answer 1

If you want to store in an array the list of files resulting from the expansion of a glob pattern stored in variable, in bash, that would be:

pattern='path with wildcard*'

IFS= # disable splitting

shopt -s nullglob # make globs that don't match any file expand to nothing
                  # instead of the unexpanded pattern.

files=($pattern) # here using split+glob (unquoted expansion in list context)
                 # with the splitting disabled above.

Or to assign the $files array directly without using a $pattern scalar variable:

shopt -s nullglob # make globs that don't match any file expand to nothing
                  # instead of the unexpanded pattern.

files=('path with wildcard'*)

Then you can test if that list is empty with:

if [ "${#files[@]}" -gt 0 ]; then
  echo it did find some files
fi

If you want to check, that among those files, at least one is a regular file (after symlink resolution), you could do:

has_regular_files() {
  local file
  for file do
    [ -f "$file" ] && return
  done
  false
}

if has_regular_files "${files[@]}"; then
  echo there was at least one regular file in the list
fi

To check that it matches only one file and that that file is a regular file:

if [ "${#files[@]}" -eq 1 ] && [ -f "${files[0]}" ]; then
  echo one and only one file matches and it is regular.
fi

To check that it matches at least one regular file and that all the matched files are regular:

only_regular_files() {
  [ "$#" -gt 0 ] || return
  local file
  for file do
    [ -f "$file" ] || return
  done
}

if only_regular_files "${files[@]}"; then
  echo at least one regular file and all are regular.
fi

With the zsh shell, you can use glob qualifiers to match by file type:

if ()(($#)) $~pattern(N-.); then
  print at least one regular file in the expansion of the pattern.
fi

• contrary to bash, zsh doesn't do implicit split+glob upon unquoted parameter expansions. Here we're asking for globbing (but not splitting) with $~pattern.
• We append the (N-.) glob qualifier, N for nullglob so that if the glob matches no file, it expands to nothing . to test for regular files only (to the exclusion of any other type of file), - so that that test be done after symlink resolution so it would also match on files that are symlinks to regular files (like your [ -f "$file" ] would).
• the expansion of that glob is passed as arguments to an anonymous function, () {body} args where the {body} is (($#)).
• ((expr)) is a ksh-style arithmetic expression evaluation operator, that returns true if the expression evaluates to a number other than 0. Here, the expression is $#, that is a special parameter than expands to the number of positional parameters, in this case the number of arguments of that anonymous function, so the number of files that result from that glob expansion.

Answer 2

[ -f $file ] && echo ok

This would expand the variable, wordsplit, and expand all matching files. You might end up with [ -f filethis filethat ], and filethis isn't a binary operator, so you get the error.

Even if there are no matches, and $file expands to nothing, you get [ -f ] which is a test to see if -f is a non-empty string. It is, so the result is true.

Expand the filenames to an array or to the positional parameters and count the matches:

file="path with wildcard*"
IFS=
set -- $file
echo "matched $# files"

You have to change IFS there if you have whitespace in the pattern, because the split happens before filename expansion, so the above would have two constant words and one glob pattern. Also an unmatched pattern would remain as-is, so we need to check for that.

You could hide this in a function:

only_one() {
    local IFS=
    set -- $1
    if [ $# = 1 ] && [ -f "$1" ]; then return 0; fi
    return 1
}

and then run

if only_one "$file"; then 
    ...
fi

Answer 3

I have solved with:
The file "a.sh" contain:

file=('path with wildcard'*)

The file "b.sh" contain:

. a.sh
[ -f "$file" ] && echo ok

Result: Ok