O grep pode gerar apenas grupos especificados correspondentes?

Digamos que eu tenho um arquivo:

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

Eu só quero saber quais palavras aparecem depois de "foobar", para que eu possa usar este regex:

"foobar \(\w\+\)"

Os parênteses indicam que tenho um interesse especial pela palavra logo após foobar. Mas quando eu faço a grep "foobar \(\w\+\)" test.txt, recebo as linhas inteiras que correspondem a toda a expressão regular, em vez de apenas "a palavra após foobar":

foobar bash 1
foobar happy

Eu preferiria muito que a saída desse comando fosse assim:

bash
happy

Existe uma maneira de dizer ao grep para emitir apenas os itens que correspondem ao agrupamento (ou a um agrupamento específico) em uma expressão regular?

O GNU grep tem a -Popção de expressões regulares no estilo perl e a -oopção de imprimir apenas o que corresponde ao padrão. Eles podem ser combinados usando asserções de pesquisa (descritas em Padrões estendidos na página de manual do perlre ) para remover parte do padrão grep do que é determinado ter correspondido para os fins de -o.

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

O \Ké o formato abreviado (e mais eficiente) (?<=pattern)que você usa como uma declaração de look-behind de largura zero antes do texto que deseja produzir. (?=pattern)pode ser usado como uma afirmação antecipada de largura zero após o texto que você deseja gerar.

Por exemplo, se você deseja combinar a palavra entre fooe bar, você pode usar:

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

ou (por simetria)

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

O grep padrão não pode fazer isso, mas as versões recentes do GNU grep podem . Você pode mudar para sed, awk ou perl. Aqui estão alguns exemplos que fazem o que você deseja na sua entrada de amostra; eles se comportam de maneira ligeiramente diferente nos cantos.

Substitua foobar word other stuffpor word, imprima apenas se uma substituição for concluída.

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

Se a primeira palavra for foobar, imprima a segunda palavra.

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

Retire foobarse for a primeira palavra e pule a linha caso contrário; depois retire tudo após o primeiro espaço em branco e imprima.

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

Bem, se você souber que foobar é sempre a primeira palavra ou a linha, use cortada. Igual a:

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

Se o PCRE não for suportado, você poderá obter o mesmo resultado com duas invocações do grep. Por exemplo, para pegar a palavra após foobar, faça o seguinte:

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

Isso pode ser expandido para uma palavra arbitrária após foobar como este (com EREs para facilitar a leitura):

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

Resultado:

1

Observe que o índice ié baseado em zero.

pcregreppossui uma -oopção mais inteligente que permite escolher quais grupos de captura você deseja exibir. Então, usando seu arquivo de exemplo,

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

O uso grepnão é compatível com várias plataformas, pois -P/ --perl-regexpestá disponível apenas no GNUgrep , não no BSDgrep .

Aqui está a solução usando ripgrep:

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

Conforme man rg:

-r/ --replace REPLACEMENT_TEXTSubstitua todas as correspondências pelo texto fornecido.

Os índices do grupo de captura (por exemplo, $5) e os nomes (por exemplo $foo) são suportados na sequência de substituição.

^{Palavras-chave : GH-462 .}

Achei a resposta de @jgshawkey muito útil. grepnão é uma ferramenta tão boa para isso, mas sed é, embora aqui tenhamos um exemplo que usa grep para pegar uma linha relevante.

A sintaxe da regex do sed é idiossincrática se você não estiver acostumado.

Aqui está outro exemplo: este analisa a saída do xinput para obter um número inteiro de ID

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

e eu quero 19

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

Observe a sintaxe da classe:

[[:digit:]]

e a necessidade de escapar do seguinte +

Presumo que apenas uma linha corresponda.