Como posso saber programaticamente se um nome de arquivo corresponde a um padrão de shell glob?

Gostaria de dizer se uma string $stringseria correspondida por um padrão glob $pattern. $stringpode ou não ser o nome de um arquivo existente. Como posso fazer isso?

Suponha os seguintes formatos para minhas seqüências de caracteres de entrada:

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

Eu gostaria de encontrar uma linguagem bash que determina se $stringseria acompanhado por $pattern1, $pattern2ou qualquer outro padrão glob arbitrária. Aqui está o que eu tentei até agora:

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

   Isso quase funciona, exceto que $patterné interpretado como um padrão de cadeia e não como um padrão glob.

2. [ "$string" = $pattern ]

   O problema com essa abordagem é que $patterné expandido e a comparação de cadeias é executada entre $stringe a expansão de $pattern.

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

   Este funciona, mas somente se $stringcontém um arquivo que existe.

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

   Isso não funciona porque o =~operador faz $patterncom que seja interpretado como uma expressão regular estendida, não como um padrão glob ou curinga.

Não há solução geral para esse problema. O motivo é que, no bash, a expansão de chaves (ou seja, {pattern1,pattern2,...}expansão de nome de arquivo (também conhecida como padrões glob)) é considerada uma coisa separada e expandida sob diferentes condições e em diferentes momentos.Aqui está a lista completa das expansões executadas pelo bash:

• cinta de expansão
• expansão de til
• expansão de parâmetro e variável
• substituição de comando
• expansão aritmética
• divisão de palavras
• expansão do nome do caminho

Como nos preocupamos apenas com um subconjunto deles (talvez expansão entre chaves, til e nome do caminho), é possível usar certos padrões e mecanismos para restringir a expansão de maneira controlável. Por exemplo:

#!/bin/bash
set -f

string=/foo/bar

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

A execução desse script gera a seguinte saída:

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

Isso funciona porque set -fa expansão desativa caminho, portanto, apenas a expansão cinta e expansão til ocorrer na declaração for pattern in /foo/{*,foo*,bar*,**,**/*}. Em seguida, podemos usar a operação [[ $string == $pattern ]]de teste para testar a expansão do nome do caminho após a expansão da chave já ter sido executada.

Eu não acredito que esse {bar,baz} seja um padrão shell glob (embora certamente /foo/ba[rz]seja), mas se você quiser saber se $stringcorresponde, $patternpode:

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

Você pode fazer quantas quiser:

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

Como Patrick apontou, você precisa de um "tipo diferente" de padrão:

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


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

Citações não são necessárias lá.

Eu usaria o grep assim:

#!/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

O que fornece a saída:

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

no zsh:

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