Capturer les groupes à partir d'un RegEx Grep

Question

J'ai ce petit script dans sh (Mac OSX 10.6) pour consulter un ensemble de fichiers. Google a cessé d'être utile à ce stade :

files="*.jpg"
for f in $files
    do
        echo $f | grep -oEi '[0-9]+_([a-z]+)_[0-9a-z]*'
        name=$?
        echo $name
    done

Jusqu'à présent (évidemment, pour vous, gourous des coquillages) $name tient simplement 0, 1 ou 2, selon si grep a constaté que le nom du fichier correspondait à la matière fournie. Ce que j'aimerais, c'est capturer ce qui se trouve à l'intérieur des parenthèses. ([a-z]+) et le stocker dans une variable .

J'aimerais à utiliser grep seulement, si possible . Dans le cas contraire, veuillez ne pas utiliser Python ou Perl, etc. sed ou quelque chose comme ça - je suis nouveau dans le shell et j'aimerais attaquer cela sous l'angle du puriste *nix.

En outre, en tant que super-cool bonu je suis curieux de savoir comment concaténer des chaînes de caractères dans le shell ? Si le groupe que j'ai capturé était la chaîne "somename" stockée dans $name, et que je voulais ajouter la chaîne ".jpg" à la fin de celle-ci, pourrais-je cat $name '.jpg' ?

S'il vous plaît, expliquez ce qui se passe, si vous avez le temps.

Answer 1

Si vous utilisez Bash, vous n'avez même pas besoin d'utiliser grep :

files="*.jpg"
regex="[0-9]+_([a-z]+)_[0-9a-z]*"
for f in $files    # unquoted in order to allow the glob to expand
do
    if [[ $f =~ $regex ]]
    then
        name="${BASH_REMATCH[1]}"
        echo "${name}.jpg"    # concatenate strings
        name="${name}.jpg"    # same thing stored in a variable
    else
        echo "$f doesn't match" >&2 # this could get noisy if there are a lot of non-matching files
    fi
done

Il est préférable de mettre la regex dans une variable. Certains motifs ne fonctionneront pas s'ils sont inclus littéralement.

Cela utilise =~ qui est l'opérateur de correspondance regex de Bash. Les résultats de la correspondance sont enregistrés dans un tableau appelé $BASH_REMATCH . Le premier groupe de capture est stocké dans l'index 1, le second (le cas échéant) dans l'index 2, etc. L'index zéro est la correspondance complète.

Il faut savoir que sans ancres, cette regex (et celle qui utilise la fonction grep ) correspondra à tous les exemples suivants et à d'autres, ce qui n'est peut-être pas ce que vous recherchez :

123_abc_d4e5
xyz123_abc_d4e5
123_abc_d4e5.xyz
xyz123_abc_d4e5.xyz

Pour éliminer les deuxième et quatrième exemples, faites votre regex comme ceci :

^[0-9]+_([a-z]+)_[0-9a-z]*

qui dit que la chaîne doit commencer avec un ou plusieurs chiffres. Le carat représente le début de la chaîne. Si vous ajoutez un signe dollar à la fin de la regex, comme ceci :

^[0-9]+_([a-z]+)_[0-9a-z]*$

alors le troisième exemple sera également éliminé puisque le point ne fait pas partie des caractères de la regex et que le signe dollar représente la fin de la chaîne. Notez que le quatrième exemple échoue également à cette correspondance.

Si vous avez GNU grep (vers 2.5 ou plus tard, je pense, lorsque la \K a été ajouté) :

name=$(echo "$f" | grep -Po '(?i)[0-9]+_\K[a-z]+(?=_[0-9a-z]*)').jpg

El \K (look-behind de longueur variable) fait correspondre le motif précédent, mais n'inclut pas la correspondance dans le résultat. L'équivalent en longueur fixe est (?<=) - le motif serait inclus avant la parenthèse fermante. Vous devez utiliser \K si les quantificateurs peuvent correspondre à des chaînes de caractères de différentes longueurs (par ex. + , * , {2,4} ).

El (?=) correspond à des motifs de longueur fixe ou variable et est appelé "look-ahead". Il n'inclut pas non plus la chaîne trouvée dans le résultat.

Afin de rendre la correspondance insensible à la casse, l'option (?i) est utilisé. Il affecte les motifs qui le suivent, sa position est donc importante.

La regex peut devoir être ajustée en fonction de la présence d'autres caractères dans le nom du fichier. Vous remarquerez que dans ce cas, je montre un exemple de concaténation d'une chaîne en même temps que la sous-chaîne est capturée.

Answer 2

Ce n'est pas vraiment possible avec de purs grep du moins pas en général.

Mais si votre modèle est adapté, vous pourrez peut-être utiliser grep plusieurs fois dans un pipeline pour d'abord réduire votre ligne à un format connu, et ensuite extraire seulement le bit que vous voulez. (Bien que des outils comme cut y sed sont bien meilleurs dans ce domaine).

Supposons, à titre d'exemple, que votre modèle soit un peu plus simple : [0-9]+_([a-z]+)_ Vous pourriez l'extraire comme suit :

echo $name | grep -Ei '[0-9]+_[a-z]+_' | grep -oEi '[a-z]+'

Le premier grep enlèverait toutes les lignes qui ne correspondent pas à votre paternité globale, la seconde grep (qui a --only-matching spécifié) afficherait la partie alpha du nom. Cela ne fonctionne que parce que le modèle est approprié : "portion alpha" est suffisamment spécifique pour faire ressortir ce que vous voulez.

(A propos : Personnellement, j'utiliserais grep + cut pour atteindre ce que vous recherchez : echo $name | grep {pattern} | cut -d _ -f 2 . Cela permet cut pour analyser la ligne en champs en la divisant par le délimiteur. _ et renvoie uniquement le champ 2 (les numéros de champ commencent à 1)).

La philosophie d'Unix est de disposer d'outils qui font une chose, et qui la font bien, et de les combiner pour réaliser des tâches non triviales. grep + sed etc est une façon plus Unixy de faire les choses :-)

Answer 3

Je me rends compte qu'une réponse a déjà été acceptée pour cela, mais d'un point de vue "strictement puriste *nix", il semble que le bon outil pour le travail soit pcregrep qui ne semble pas avoir été mentionné jusqu'à présent. Essayez de changer les lignes :

    echo $f | grep -oEi '[0-9]+_([a-z]+)_[0-9a-z]*'
    name=$?

à ce qui suit :

    name=$(echo $f | pcregrep -o1 -Ei '[0-9]+_([a-z]+)_[0-9a-z]*')

pour obtenir uniquement le contenu du groupe de capture 1.

El pcregrep utilise la même syntaxe que celle que vous avez déjà utilisée avec l'outil grep mais met en œuvre la fonctionnalité dont vous avez besoin.

Le paramètre -o fonctionne comme le grep s'il est nu, mais il accepte aussi un paramètre numérique en pcregrep qui indique le groupe de capture que vous souhaitez afficher.

Avec cette solution, il n'y a qu'un minimum de changement à faire dans le script. Il suffit de remplacer un utilitaire modulaire par un autre et de modifier les paramètres.

Note intéressante : Vous pouvez utiliser plusieurs arguments -o pour renvoyer plusieurs groupes de capture dans l'ordre dans lequel ils apparaissent sur la ligne.

Answer 4

Pas possible avec juste grep je crois

pour sed :

name=`echo $f | sed -E 's/([0-9]+_([a-z]+)_[0-9a-z]*)|.*/\2/'`

Je vais quand même tenter le coup avec le bonus :

echo "$name.jpg"

Answer 5

Il s'agit d'une solution qui utilise gawk. C'est quelque chose que j'ai besoin d'utiliser souvent, donc j'ai créé une fonction pour cela.

function regex1 { gawk 'match($0,/'$1'/, ary) {print ary['${2:-'1'}']}'; }

pour l'utiliser, il suffit de faire

$ echo 'hello world' | regex1 'hello\s(.*)'
world