Comment puis-je déterminer par programme si un nom de fichier correspond à un modèle glob de shell?

Je voudrais dire si une chaîne $stringcorrespondrait à un modèle glob $pattern. $stringpeut ou peut ne pas être le nom d'un fichier existant. Comment puis-je faire ceci?

Supposons les formats suivants pour mes chaînes d'entrée:

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

Je voudrais trouver un idiome bash qui détermine si $stringserait compensée par $pattern1, $pattern2ou tout autre motif glob arbitraire. Voici ce que j'ai essayé jusqu'à présent:

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

   Cela fonctionne presque, sauf qu'il $patternest interprété comme un modèle de chaîne et non comme un modèle global.

2. [ "$string" = $pattern ]

   Le problème avec cette approche est qu'elle $patternest étendue et que la comparaison des chaînes est effectuée entre $stringet l'expansion de $pattern.

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

   Celui-ci fonctionne, mais uniquement s'il $stringcontient un fichier qui existe.

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

   Cela ne fonctionne pas car l' =~opérateur fait $patternen sorte qu'il soit interprété comme une expression régulière étendue et non comme un modèle glob ou générique.

Il n'y a pas de solution générale à ce problème. La raison en est que, dans bash, l'expansion d'accolade (c'est-à-dire, {pattern1,pattern2,...}et l'expansion de nom de fichier (alias les modèles glob)) sont considérées comme des choses distinctes et développées dans différentes conditions et à différents moments. Voici la liste complète des extensions que bash effectue:

• expansion de l'accolade
• expansion tilde
• expansion des paramètres et des variables
• substitution de commande
• expansion arithmétique
• division de mot
• extension du nom de chemin

Étant donné que nous ne nous soucions que d'un sous-ensemble de ces derniers (peut-être l'expansion d'accolade, de tilde et de chemin d'accès), il est possible d'utiliser certains modèles et mécanismes pour restreindre l'expansion de manière contrôlable. Par exemple:

#!/bin/bash
set -f

string=/foo/bar

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

L'exécution de ce script génère la sortie suivante:

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

Cela fonctionne car set -fdésactive l'expansion des noms de chemin, donc seules l'expansion entre accolades et l'expansion tilde se produisent dans l'instruction for pattern in /foo/{*,foo*,bar*,**,**/*}. Nous pouvons ensuite utiliser l'opération [[ $string == $pattern ]]de test pour tester l'expansion du nom de chemin une fois que l'extension d'accolade a déjà été effectuée.

Je ne crois pas que ce {bar,baz} soit un modèle de glob de shell (bien que ce soit certainement le cas /foo/ba[rz]) mais si vous voulez savoir si des $stringcorrespondances $patternvous pouvez le faire:

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

Vous pouvez en faire autant que vous le souhaitez:

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

Comme Patrick l'a souligné, vous avez besoin d'un "type différent" de motif:

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


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

Les citations n'y sont pas nécessaires.

J'utiliserais ainsi grep:

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

Ce qui donne la sortie:

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

en zsh:

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