Captura de grupos desde un Grep RegEx

Tengo este pequeño script en sh(Mac OSX 10.6) para mirar a través de una variedad de archivos. Google ha dejado de ser útil en este punto:

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

Hasta ahora (obviamente, para ustedes gurús de shell) $namesimplemente tiene 0, 1 o 2, dependiendo de si se grepencontró que el nombre del archivo coincide con el asunto proporcionado. Lo que me gustaría es capturar lo que hay dentro de los padres ([a-z]+)y almacenarlo en una variable .

Me gustaría usar grepsolo, si es posible . Si no es así, no use Python o Perl, etc. sedo algo así: soy nuevo en shell y me gustaría atacar esto desde el ángulo purista * nix.

Además, como bonificaciones súper geniales , tengo curiosidad por saber cómo puedo concatenar la cuerda en la concha. ¿El grupo que capturé era la cadena "somename" almacenada en $ name, y quería agregar la cadena ".jpg" al final, ¿podría cat $name '.jpg'?

Por favor explique qué está pasando, si tiene tiempo.

Si está usando Bash, ni siquiera tiene que usar 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

Es mejor poner la expresión regular en una variable. Algunos patrones no funcionarán si se incluyen literalmente.

Esto utiliza =~cuál es el operador de coincidencia de expresiones regulares de Bash. Los resultados del partido se guardan en una matriz llamada $BASH_REMATCH. El primer grupo de captura se almacena en el índice 1, el segundo (si lo hay) en el índice 2, etc. El índice cero es la coincidencia completa.

Debe tener en cuenta que sin las anclas, esta expresión regular (y la que usa grep) coincidirá con cualquiera de los siguientes ejemplos y más, que pueden no ser lo que está buscando:

123_abc_d4e5
xyz123_abc_d4e5
123_abc_d4e5.xyz
xyz123_abc_d4e5.xyz

Para eliminar los ejemplos segundo y cuarto, haga su expresión regular de esta manera:

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

que dice que la cadena debe comenzar con uno o más dígitos. El quilate representa el comienzo de la cadena. Si agrega un signo de dólar al final de la expresión regular, así:

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

entonces el tercer ejemplo también será eliminado ya que el punto no está entre los caracteres en la expresión regular y el signo de dólar representa el final de la cadena. Tenga en cuenta que el cuarto ejemplo también falla en esta coincidencia.

Si tiene GNU grep(alrededor de 2.5 o posterior, creo, cuando \Kse agregó el operador):

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

El \Koperador (retrospectiva de longitud variable) hace que el patrón anterior coincida, pero no incluye la coincidencia en el resultado. El equivalente de longitud fija es (?<=): el patrón se incluiría antes del paréntesis de cierre. Debe usar \Ksi los cuantificadores pueden coincidir con cadenas de diferentes longitudes (p +. Ej . *, {2,4}).

El (?=)operador coincide con patrones de longitud fija o variable y se llama "mirar hacia adelante". Tampoco incluye la cadena coincidente en el resultado.

Para que la coincidencia no distinga entre mayúsculas y minúsculas, (?i)se utiliza el operador. Afecta los patrones que lo siguen, por lo que su posición es significativa.

Es posible que sea necesario ajustar la expresión regular dependiendo de si hay otros caracteres en el nombre del archivo. Notarás que en este caso, muestro un ejemplo de concatenación de una cadena al mismo tiempo que se captura la subcadena.

Esto no es realmente posible con puro grep, al menos en general.

Pero si su patrón es adecuado, puede usarlo grepvarias veces dentro de una tubería para reducir primero su línea a un formato conocido y luego extraer solo el bit que desee. (Aunque las herramientas les gustan cuty sedson mucho mejores en esto).

Supongamos, por el argumento, que su patrón es un poco más simple: [0-9]+_([a-z]+)_podría extraer esto de esta manera:

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

El primero grepeliminaría cualquier línea que no coincidiera con su patrón general, el segundo grep(que ha --only-matchingespecificado) mostrará la parte alfa del nombre. Esto solo funciona porque el patrón es adecuado: la "porción alfa" es lo suficientemente específica como para extraer lo que desea.

(Aparte: Personalmente, usaría grep+ cutpara lograr lo que busca: echo $name | grep {pattern} | cut -d _ -f 2esto cutpermite analizar la línea en campos al dividir en el delimitador _, y devuelve solo el campo 2 (los números de campo comienzan en 1)).

La filosofía de Unix es tener herramientas que hacen una cosa, y lo hacen bien, y combinarlas para lograr tareas no triviales, por lo que diría que grep+ sedetc es una forma más Unixy de hacer las cosas :-)

Me doy cuenta de que ya se aceptó una respuesta para esto, pero desde un "ángulo estrictamente * nix purista" parece que la herramienta adecuada para el trabajo es pcregrep, lo que parece no haber sido mencionado todavía. Intenta cambiar las líneas:

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

a lo siguiente:

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

para obtener solo los contenidos del grupo de captura 1.

La pcregrepherramienta utiliza la misma sintaxis que ya usó grep, pero implementa la funcionalidad que necesita.

El parámetro -ofunciona igual que la grepversión si es simple , pero también acepta un parámetro numérico pcregrep, que indica qué grupo de captura desea mostrar.

Con esta solución, se requiere un mínimo de cambio en el script. Simplemente reemplace una utilidad modular con otra y modifique los parámetros.

Nota interesante: puede usar múltiples argumentos -o para devolver múltiples grupos de captura en el orden en que aparecen en la línea.

No es posible solo con grep, creo

para sed:

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

Sin embargo, probaré la bonificación:

echo "$name.jpg"

Esta es una solución que usa gawk. Es algo que creo que necesito usar a menudo, así que creé una función para ello.

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

para usar solo hacer

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

Una sugerencia para usted: puede usar la expansión de parámetros para eliminar la parte del nombre del último guión bajo y, de manera similar, al principio:

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

Entonces nametendrá el valor abc.

Consulte los documentos para desarrolladores de Apple , busque 'Expansión de parámetros'.

si tienes bash, puedes usar globbing extendido

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