¿Cómo usar sed, awk o gawk para imprimir solo lo que coincide?

Veo muchos ejemplos y páginas de manual sobre cómo hacer cosas como buscar y reemplazar usando sed, awk o gawk.

Pero en mi caso, tengo una expresión regular que quiero ejecutar en un archivo de texto para extraer un valor específico. No quiero buscar y reemplazar. Esto se llama desde bash. Usemos un ejemplo:

Ejemplo de expresión regular:

.*abc([0-9]+)xyz.*

Archivo de entrada de ejemplo:

a
b
c
abc12345xyz
a
b
c

Tan simple como suena, no puedo entender cómo llamar a sed / awk / gawk correctamente. Lo que esperaba hacer es que mi script bash tenga:

myvalue=$( sed <...something...> input.txt )

Las cosas que he probado incluyen:

sed -e 's/.*([0-9]).*/\\1/g' example.txt # extracts the entire input file
sed -n 's/.*([0-9]).*/\\1/g' example.txt # extracts nothing

Mi sed(Mac OS X) no funcionó con +. Intenté en su *lugar y agregué una petiqueta para imprimir coincidencia:

sed -n 's/^.*abc\([0-9]*\)xyz.*$/\1/p' example.txt

Para hacer coincidir al menos un carácter numérico sin +, usaría:

sed -n 's/^.*abc\([0-9][0-9]*\)xyz.*$/\1/p' example.txt

Puedes usar sed para hacer esto

 sed -rn 's/.*abc([0-9]+)xyz.*/\1/gp'

• -n no imprima la línea resultante
• -resto hace que no tenga el escape del grupo de captura parens ().
• \1 el partido del grupo de captura
• /g partido global
• /p imprimir el resultado

Escribí una herramienta para mí que lo hace más fácil.

rip 'abc(\d+)xyz' '$1'

Utilizo perlpara hacer esto más fácil para mí. p.ej

perl -ne 'print $1 if /.*abc([0-9]+)xyz.*/'

Esto ejecuta Perl, la -nopción le indica a Perl que lea en una línea a la vez desde STDIN y ejecute el código. La -eopción especifica la instrucción a ejecutar.

La instrucción ejecuta una expresión regular en la línea leída y, si coincide, imprime el contenido del primer conjunto de corchetes ( $1).

También puede hacer esto con varios nombres de archivo al final. p.ej

perl -ne 'print $1 if /.*abc([0-9]+)xyz.*/' example1.txt example2.txt

Si su versión de lo grepadmite, puede usar la -oopción para imprimir solo la parte de cualquier línea que coincida con su expresión regular.

Si no es así, aquí está lo mejor sedque se me ocurrió:

sed -e '/[0-9]/!d' -e 's/^[^0-9]*//' -e 's/[^0-9]*$//'

... que elimina / omite sin dígitos y, para las líneas restantes, elimina todos los caracteres iniciales y finales que no son dígitos. (Solo supongo que su intención es extraer el número de cada línea que contiene uno).

El problema con algo como:

sed -e 's/.*\([0-9]*\).*/&/' 

.... o

sed -e 's/.*\([0-9]*\).*/\1/'

... es que sedsolo admite coincidencias "codiciosas" ... por lo que el primero. * coincidirá con el resto de la línea. A menos que podamos usar una clase de carácter negada para lograr una coincidencia no codiciosa ... o una versión sedcompatible con Perl u otras extensiones para sus expresiones regulares, no podemos extraer una coincidencia de patrón precisa con el espacio de patrón (una línea ).

Puede utilizar awkcon match()para acceder al grupo capturado:

$ awk 'match($0, /abc([0-9]+)xyz/, matches) {print matches[1]}' file
12345

Esto intenta coincidir con el patrón abc[0-9]+xyz. Si lo hace, almacena sus cortes en la matriz matches, cuyo primer elemento es el bloque [0-9]+. Dado que match() devuelve la posición del carácter, o índice, de donde comienza esa subcadena (1, si comienza al principio de la cadena) , activa la printacción.

Con greppuede utilizar una mirada hacia atrás y hacia adelante:

$ grep -oP '(?<=abc)[0-9]+(?=xyz)' file
12345

$ grep -oP 'abc\K[0-9]+(?=xyz)' file
12345

Esto comprueba el patrón [0-9]+cuando se produce dentro abcy xyzya sólo imprime los dígitos.

perl es la sintaxis más limpia, pero si no tiene perl (no siempre está ahí, según tengo entendido), entonces la única forma de usar gawk y los componentes de una expresión regular es usar la función gensub.

gawk '/abc[0-9]+xyz/ { print gensub(/.*([0-9]+).*/,"\\1","g"); }' < file

la salida del archivo de entrada de muestra será

12345

Nota: gensub reemplaza toda la expresión regular (entre //), por lo que debe colocar. * Antes y después de ([0-9] +) para eliminar el texto antes y después del número en la sustitución.

Si desea seleccionar líneas, elimine los bits que no desea:

egrep 'abc[0-9]+xyz' inputFile | sed -e 's/^.*abc//' -e 's/xyz.*$//'

Básicamente, selecciona las líneas que desea egrepy luego las usa sedpara quitar los bits antes y después del número.

Puedes ver esto en acción aquí:

pax> echo 'a
b
c
abc12345xyz
a
b
c' | egrep 'abc[0-9]+xyz' | sed -e 's/^.*abc//' -e 's/xyz.*$//'
12345
pax> 

Actualización: obviamente, si su situación real es más compleja, los RE necesitarán modificarlos. Por ejemplo, si siempre tuvo un solo número enterrado dentro de cero o más números no numéricos al principio y al final:

egrep '[^0-9]*[0-9]+[^0-9]*$' inputFile | sed -e 's/^[^0-9]*//' -e 's/[^0-9]*$//'

El caso del OP no especifica que puede haber múltiples coincidencias en una sola línea, pero para el tráfico de Google, también agregaré un ejemplo para eso.

Dado que la necesidad del OP es extraer un grupo de un patrón, el uso grep -orequerirá 2 pasadas. Pero, todavía encuentro que esta es la forma más intuitiva de hacer el trabajo.

$ cat > example.txt <<TXT
a
b
c
abc12345xyz
a
abc23451xyz asdf abc34512xyz
c
TXT

$ cat example.txt | grep -oE 'abc([0-9]+)xyz'
abc12345xyz
abc23451xyz
abc34512xyz

$ cat example.txt | grep -oE 'abc([0-9]+)xyz' | grep -oE '[0-9]+'
12345
23451
34512

Dado que el tiempo del procesador es básicamente gratuito, pero la legibilidad humana no tiene precio, tiendo a refactorizar mi código en función de la pregunta, "dentro de un año, ¿qué voy a pensar que hace esto?" De hecho, para el código que tengo la intención de compartir públicamente o con mi equipo, incluso abriré man greppara averiguar cuáles son las opciones largas y sustituirlas. Al igual que:grep --only-matching --extended-regexp

puedes hacerlo con el caparazón

while read -r line
do
    case "$line" in
        *abc*[0-9]*xyz* ) 
            t="${line##abc}"
            echo "num is ${t%%xyz}";;
    esac
done <"file"

Por awk. Usaría el siguiente script:

/.*abc([0-9]+)xyz.*/ {
            print $0;
            next;
            }
            {
            /* default, do nothing */
            }

gawk '/.*abc([0-9]+)xyz.*/' file