come usare sed, awk o gawk per stampare solo ciò che è abbinato?

Vedo molti esempi e pagine di manuale su come eseguire operazioni come la ricerca e la sostituzione utilizzando sed, awk o gawk.

Ma nel mio caso, ho un'espressione regolare che voglio eseguire su un file di testo per estrarre un valore specifico. Non voglio fare ricerca e sostituzione. Questo viene chiamato da bash. Facciamo un esempio:

Esempio di espressione regolare:

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

File di input di esempio:

a
b
c
abc12345xyz
a
b
c

Per quanto semplice possa sembrare, non riesco a capire come chiamare correttamente sed / awk / gawk. Quello che speravo di fare, è dal mio script bash avere:

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

Le cose che ho provato includono:

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

Il mio sed(Mac OS X) non funzionava con +. Ho provato *invece e ho aggiunto il ptag per la corrispondenza di stampa:

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

Per trovare almeno un carattere numerico senza + , userei:

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

Puoi usare sed per farlo

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

• -n non stampare la riga risultante
• -rquesto fa in modo che tu non abbia la possibilità di sfuggire ai genitori del gruppo di cattura ().
• \1 la partita del gruppo di cattura
• /g partita globale
• /p stampare il risultato

Ho scritto uno strumento per me stesso che lo rende più facile

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

Uso perlper rendere tutto più facile per me stesso. per esempio

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

Questo esegue Perl, l' -nopzione ordina a Perl di leggere una riga alla volta da STDIN ed eseguire il codice. L' -eopzione specifica l'istruzione da eseguire.

L'istruzione esegue un'espressione regolare sulla riga letta e, se corrisponde, stampa il contenuto della prima serie di parentesi graffe ($1 ).

Puoi farlo anche con più nomi di file alla fine. per esempio

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

Se la tua versione di lo grepsupporta puoi usare l' -oopzione per stampare solo la parte di qualsiasi riga che corrisponde alla tua espressione regolare.

In caso contrario, ecco il meglio che sedsono riuscito a trovare:

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

... che elimina / salta senza cifre e, per le righe rimanenti, rimuove tutti i caratteri non numerici iniziali e finali. (Immagino solo che la tua intenzione sia estrarre il numero da ogni riga che ne contiene uno).

Il problema con qualcosa come:

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

.... o

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

... è che sedsupporta solo la corrispondenza "avida" ... quindi il primo. * corrisponderà al resto della riga. A meno che non possiamo usare una classe di caratteri negata per ottenere una corrispondenza non avida ... o una versione di sedcompatibile con Perl o altre estensioni alle sue espressioni regolari, non possiamo estrarre una corrispondenza di pattern precisa dallo spazio del pattern (una linea ).

È possibile utilizzare awkcon match()per accedere al gruppo acquisito:

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

Questo cerca di abbinare il modello abc[0-9]+xyz. Se lo fa, memorizza le sue sezioni nell'array matches, il cui primo elemento è il blocco [0-9]+. Poiché match() restituisce la posizione del carattere, o indice, di dove inizia quella sottostringa (1, se inizia all'inizio della stringa) , attiva l' printazione.

Con greppuoi usare uno sguardo dietro e uno sguardo avanti:

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

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

Questo controlla il modello [0-9]+quando si verifica all'interno abce xyzstampa solo le cifre.

perl è la sintassi più pulita, ma se non hai perl (non sempre presente, capisco), l'unico modo per usare gawk e componenti di un'espressione regolare è usare la funzione gensub.

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

l'output del file di input di esempio sarà

12345

Nota: gensub sostituisce l'intera regex (tra //), quindi è necessario inserire. * Prima e dopo ([0-9] +) per eliminare il testo prima e dopo il numero nella sostituzione.

Se vuoi selezionare le linee, elimina i bit che non vuoi:

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

Fondamentalmente seleziona le linee che desideri egrepe quindi utilizza sedper rimuovere i bit prima e dopo il numero.

Puoi vederlo in azione qui:

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

Aggiornamento: ovviamente se la tua situazione attuale è più complessa, le RE dovranno essere modificate. Ad esempio, se hai sempre un singolo numero sepolto entro zero o più non numerici all'inizio e alla fine:

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

Il caso dell'OP non specifica che possono esserci più corrispondenze su una singola riga, ma per il traffico di Google, aggiungerò un esempio anche per questo.

Poiché la necessità dell'OP è estrarre un gruppo da un pattern, l'utilizzo grep -orichiederà 2 passaggi. Ma trovo ancora questo il modo più intuitivo per portare a termine il lavoro.

$ 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

Poiché il tempo del processore è fondamentalmente gratuito ma la leggibilità umana non ha prezzo, tendo a rifattorizzare il mio codice in base alla domanda "tra un anno, cosa penserò che faccia?" Infatti, per il codice che intendo condividere pubblicamente o con il mio team, mi aprirò persino man grepper capire quali sono le opzioni lunghe e sostituirle. Così:grep --only-matching --extended-regexp

puoi farlo con la shell

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

Per awk. Userei il seguente script:

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

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