Grep coloreado: ver el archivo completo con coincidencias resaltadas

Encuentro que grepla --color=alwaysbandera es tremendamente útil. Sin embargo, grep solo imprime líneas con coincidencias (a menos que solicite líneas de contexto). Dado que cada línea que imprime tiene una coincidencia, el resaltado no agrega tanta capacidad como podría.

Realmente me gustaría catun archivo y ver todo el archivo con las coincidencias de patrón resaltadas.

¿Hay alguna manera de decirle a grep que imprima cada línea que se lee independientemente de si hay una coincidencia? Sé que podría escribir un script para ejecutar grep en cada línea de un archivo, pero tenía curiosidad por saber si esto era posible con el estándar grep.

Aquí hay algunas formas de hacerlo:

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

Aquí hay algo en la misma línea. Lo más probable es que use menos de todos modos, así que intente esto:

less -p pattern file

Destacará el patrón y saltará a la primera aparición del mismo en el archivo.

Me gustaría recomendar ack, mejor que grep, una herramienta de búsqueda poderosa para programadores .

$ ack --color --passthru --pager = "$ {PAGER: -less -R}" archivos de patrones

$ ack --color --passthru archivos de patrones | menos -R

$ export ACK_PAGER_COLOR = "$ {PAGER: -less -R}"
$ ack --passthru archivos de patrones

Me encanta porque el valor predeterminado es la búsqueda recursiva de directorios (y es mucho más inteligente que grep -r), admite expresiones regulares completas de Perl (en lugar de POSIXish regex(3)) y tiene una visualización de contexto mucho más agradable al buscar muchos archivos.

Puedes usar mi highlightscript desde https://github.com/kepkin/dev-shell-essentials

Es mejor que grepporque puedas resaltar cada partido con su propio color .

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

También puedes crear un alias. Agregue esta función en su .bashrc (o .bash_profile en osx)

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

Ahora puede usar el alias de esta manera: " ifconfig | grepe inet" o " grepe css index.html".

(PD: no olvides source ~/.bashrcvolver a cargar bashrc en la sesión actual)

Utilice el coloutprograma: http://nojhan.github.io/colout/

Está diseñado para agregar resaltados de color a una secuencia de texto. Dado una expresión regular y un color (por ejemplo, "rojo"), reproduce una secuencia de texto con coincidencias resaltadas. p.ej:

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

Puede encadenar varias invocaciones para agregar múltiples resaltados de colores 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

O puede lograr lo mismo utilizando una expresión regular con N grupos (partes entre paréntesis de la expresión regular), seguida de una lista de N colores separados por comas.

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

Yo uso rcg de "Linux Server Hacks", O'Reilly. Es perfecto para lo que desea y puede resaltar múltiples expresiones, cada una con diferentes colores.

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

¡La -zopción para grep también es bastante hábil!

cat file1 | grep -z "pattern"

Agregué esto a mis .bash_aliases:

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

Para resaltar patrones mientras ve el archivo completo, h puede hacer esto.

Además, utiliza diferentes colores para diferentes patrones.

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

También puede canalizar la salida de ha less -Rpara una mejor lectura.

Para grep y usar 1 color para cada patrón, cxpgrep podría ser una buena opción .

Ok, esta es una forma

wc -l filename

le dará el recuento de líneas - diga NN, luego puede hacer

grep -C NN --color=always filename

Aquí hay un script de shell que utiliza la función gsub de Awk para reemplazar el texto que está buscando con la secuencia de escape adecuada para mostrarlo en rojo brillante:

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

Úselo así:

$ ./cgrep pattern [file]

Desafortunadamente, no tiene toda la funcionalidad de grep.

Para obtener más información, puede consultar un artículo " So You Like Color " en Linux Journal

Otra respuesta mencionó el interruptor grep's -Cn que incluye n líneas de contexto. A veces hago esto con n = 99 como una forma rápida y sucia de obtener [al menos] una pantalla llena de contexto cuando el patrón egrep parece demasiado complicado, o cuando estoy en una máquina en la que no he instalado rcg y / o ccze.

Recientemente descubrí cczecuál es un colorante más potente. Mi única queja es que está orientado a la pantalla (como less, que nunca uso por ese motivo) a menos que especifique el interruptor -A para la salida "ANSI sin procesar".

+1 por la rcgmención anterior. Sigue siendo mi favorito, ya que es muy sencillo de personalizar en un alias. Algo así suele estar en mi ~ / .bashrc:

alias tailc = 'tail -f / my / app / log / file | rcg envía "VERDE NEGRO" recibe el error "CIAN" "ROJO"

Otra forma sucia:

grep -A80 -B80 --color FIND_THIS IN_FILE

Hice un

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

en bashrc.

Alternativamente, puede usar The Silver Searcher y hacer

ag <search> --passthrough

Si desea resaltar varios patrones con diferentes colores, vea este script bash.

Uso básico:

echo warn error debug info 10 nil | colog

Puede cambiar patrones y colores mientras se ejecuta presionando una tecla y luego ingresar la tecla.

Yo uso el siguiente comando para un propósito similar:

grep -C 100 searchtext file

Esto dirá grep para imprimir 100 * 2 líneas de contexto, antes y después del texto de búsqueda resaltado.

Aquí está mi enfoque , inspirado en la solución de @ 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[@]}")
}

Esto acepta múltiples argumentos (pero no le permite personalizar los colores). Ejemplo:

$ noisy_command | highlight ERROR WARN

¿Hay alguna manera de decirle a grep que imprima cada línea que se lee independientemente de si hay una coincidencia?

La opción -C999hará el truco en ausencia de una opción para mostrar todas las líneas de contexto. La mayoría de las otras variantes de grep también admiten esto. Sin embargo: 1) no se produce salida cuando no se encuentra ninguna coincidencia y 2) esta opción tiene un impacto negativo en la eficiencia de grep: cuando el -Cvalor es grande, es posible que muchas líneas deban almacenarse temporalmente en la memoria para que grep determine qué líneas de contexto para mostrar cuando se produce una coincidencia. Tenga en cuenta que las implementaciones de grep no cargan archivos de entrada, sino que leen algunas líneas o usan una ventana deslizante sobre la entrada. La "parte anterior" del contexto debe mantenerse en una ventana (memoria) para generar las líneas de contexto "anterior" más adelante cuando se encuentra una coincidencia.

Un patrón como ^|PATTERNo PATTERN|$cualquier subpatrón de coincidencia vacía para ese asunto [^ -~]?|PATTERNes un buen truco. Sin embargo, 1) estos patrones no muestran líneas no coincidentes resaltadas como contexto y 2) esto no se puede usar en combinación con algunas otras opciones grep, como -Fy -wpor ejemplo.

Así que ninguno de estos enfoques me satisface. Estoy usando ugrep y grep mejorado con la opción -yde mostrar de manera eficiente todos los resultados no coincidentes como líneas de contexto resaltadas en color. Otras herramientas similares a grep como ag y ripgrep también ofrecen una opción de transferencia. Pero ugrep es compatible con GNU / BSD grep y ofrece un superconjunto de opciones grep como -yy -Q. Por ejemplo, esto es lo que -ymuestra la opción cuando se combina con -Q(interfaz de usuario de consulta interactiva para ingresar patrones):

ugrep -Q -y FILE ...