Catturare gruppi da un GreEx RegEx

Ho questo piccolo script in sh(Mac OSX 10.6) per sfogliare una serie di file. Google ha smesso di essere utile a questo punto:

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

Fino ad ora (ovviamente, per voi guru della shell) $namevale solo 0, 1 o 2, a seconda se si greptrova che il nome file corrisponde all'argomento fornito. Quello che mi piacerebbe è catturare ciò che è dentro le parentesi ([a-z]+)e archiviarlo in una variabile .

Mi piacerebbe usare grepsolo, se possibile . Altrimenti, per favore niente Python o Perl, ecc. sedO qualcosa del genere - Sono nuovo a sgusciare e vorrei attaccarlo dall'angolo purista * nix.

Inoltre, come un super cool , sono curioso di sapere come posso concatenare la stringa nella shell? Il gruppo che ho catturato era la stringa "somename" memorizzata in $ name e volevo aggiungere la stringa ".jpg" alla fine, posso cat $name '.jpg'?

Per favore, spiega cosa sta succedendo, se hai tempo.

Se stai usando Bash, non devi nemmeno usare 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

È meglio mettere la regex in una variabile. Alcuni schemi non funzioneranno se inclusi letteralmente.

Questo utilizza =~quale è l'operatore di corrispondenza regex di Bash. I risultati della partita vengono salvati in un array chiamato $BASH_REMATCH. Il primo gruppo di acquisizione è memorizzato nell'indice 1, il secondo (se presente) nell'indice 2, ecc. L'indice zero è la corrispondenza completa.

Dovresti essere consapevole che senza ancore, questa regex (e quella che usa grep) corrisponderà a uno dei seguenti esempi e altro, che potrebbe non essere quello che stai cercando:

123_abc_d4e5
xyz123_abc_d4e5
123_abc_d4e5.xyz
xyz123_abc_d4e5.xyz

Per eliminare il secondo e il quarto esempio, rendi il tuo regex in questo modo:

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

che dice che la stringa deve iniziare con una o più cifre. Il carato rappresenta l'inizio della stringa. Se aggiungi un segno di dollaro alla fine della regex, in questo modo:

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

quindi anche il terzo esempio verrà eliminato poiché il punto non è tra i caratteri nella regex e il simbolo del dollaro rappresenta la fine della stringa. Nota che anche il quarto esempio fallisce questa corrispondenza.

Se hai GNU grep(circa 2.5 o versioni successive, penso, quando l' \Koperatore è stato aggiunto):

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

L' \Koperatore (look-behind a lunghezza variabile) fa corrispondere il modello precedente, ma non include la corrispondenza nel risultato. L'equivalente a lunghezza fissa è (?<=)- il modello sarebbe incluso prima della parentesi di chiusura. È necessario utilizzare \Kse quantificatori possono corrispondere a stringhe di lunghezza diversa (ad esempio +, *, {2,4}).

L' (?=)operatore abbina schemi a lunghezza fissa o variabile e viene chiamato "look-ahead". Inoltre non include la stringa corrispondente nel risultato.

Al fine di rendere la corrispondenza senza distinzione tra maiuscole e minuscole, (?i)viene utilizzato l' operatore. Colpisce i modelli che lo seguono, quindi la sua posizione è significativa.

Potrebbe essere necessario modificare la regex in base alla presenza di altri caratteri nel nome file. Noterai che in questo caso, mostro un esempio di concatenazione di una stringa mentre viene catturata la sottostringa.

Questo non è davvero possibile con puro grep, almeno non in generale.

Ma se il tuo modello è adatto, potresti essere in grado di utilizzare greppiù volte all'interno di una pipeline per ridurre prima la linea in un formato noto, quindi estrarre solo il bit desiderato. (Sebbene gli strumenti piacciano cute sedsiano molto migliori in questo).

Supponiamo per amor di discussione che il tuo modello fosse un po 'più semplice: [0-9]+_([a-z]+)_potresti estrarlo in questo modo:

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

Il primo greprimuove tutte le righe che non corrispondono al tuo patern generale, il secondo grep(che ha --only-matchingspecificato) mostrerà la parte alfa del nome. Questo funziona solo perché il modello è adatto: "porzione alfa" è abbastanza specifica da estrarre ciò che vuoi.

(A parte: Personalmente userei grep+ cutper ottenere ciò che stai cercando:. echo $name | grep {pattern} | cut -d _ -f 2Questo arriva cutad analizzare la linea in campi dividendo il delimitatore _, e restituisce solo il campo 2 (i numeri dei campi iniziano da 1).

La filosofia di Unix è quella di avere strumenti che facciano una cosa, e la facciano bene, e combinandoli per raggiungere compiti non banali, quindi direi che grep+ sedetc è un modo più Unixy di fare le cose :-)

Mi rendo conto che una risposta era già stata accettata per questo, ma da un "angolo purista rigorosamente * nix" sembra che sia lo strumento giusto per il lavoro pcregrep, che non sembra essere stato ancora menzionato. Prova a cambiare le linee:

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

al seguente:

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

per ottenere solo i contenuti del gruppo di acquisizione 1.

Il pcregrep strumento utilizza la stessa sintassi con cui hai già utilizzato grep, ma implementa le funzionalità di cui hai bisogno.

Il parametro -o funziona esattamente come la grepversione se è nudo, ma accetta anche un parametro numerico pcregrep, che indica quale gruppo di acquisizione si desidera mostrare.

Con questa soluzione è necessario un minimo di modifica nello script. È sufficiente sostituire un'utilità modulare con un'altra e modificare i parametri.

Nota interessante: è possibile utilizzare più argomenti -o per restituire più gruppi di acquisizione nell'ordine in cui vengono visualizzati sulla riga.

Credo che non sia possibile solo in grep

per sed:

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

Prenderò una pugnalata al bonus però:

echo "$name.jpg"

Questa è una soluzione che utilizza gawk. È qualcosa che trovo che devo usare spesso, quindi ho creato una funzione per questo

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

da usare basta

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

Un suggerimento per te: puoi usare l'espansione dei parametri per rimuovere la parte del nome dall'ultimo trattino basso in poi, e allo stesso modo all'inizio:

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

Quindi nameavrà il valore abc.

Consulta i documenti per gli sviluppatori Apple , cerca "Espansione parametri".

se hai bash, puoi usare il globbing esteso

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

o

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