Convença o grep a exibir todas as linhas, não apenas as que correspondem

Digamos que tenho o seguinte arquivo:

$ cat test

test line 1
test line 2
line without the search word
another line without it
test line 3 with two test words
test line 4

Por padrão, grepretorna cada linha que contém o termo de pesquisa:

$ grep test test

test line 1
test line 2
test line 3 with two test words
test line 4

Passar o --colorparâmetro para grepfará com que ele destaque a parte da linha que corresponde à expressão de pesquisa, mas ainda retorna apenas as linhas que contêm a expressão. Existe uma maneira de obter greptodas as linhas no arquivo de origem, mas realce as correspondências?

Meu terrível truque atual para fazer isso (pelo menos em arquivos que não têm mais de 10000 linhas consecutivas sem correspondências) é:

$ grep -B 9999 -A 9999 test test

Se grepnão for possível, existe outra ferramenta de linha de comando que ofereça a mesma funcionalidade? Eu brinquei com isso ack, mas também não parece ter uma opção.

grep --color -E "test|$" yourfile

O que estamos fazendo aqui é comparar com o $padrão e o padrão de teste, obviamente $não tem nada para colorir, então apenas o padrão de teste fica colorido. O -Eapenas ativa a correspondência estendida de regex.

Você pode criar uma função facilmente dessa forma:

highlight () { grep --color -E "$1|$" "${@:1}" ; }

ack --passthru --color string file

para Ubuntu e Debian, use ack-grep em vez de ack

ack-grep --passthru --color string file

Outra maneira de fazer isso corretamente e portably com grep(além de usar duas expressões regulares com alternância como na resposta aceita) é via o padrão nulo (e corda respectivamente null).
Ele deve funcionar igualmente bem com os dois -Ee com os -Fswitches, pois, de acordo com o padrão :

-E
    Match using extended regular expressions. 
    [...] A null ERE shall match every line.

e

-F
    Match using fixed strings.
    [...] A null string shall match every line.

Então é simplesmente uma questão de correr

grep -E -e '' -e 'pattern' infile

e respectivamente

grep -F -e '' -e 'string' infile

Eu tenho a seguinte função que eu uso para essas coisas:

highlight () {
    perl -pe "s/$1/\e[1;31;43m$&\e[0m/g"
}

Internamente, parece meio feio, é agradável e fácil de usar, assim:

cat some_file.txt | highlight some_word

ou, para um exemplo um pouco mais real:

tail -f console.log | highlight ERROR

Você pode alterar as cores para o que quiser (o que pode ser difícil com o grep - não tenho certeza) alterando o 1e 31e 43(depois \e[) para valores diferentes. Os códigos a serem usados ​​estão por todo o lado , mas aqui está uma introdução rápida: o 1 coloca o texto em negrito, o 31torna vermelho e o 43amarelo fornece um fundo amarelo. 32ou 33seriam cores diferentes e 44ou 45seriam fundos diferentes: você entendeu a idéia. Você pode até fazê-lo piscar (com a 5) se quiser.

Isso não usa módulos Perl especiais, e o Perl é quase onipresente, portanto, espero que funcione em qualquer lugar. A solução grep é muito inteligente, mas a opção --color no grep não está disponível em todos os lugares. Por exemplo, eu apenas tentei esta solução em uma caixa Solaris executando o bash e outro executando o ksh, e minha máquina local do Mac OS X executando o zsh. Tudo funcionou muito bem. Solaris engasgou com a grep --colorsolução, no entanto.

Além disso, o ack é incrível, e eu o recomendo para quem ainda não o descobriu, mas tive alguns problemas ao instalá-lo em alguns dos muitos servidores em que trabalho. (Eu esqueço o porquê: acho que relacionado aos módulos Perl necessários).

Como acho que nunca trabalhei em uma caixa Unix que não tinha o Perl instalado (com exceção de sistemas do tipo incorporado, roteadores Linksys e outros), eu diria que essa é uma solução praticamente universal. .

Em vez de usar o Grep, você pode usar Menos:

less file

Pesquisar assim: /pattern Enter

Isso vai:

1. role até a primeira linha correspondente
2. produzir todas as linhas a partir daí
3. destacar todas as correspondências

Para rolar para a próxima linha correspondente: n

Para rolar para a linha correspondente anterior: N

Para alternar o destaque: Esc u

Além disso, você pode alterar a cor de destaque, se quiser.

Podes tentar:

perl -MTERM::ANSIColor -nle '/pattern/ ? print colored($_, 'color') : print' test

No entanto, não é muito portátil e, mesmo que o Perl esteja instalado, você pode precisar fazer o download de outro módulo. Além disso, colorirá a linha inteira, não apenas a palavra de pesquisa.

ripgrep

Use ripgrepcom seu --passthruparâmetro:

rg --passthru pattern file.txt

É uma das ferramentas de grepping mais rápidas , pois é construída sobre o mecanismo de expressão regular da Rust, que usa autômatos finitos, SIMD e otimizações literais agressivas para tornar a pesquisa muito rápida.

--passthru - Imprima linhas correspondentes e não correspondentes.

Outra maneira de obter um efeito semelhante é modificando seu padrão para corresponder à sequência vazia. Por exemplo, se você estiver pesquisando usando rg foo, o uso rg "^|foo"será emitido em todas as linhas de todos os arquivos pesquisados, mas apenas as ocorrências de foo serão destacadas. Esse sinalizador permite o mesmo comportamento sem precisar modificar o padrão.

Existe uma maneira muito mais fácil de fazer isso no GNU grep, mas não acho que seja portátil (ou seja, BSD grep):

Em um tubo:

cat <file> | grep --color=always -z <query>

Em um arquivo:

grep --color=always -z <query> <file>

O crédito vai para a resposta de Cyrus aqui .

Nenhuma das respostas dadas até o momento fornece uma solução portátil .

Aqui é um portátil ¹ função shell que eu já postado em um fechado como questão duplicado que não necessita de ferramentas padrão não ou extensões não padrão fornecidos com perl, ack, ggrep, gsed, bashe os gostos, mas só precisa de um shell POSIX e os utilitários obrigatórios POSIX sede printf:

grepc()
{
  pattern=$1
  shift
  esc=$(printf "\033")
  sed 's"'"$pattern"'"'$esc'[32m&'$esc'[0m"g' "$@"
}

Você pode usá-lo dessa maneira:

grepc string_to_search [file ...]

A cor do destaque pode ser ajustada usando um destes códigos no argumento sed command (32m sendo verde aqui):

30m black
31m red
33m yellow
34m blue
35m magenta
36m cyan
37m white
7m reverse video

¹ Desde que o seu terminal suporte sequências de escape de cores ANSI.

Uma sedversão, funciona em ambos bashe ash.

#highlight
hsed(){
    local pattern="$1"
    shift
    local r=`echo -e '\e'[31m`
    local c=`echo -e '\e'[0m`
    sed "s:${pattern//:/\:}:$r\0$c:g" "$@"
}

O OP pediu grep, e é isso que RECOMENDO ; mas depois de tentar resolver um problema com sed, para constar, aqui está uma solução simples:

sed $'s/main/\E[31m&\E[0m/g' testt.c

ou

cat testt.c | sed $'s/main/\E[31m&\E[0m/g'

Pintará mainem vermelho.

• \E[31m : sequência de início de cor vermelha
• \E[0m : marca de cor finalizada
• & : o padrão correspondente
• /g : todas as palavras em uma linha, não apenas a primeira
• $'string' é bash strings com caracteres de escape interpretados

Em relação ao grep , ele também funciona usando ^(início de linha) em vez de $(fim de linha). Exemplo:

egrep "^|main" testt.c

E só para mostrar esse pseudônimo louco que NÃO RECOMENDO , você pode até deixar as aspas abertas:

alias h='egrep -e"^|'
h main" testt.c
cat testt.c | h main"

todo o trabalho! :) Não se preocupe se você esquecer de fechar a cotação, o bash lembrará de você com um "caractere de linha contínua".