¿Cómo puedo saber mediante programación si un nombre de archivo coincide con un patrón glob de shell?

Me gustaría saber si una cadena $stringcoincidiría con un patrón global $pattern. $stringpuede o no ser el nombre de un archivo existente. ¿Cómo puedo hacer esto?

Asumir los siguientes formatos para mis cadenas de entrada:

string="/foo/bar"
pattern1="/foo/*"
pattern2="/foo/{bar,baz}"

Me gustaría encontrar un lenguaje bash que determina si $stringsería igualado por $pattern1, $pattern2o cualquier otro patrón global arbitraria. Esto es lo que he intentado hasta ahora:

1. [[ "$string" = $pattern ]]

   Esto casi funciona, excepto que $patternse interpreta como un patrón de cadena y no como un patrón global.

2. [ "$string" = $pattern ]

   El problema con este enfoque es que $patternse expande y luego se realiza una comparación de cadenas entre $stringy la expansión de $pattern.

3. [[ "$(find $pattern -print0 -maxdepth 0 2>/dev/null)" =~ "$string" ]]

   Este funciona, pero solo si $stringcontiene un archivo que existe.

4. [[ $string =~ $pattern ]]

   Esto no funciona porque el =~operador hace $patternque se interprete como una expresión regular extendida, no como un patrón global o comodín.

No hay una solución general para este problema. La razón es que, en bash, la expansión de llaves (es decir, {pattern1,pattern2,...}y la expansión de nombre de archivo (también conocidos como patrones globales) se consideran cosas separadas y se expanden bajo diferentes condiciones y en diferentes momentos. Aquí está la lista completa de expansiones que realiza bash:

• expansión de llaves
• expansión tilde
• parámetro y expansión variable
• sustitución de comando
• expansión aritmética
• división de palabras
• expansión de nombre de ruta

Dado que solo nos preocupamos por un subconjunto de estos (quizás expansión de llaves, tilde y nombre de ruta), es posible usar ciertos patrones y mecanismos para restringir la expansión de manera controlable. Por ejemplo:

#!/bin/bash
set -f

string=/foo/bar

for pattern in /foo/{*,foo*,bar*,**,**/*}; do
    [[ $string == $pattern ]] && echo "$pattern matches $string"
done

La ejecución de este script genera el siguiente resultado:

/foo/* matches /foo/bar
/foo/bar* matches /foo/bar
/foo/** matches /foo/bar

Esto funciona porque set -fdeshabilita la expansión del nombre de ruta, por lo que solo la expansión de llaves y la expansión de tilde ocurren en la declaración for pattern in /foo/{*,foo*,bar*,**,**/*}. Luego podemos usar la operación [[ $string == $pattern ]]de prueba para probar contra la expansión del nombre de ruta después de que la expansión de la llave ya se haya realizado.

No creo que {bar,baz} sea un patrón glob de concha (aunque ciertamente lo /foo/ba[rz]es), pero si quieres saber si $stringcoincide $patternpuedes hacerlo:

case "$string" in 
($pattern) put your successful execution statement here;;
(*)        this is where your failure case should be   ;;
esac

Puedes hacer tantas como quieras:

case "$string" in
($pattern1) do something;;
($pattern2) do differently;;
(*)         still no match;;
esac

Como Patrick señaló que necesita un "tipo diferente" de patrón:

[[ /foo/bar == /foo/@(bar|baz) ]]


string="/foo/bar"
pattern="/foo/@(bar|baz)"
[[ $string == $pattern ]]

Las cotizaciones no son necesarias allí.

Usaría grep así:

#!/bin/bash
string="/foo/bar"
pattern1="/foo/*"
pattern2="/foo/{bar,baz}"

if echo $string | grep -e "$pattern1" > /dev/null; then
    echo $string matches $pattern1
fi

if echo $string | grep -e "$pattern2" > /dev/null; then
    echo $string matches $pattern2
fi

Lo que da la salida:

./test2.bsh 
/foo/bar matches /foo/*

en zsh:

[[ $string = $~pattern ]] && print true