Grep può produrre solo raggruppamenti specifici corrispondenti?

Di 'che ho un file:

# file: 'test.txt'
foobar bash 1
bash
foobar happy
foobar

Voglio solo sapere quali parole compaiono dopo "foobar", quindi posso usare questa regex:

"foobar \(\w\+\)"

Le parentesi indicano che ho un interesse speciale per la parola subito dopo il foobar. Ma quando faccio un grep "foobar \(\w\+\)" test.txt, ottengo le intere righe che corrispondono all'intera regex, piuttosto che solo "la parola dopo foobar":

foobar bash 1
foobar happy

Preferirei di gran lunga che l'output di quel comando fosse simile al seguente:

bash
happy

C'è un modo per dire a grep di produrre solo gli elementi che corrispondono al raggruppamento (o un raggruppamento specifico) in un'espressione regolare?

GNU grep ha l' -Popzione per le regex in stile perl e l' -oopzione per stampare solo ciò che corrisponde al modello. Questi possono essere combinati usando asserzioni look-around (descritte in Extended Patterns nella manpage perlre ) per rimuovere parte del pattern grep da ciò che è stato determinato corrispondere ai fini di -o.

$ grep -oP 'foobar \K\w+' test.txt
bash
happy
$

Il \Kè la forma abbreviata (e la forma più efficiente) di (?<=pattern)cui si utilizza come uno zero-width look-dietro l'affermazione prima che il testo che si desidera in uscita. (?=pattern)può essere utilizzato come un'asserzione di previsione a larghezza zero dopo il testo che si desidera produrre.

Ad esempio, se si desidera abbinare la parola tra fooe bar, è possibile utilizzare:

$ grep -oP 'foo \K\w+(?= bar)' test.txt

o (per simmetria)

$ grep -oP '(?<=foo )\w+(?= bar)' test.txt

Grep standard non può farlo, ma le versioni recenti di GNU grep possono farlo . Puoi passare a sed, awk o perl. Ecco alcuni esempi che fanno quello che vuoi sul tuo input di esempio; si comportano in modo leggermente diverso in casi angolari.

Sostituisci foobar word other stuffcon word, stampa solo se viene effettuata una sostituzione.

sed -n -e 's/^foobar \([[:alnum:]]\+\).*/\1/p'

Se la prima parola è foobar, stampa la seconda parola.

awk '$1 == "foobar" {print $2}'

Rimuovi foobarse è la prima parola e salta la riga altrimenti; quindi rimuovere tutto dopo il primo spazio bianco e stampare.

perl -lne 's/^foobar\s+// or next; s/\s.*//; print'

    sed -n "s/^.*foobar\s*\(\S*\).*$/\1/p"

-n     suppress printing
s      substitute
^.*    anything before foobar
foobar initial search match
\s*    any white space character (space)
\(     start capture group
\S*    capture any non-white space character (word)
\)     end capture group
.*$    anything after the capture group
\1     substitute everything with the 1st capture group
p      print it

Bene, se sai che foobar è sempre la prima parola o la riga, puoi usare cut. Così:

grep "foobar" test.file | cut -d" " -f2

Se PCRE non è supportato, puoi ottenere lo stesso risultato con due invocazioni di grep. Ad esempio per afferrare la parola dopo foobar fare questo:

<test.txt grep -o 'foobar  *[^ ]*' | grep -o '[^ ]*$'

Questo può essere espanso in una parola arbitraria dopo foobar come questo (con ERE per la leggibilità):

i=1
<test.txt egrep -o 'foobar +([^ ]+ +){'$i'}[^ ]+' | grep -o '[^ ]*$'

Produzione:

1

Si noti che l'indice iè a base zero.

pcregrepha -oun'opzione più intelligente che ti consente di scegliere quali gruppi di acquisizione vuoi ottenere. Quindi, usando il tuo file di esempio,

$ pcregrep -o1 "foobar (\w+)" test.txt
bash
happy

L'uso grepnon è compatibile con più piattaforme, poiché -P/ --perl-regexpè disponibile solo su GNUgrep , non su BSDgrep .

Ecco la soluzione usando ripgrep:

$ rg -o "foobar (\w+)" -r '$1' <test.txt
bash
happy

Secondo man rg:

-r/ --replace REPLACEMENT_TEXTSostituisci ogni corrispondenza con il testo indicato.

Gli indici dei gruppi di acquisizione (ad es. $5) E i nomi (ad es. $foo) Sono supportati nella stringa di sostituzione.

^{Correlati: GH-462 .}

Ho trovato molto utile la risposta di @jgshawkey. grepnon è un ottimo strumento per questo, ma sed è, anche se qui abbiamo un esempio che utilizza grep per afferrare una linea pertinente.

La sintassi Regex di sed è idiosincratica se non ci si è abituati.

Ecco un altro esempio: questo analizza l'output di xinput per ottenere un numero intero ID

⎜   ↳ SynPS/2 Synaptics TouchPad                id=19   [slave  pointer  (2)]

e voglio 19

export TouchPadID=$(xinput | grep 'TouchPad' | sed  -n "s/^.*id=\([[:digit:]]\+\).*$/\1/p")

Nota la sintassi della classe:

[[:digit:]]

e la necessità di sfuggire a quanto segue +

Presumo che corrispondano solo a una riga.