Grep colorido - visualizando o arquivo inteiro com correspondências destacadas

Acho grepa --color=alwaysbandeira de ser tremendamente útil. No entanto, o grep imprime apenas linhas com correspondências (a menos que você solicite linhas de contexto). Dado que cada linha impressa tem uma correspondência, o realce não adiciona a maior capacidade possível.

Eu realmente gostaria de catum arquivo e ver o arquivo inteiro com as correspondências de padrões destacadas.

Existe alguma maneira de dizer ao grep para imprimir todas as linhas que estão sendo lidas, independentemente de haver uma correspondência? Eu sei que poderia escrever um script para executar o grep em todas as linhas de um arquivo, mas fiquei curioso para saber se isso era possível com o padrão grep.

Aqui estão algumas maneiras de fazer isso:

grep --color -E 'pattern|$' file
grep --color 'pattern\|$' file
egrep --color 'pattern|$' file

Aqui está algo na mesma linha. As chances são de que você usará menos de qualquer maneira, então tente o seguinte:

less -p pattern file

Ele destacará o padrão e pulará para a primeira ocorrência dele no arquivo.

Eu gostaria de recomendar o ack - melhor que o grep, uma ferramenta de busca avançada para programadores .

$ ack --color --passthru --pager = "$ {PAGER: -less -R}" arquivos padrão

$ ack --color --passthru arquivos padrão | menos -R

$ export ACK_PAGER_COLOR = "$ {PAGER: -less -R}"
Arquivos de padrão $ ack --passthru

Eu amo isso porque o padrão é a pesquisa recursiva de diretórios (e é muito mais inteligente do que grep -r), suporta expressões regulares completas do Perl (em vez do POSIXish regex(3)) e possui uma exibição de contexto muito mais agradável ao pesquisar muitos arquivos.

Você pode usar meu highlightscript em https://github.com/kepkin/dev-shell-essentials

É melhor do que grepporque você pode destacar cada partida com sua própria cor .

$ command_here | highlight green "input" | highlight red "output"

Você também pode criar um alias. Adicione esta função ao seu .bashrc (ou .bash_profile no osx)

function grepe {
    grep --color -E "$1|$" $2
}

Agora você pode usar o alias assim: " ifconfig | grepe inet" ou " grepe css index.html".

(PS: não esqueça source ~/.bashrcde recarregar o bashrc na sessão atual)

Use o coloutprograma: http://nojhan.github.io/colout/

Ele foi projetado para adicionar realces de cores a um fluxo de texto. Dada uma expressão regular e uma cor (por exemplo, "vermelho"), ele reproduz um fluxo de texto com as correspondências destacadas. por exemplo:

# cat logfile but highlight instances of 'ERROR' in red
colout ERROR red <logfile

Você pode encadear várias invocações para adicionar vários destaques de cores diferentes:

tail -f /var/log/nginx/access.log | \
    colout ' 5\d\d ' red | \
    colout ' 4\d\d ' yellow | \
    colout ' 3\d\d ' cyan | \
    colout ' 2\d\d ' green

Ou você pode conseguir o mesmo usando uma regex com N grupos (partes entre parênteses da regex), seguida por uma lista separada por vírgula de N cores.

vagrant status | \
    colout \
        '\''(^.+  running)|(^.+suspended)|(^.+not running)'\'' \
        green,yellow,red

Eu uso o rcg do "Linux Server Hacks", O'Reilly. É perfeito para o que você deseja e pode destacar várias expressões, cada uma com cores diferentes.

#!/usr/bin/perl -w
#
#       regexp coloured glasses - from Linux Server Hacks from O'Reilly
#
#       eg .rcg "fatal" "BOLD . YELLOW . ON_WHITE"  /var/adm/messages
#
use strict;
use Term::ANSIColor qw(:constants);

my %target = ( );

while (my $arg = shift) {
        my $clr = shift;

        if (($arg =~ /^-/) | !$clr) {
                print "Usage: rcg [regex] [color] [regex] [color] ...\n";
                exit(2);
        }

        #
        # Ugly, lazy, pathetic hack here. [Unquote]
        #
        $target{$arg} = eval($clr);

}

my $rst = RESET;

while(<>) {
        foreach my $x (keys(%target)) {
                s/($x)/$target{$x}$1$rst/g;
        }
        print
}

A -zopção para grep também é muito boa!

cat file1 | grep -z "pattern"

Adicionei isso ao meu .bash_aliases:

highlight() {
  grep --color -E "$1|\$"
}

Para destacar padrões enquanto visualiza o arquivo inteiro, h pode fazer isso.

Além disso, ele usa cores diferentes para diferentes padrões.

cat FILE | h 'PAT1' 'PAT2' ...

Você também pode canalizar a saída de hpara less -Rpara uma melhor leitura.

Para grep e usar 1 cor para cada padrão, o cxpgrep pode ser um bom ajuste.

Ok, este é um caminho,

wc -l filename

lhe dará a contagem de linhas - diga NN, então você pode fazer

grep -C NN --color=always filename

Aqui está um script de shell que usa a função gsub do Awk para substituir o texto que você está procurando pela seqüência de escape adequada para exibi-lo em vermelho brilhante:

#! /bin/bash
awk -vstr=$1 'BEGIN{repltext=sprintf("%c[1;31;40m&%c[0m", 0x1B,0x1B);}{gsub(str,repltext); print}' $2

Use-o assim:

$ ./cgrep pattern [file]

Infelizmente, ele não tem toda a funcionalidade do grep.

Para obter mais informações, consulte o artigo " So You Like Color " no Linux Journal.

Uma outra resposta mencionou a opção -Cn do grep, que inclui n linhas de contexto. Às vezes, faço isso com n = 99 como uma maneira rápida e suja de obter [pelo menos] uma tela cheia de contexto quando o padrão egrep parece muito complicado ou quando estou em uma máquina na qual não instalei o rcg e / ou ccze.

Eu descobri recentemente cczeque é um colorizador mais poderoso. Minha única reclamação é que ela é orientada à tela (tipo less, que eu nunca uso por esse motivo), a menos que você especifique a opção -A para a saída "bruto ANSI".

+1 para a rcgmenção acima. Ainda é o meu favorito, pois é muito simples de personalizar em um pseudônimo. Algo como isso geralmente está no meu ~ / .bashrc:

alias tailc = 'tail -f / meu / app / log / arquivo | rcg envia "BOLD GREEN" recebe o erro "CYAN" "RED" '

outra maneira suja:

grep -A80 -B80 --color FIND_THIS IN_FILE

Eu fiz um

alias grepa='grep -A80 -B80 --color'

no bashrc.

Como alternativa, você pode usar o Silver Searcher e fazer

ag <search> --passthrough

Se você deseja destacar vários padrões com cores diferentes, consulte este script bash.

Uso básico:

echo warn error debug info 10 nil | colog

Você pode alterar padrões e cores enquanto estiver executando, pressionando uma tecla e depois a tecla Enter.

Eu uso o seguinte comando para fins semelhantes:

grep -C 100 searchtext file

Isso indica grep para imprimir 100 * 2 linhas de contexto, antes e depois do texto de pesquisa destacado.

Aqui está minha abordagem , inspirada na solução do @ kepkin:

# Adds ANSI colors to matched terms, similar to grep --color but without
# filtering unmatched lines. Example:
#   noisy_command | highlight ERROR INFO
#
# Each argument is passed into sed as a matching pattern and matches are
# colored. Multiple arguments will use separate colors.
#
# Inspired by https://stackoverflow.com/a/25357856
highlight() {
  # color cycles from 0-5, (shifted 31-36), i.e. r,g,y,b,m,c
  local color=0 patterns=()
  for term in "$@"; do
    patterns+=("$(printf 's|%s|\e[%sm\\0\e[0m|g' "${term//|/\\|}" "$(( color+31 ))")")
    color=$(( (color+1) % 6 ))
  done
  sed -f <(printf '%s\n' "${patterns[@]}")
}

Isso aceita vários argumentos (mas não permite que você personalize as cores). Exemplo:

$ noisy_command | highlight ERROR WARN

Existe alguma maneira de dizer ao grep para imprimir todas as linhas que estão sendo lidas, independentemente de haver uma correspondência?

Option -C999fará o truque na ausência de uma opção para exibir todas as linhas de contexto. A maioria das outras variantes do grep também suporta isso. Entretanto: 1) nenhuma saída é produzida quando nenhuma correspondência é encontrada e 2) essa opção tem um impacto negativo na eficiência do grep: quando o-C valor é grande, muitas linhas podem precisar ser temporariamente armazenadas na memória do grep para determinar quais linhas de contexto para exibir quando ocorrer uma correspondência. Observe que as implementações grep não carregam arquivos de entrada, mas lê algumas linhas ou usam uma janela deslizante sobre a entrada. A "parte anterior" do contexto deve ser mantida em uma janela (memória) para gerar as linhas de contexto "anterior" mais tarde, quando uma correspondência for encontrada.

Um padrão como ^|PATTERNou PATTERN|$ou qualquer sub-padrão de correspondência vazia, por exemplo, [^ -~]?|PATTERNé um bom truque. No entanto, 1) esses padrões não mostram linhas não correspondentes destacadas como contexto e 2) isso não pode ser usado em combinação com outras opções de grep, como -Fe -wpor exemplo.

Portanto, nenhuma dessas abordagens me satisfaz. Estou usando o ugrep e o grep aprimorado com a opção -yde exibir com eficiência todas as saídas não correspondentes como linhas de contexto destacadas em cores. Outras ferramentas do tipo grep, como ag e ripgrep, também oferecem uma opção de passagem. Mas o ugrep é compatível com o GNU / BSD grep e oferece um superconjunto de opções de grep como -ye -Q. Por exemplo, eis a opção -ymostrada quando combinada com -Q(UI de consulta interativa para inserir padrões):

ugrep -Q -y FILE ...