Come posso stabilire a livello di codice se un nome file corrisponde a un modello glob shell?

Vorrei dire se una stringa $stringsarebbe abbinata a un modello glob $pattern. $stringpuò essere o meno il nome di un file esistente. Come posso fare questo?

Assumi i seguenti formati per le mie stringhe di input:

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

Mi piacerebbe trovare un linguaggio bash che determina se $stringsarebbe stato accompagnato da $pattern1, $pattern2o qualsiasi altro modello di glob arbitrario. Ecco cosa ho provato finora:

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

   Funziona quasi, tranne per il fatto che $patternviene interpretato come un modello di stringa e non come un modello glob.

2. [ "$string" = $pattern ]

   Il problema con questo approccio è che $patternviene espanso e quindi viene eseguito il confronto tra stringhe $stringe l'espansione di $pattern.

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

   Questo funziona, ma solo se $stringcontiene un file esistente.

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

   Questo non funziona perché l' =~operatore causa $patternl'interpretazione come un'espressione regolare estesa, non un modello glob o jolly.

Non esiste una soluzione generale per questo problema. Il motivo è che, in bash, l'espansione del controvento (cioè l' {pattern1,pattern2,...}espansione del nome del file (ovvero i modelli glob) sono considerati cose separate ed espanse in condizioni diverse e in momenti diversi. Ecco l'elenco completo delle espansioni che bash esegue:

• espansione parentesi graffa
• espansione della tilde
• espansione dei parametri e delle variabili
• sostituzione del comando
• espansione aritmetica
• frazionamento di parole
• espansione del percorso

Dal momento che ci preoccupiamo solo di un sottoinsieme di questi (forse parentesi graffa, tilde ed espansione del nome di percorso), è possibile utilizzare determinati modelli e meccanismi per limitare l'espansione in modo controllabile. Per esempio:

#!/bin/bash
set -f

string=/foo/bar

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

L'esecuzione di questo script genera il seguente output:

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

Questo perché set -fdisabilita l'espansione del nome percorso, quindi nell'istruzione si verificano solo l'espansione parentesi e l'espansione tilde for pattern in /foo/{*,foo*,bar*,**,**/*}. Possiamo quindi utilizzare l'operazione [[ $string == $pattern ]]di test per verificare l'espansione del nome percorso dopo che l'espansione del controvento è già stata eseguita.

Non credo che {bar,baz} sia un modello glob shell (anche se certamente lo /foo/ba[rz]è) ma se vuoi sapere se le $stringpartite $patternpuoi fare:

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

Puoi fare quanti ne vuoi:

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

Come ha sottolineato Patrick, hai bisogno di un "tipo diverso" di modello:

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


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

Le citazioni non sono necessarie lì.

Vorrei usare grep così:

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

Che dà l'output:

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

in zsh:

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