Grep colorato: visualizzazione dell'intero file con le corrispondenze evidenziate

Trovo che grepla --color=alwaysbandiera sia tremendamente utile. Tuttavia, grep stampa solo linee con corrispondenze (a meno che non si richiedano linee di contesto). Dato che ogni riga stampata ha una corrispondenza, l'evidenziazione non aggiunge la massima capacità possibile.

Mi piacerebbe davvero catun file e vedere l'intero file con le corrispondenze dei pattern evidenziate.

C'è un modo in cui posso dire a grep di stampare ogni riga letta indipendentemente dal fatto che ci sia una corrispondenza? So di poter scrivere uno script per eseguire grep su ogni riga di un file, ma ero curioso di sapere se questo era possibile con lo standard grep.

Ecco alcuni modi per farlo:

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

Ecco qualcosa sulla stessa linea. È probabile che utilizzerai meno comunque, quindi prova questo:

less -p pattern file

Evidenzierà il modello e salterà alla prima occorrenza di esso nel file.

Vorrei raccomandare ack - meglio di grep, uno strumento di ricerca di potenza per programmatori .

$ ack --color --passthru --pager = File di pattern "$ {PAGER: -less -R}"

$ ack --color --passthru file di pattern | meno -R

$ export ACK_PAGER_COLOR = "$ {PAGER: -less -R}"
$ ack - passa i file di pattern

Lo adoro perché per impostazione predefinita è la ricerca ricorsiva di directory (e fa molto più intelligente di grep -r), supporta espressioni regolari Perl complete (piuttosto che POSIXish regex(3)) e ha una visualizzazione del contesto molto più piacevole durante la ricerca di molti file.

Puoi usare il mio highlightscript da https://github.com/kepkin/dev-shell-essentials

È meglio che grepperché puoi evidenziare ogni partita con il suo colore .

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

Puoi anche creare un alias. Aggiungi questa funzione nel tuo .bashrc (o .bash_profile su osx)

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

Ora puoi usare l'alias in questo modo: " ifconfig | grepe inet" o " grepe css index.html".

(PS: non dimenticare source ~/.bashrcdi ricaricare Bashrc nella sessione corrente)

Usa il coloutprogramma: http://nojhan.github.io/colout/

È progettato per aggiungere evidenziazioni di colore a un flusso di testo. Dato un regex e un colore (ad esempio "rosso"), riproduce un flusso di testo con le corrispondenze evidenziate. per esempio:

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

È possibile concatenare più invocazioni per aggiungere più luci di colore diverse:

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

Oppure puoi ottenere la stessa cosa usando una regex con N gruppi (parti tra parentesi della regex), seguita da un elenco separato da virgole di N colori.

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

Uso rcg da "Linux Server Hacks", O'Reilly. È perfetto per quello che vuoi e può evidenziare più espressioni ognuna con colori diversi.

#!/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
}

L' -zopzione per grep è anche molto bella!

cat file1 | grep -z "pattern"

Ho aggiunto questo al mio .bash_aliases:

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

Per evidenziare i motivi durante la visualizzazione dell'intero file, h può farlo.

Inoltre utilizza colori diversi per motivi diversi.

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

È inoltre possibile reindirizzare l'output di hto less -Rper una migliore lettura.

Per grep e usare 1 colore per ogni motivo, cxpgrep potrebbe essere una buona scelta.

Ok, questo è un modo,

wc -l filename

ti darà il conteggio delle righe - dì NN, quindi puoi farlo

grep -C NN --color=always filename

Ecco uno script di shell che utilizza la funzione gsub di Awk per sostituire il testo che stai cercando con la sequenza di escape corretta per visualizzarlo in rosso brillante:

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

Usalo così:

$ ./cgrep pattern [file]

Sfortunatamente, non ha tutte le funzionalità di grep.

Per ulteriori informazioni, puoi fare riferimento a un articolo " So You Like Color " nel Linux Journal

Un'altra risposta ha menzionato l'opzione -Cn di grep che include n righe di contesto. A volte lo faccio con n = 99 come un modo rapido e sporco di ottenere [almeno] uno schermo di contesto quando il modello egrep sembra troppo complicato o quando sono su una macchina su cui non ho installato rcg e / o ccze.

Di recente ho scoperto cczequale è un colorante più potente. La mia unica lamentela è che è orientato allo schermo (come less, che non uso mai per quel motivo) a meno che non specifichi l'opzione -A per l'output "ANSI non elaborato".

+1 per la rcgmenzione sopra. È ancora il mio preferito poiché è così semplice da personalizzare in un alias. Qualcosa del genere è di solito nel mio ~ / .bashrc:

alias tailc = 'tail -f / my / app / log / file | rcg invia "BOLD GREEN" riceve "CYAN" errore "RED" '

un altro modo sporco:

grep -A80 -B80 --color FIND_THIS IN_FILE

Ho fatto un

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

a bashrc.

In alternativa puoi usare The Silver Searcher e farlo

ag <search> --passthrough

Se vuoi evidenziare diversi motivi con colori diversi vedi questo script bash.

Utilizzo di base:

echo warn error debug info 10 nil | colog

È possibile modificare motivi e colori mentre si esegue premendo un tasto e quindi il tasto Invio.

Uso il seguente comando per scopi simili:

grep -C 100 searchtext file

Questo dirà grep per stampare 100 * 2 righe di contesto, prima e dopo il testo di ricerca evidenziato.

Ecco il mio approccio , ispirato alla soluzione di @ 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[@]}")
}

Questo accetta più argomenti (ma non consente di personalizzare i colori). Esempio:

$ noisy_command | highlight ERROR WARN

Esiste un modo in cui posso dire a grep di stampare ogni riga letta indipendentemente dal fatto che ci sia una corrispondenza?

Opzione -C999farà il trucco in assenza di un'opzione per visualizzare tutte le linee di contesto. La maggior parte delle altre varianti di grep supportano anche questo. Tuttavia: 1) non viene prodotto alcun output quando non viene trovata alcuna corrispondenza e 2) questa opzione ha un impatto negativo sull'efficienza di grep: quando il -Cvalore è grande, potrebbe essere necessario memorizzare temporaneamente molte righe per consentire a grep di determinare quali linee di contesto per visualizzare quando si verifica una corrispondenza. Si noti che le implementazioni grep non caricano i file di input ma piuttosto leggono alcune righe o utilizzano una finestra scorrevole sull'input. La "parte prima" del contesto deve essere mantenuta in una finestra (memoria) per generare le linee di contesto "prima" in seguito quando viene trovata una corrispondenza.

Un modello come ^|PATTERNo PATTERN|$o qualsiasi sub-pattern di corrispondenza vuota per quella materia come [^ -~]?|PATTERNè un bel trucco. Tuttavia, 1) questi schemi non mostrano linee non corrispondenti evidenziate come contesto e 2) questo non può essere usato in combinazione con alcune altre opzioni grep, come -Fe -wper esempio.

Quindi nessuno di questi approcci mi soddisfa. Sto usando ugrep e grep migliorato con l'opzione -yper visualizzare in modo efficiente tutti gli output non corrispondenti come linee di contesto evidenziate dal colore. Altri strumenti simili a grep come ag e ripgrep offrono anche un'opzione pass-through. Ma ugrep è compatibile con GNU / BSD grep e offre un superset di opzioni grep come -ye -Q. Ad esempio, ecco quale opzione -ymostra quando combinata con -Q(UI di query interattiva per inserire modelli):

ugrep -Q -y FILE ...