Capture de groupes à partir d'un RegEx Grep

J'ai ce petit script dans sh(Mac OSX 10.6) pour parcourir un tableau 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 du shell), il $namene contient que 0, 1 ou 2, selon grepque le nom de fichier correspond au sujet fourni. Ce que j'aimerais, c'est capturer ce qui est à l'intérieur des parens ([a-z]+)et le stocker dans une variable .

J'aimerais utiliser grepuniquement, si possible . Sinon, s'il vous plaît pas de Python ou Perl, etc. sedou quelque chose comme ça - je suis nouveau dans le shell et je voudrais attaquer cela sous l'angle puriste * nix.

De plus, en tant que bonu super cool , je suis curieux de savoir comment je peux concaténer une chaîne en shell? Est-ce que le groupe que j'ai capturé était la chaîne "un nom" stockée dans $ name, et je voulais ajouter la chaîne ".jpg" à la fin, est-ce possible cat $name '.jpg'?

Veuillez expliquer ce qui se passe, si vous avez le temps.

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 l'expression régulière dans une variable. Certains modèles ne fonctionneront pas s'ils sont inclus littéralement.

Ceci utilise =~qui est l'opérateur de correspondance d'expressions régulières 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.

Vous devez savoir que sans ancrages, cette expression régulière (et celle qui utilise grep) correspondra à l'un des exemples suivants et plus, ce qui peut ne pas être 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 par un ou plusieurs chiffres. Le carat représente le début de la chaîne. Si vous ajoutez un signe dollar à la fin de l'expression régulière, comme ceci:

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

alors le troisième exemple sera également éliminé car le point ne fait pas partie des caractères de l'expression régulière et 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(environ 2,5 ou plus tard, je pense, lorsque l' \Kopérateur a été ajouté):

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

L' \Kopérateur (recherche de longueur variable) entraîne la correspondance du modèle précédent, mais n'inclut pas la correspondance dans le résultat. L'équivalent de longueur fixe est (?<=)- le motif serait inclus avant la parenthèse fermante. Vous devez utiliser \Ksi quantificateurs peuvent correspondre à des chaînes de longueurs différentes (par exemple +, *, {2,4}).

L' (?=)opérateur correspond à des modèles de longueur fixe ou variable et est appelé "anticipation". Il n'inclut pas non plus la chaîne correspondante dans le résultat.

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

Le regex peut avoir besoin d'être ajusté selon qu'il y a d'autres caractères dans le nom de 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.

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

Mais si votre modèle convient, vous pouvez utiliser grepplusieurs fois dans un pipeline pour réduire d'abord votre ligne à un format connu, puis extraire juste le bit que vous voulez. (Bien que les outils aiment cutet sedsont bien meilleurs dans ce domaine).

Supposons à titre d'argument que votre modèle était un peu plus simple: [0-9]+_([a-z]+)_vous pouvez extraire ceci comme ceci:

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

Le premier grepsupprimerait toutes les lignes qui ne correspondraient pas à votre motif global, le second grep(qui l'a --only-matchingspécifié) afficherait la partie alpha du nom. Cela ne fonctionne que parce que le motif est approprié: la "partie alpha" est suffisamment spécifique pour extraire ce que vous voulez.

(À part: Personnellement, j'utiliserais grep+ cutpour obtenir ce que vous recherchez: echo $name | grep {pattern} | cut -d _ -f 2cela permet cutd'analyser la ligne en champs en la divisant sur le délimiteur _et renvoie uniquement le champ 2 (les numéros de champ commencent à 1)).

La philosophie Unix est d'avoir des outils qui font une chose, et le font bien, et les combinent pour réaliser des tâches non triviales, donc je dirais que grep+ sedetc est une façon plus Unixy de faire les choses :-)

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

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

aux éléments suivants:

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

pour obtenir uniquement le contenu du groupe de capture 1.

L' pcregrepoutil utilise la même syntaxe que celle que vous avez déjà utilisée grep, mais implémente les fonctionnalités dont vous avez besoin.

Le paramètre -ofonctionne comme la grepversion s'il est nu, mais il accepte également un paramètre numérique dans pcregrep, qui indique le groupe de capture que vous souhaitez afficher.

Avec cette solution, le script requiert un minimum de modifications. Vous remplacez simplement un utilitaire modulaire par un autre et ajustez les paramètres.

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

Pas possible en juste grep je crois

pour sed:

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

Je vais essayer le bonus:

echo "$name.jpg"

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

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

utiliser juste faire

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

Une suggestion pour vous - vous pouvez utiliser l'expansion des paramètres pour supprimer la partie du nom du dernier trait de soulignement, et de la même manière au début:

f=001_abc_0za.jpg
work=${f%_*}
name=${work#*_}

Alors nameaura la valeur abc.

Consultez la documentation des développeurs Apple , recherchez «Extension des paramètres».

si vous avez bash, vous pouvez utiliser la globalisation étendue

shopt -s extglob
shopt -s nullglob
shopt -s nocaseglob
for file in +([0-9])_+([a-z])_+([a-z0-9]).jpg
do
   IFS="_"
   set -- $file
   echo "This is your captured output : $2"
done

ou

ls +([0-9])_+([a-z])_+([a-z0-9]).jpg | while read file
do
   IFS="_"
   set -- $file
   echo "This is your captured output : $2"
done