Grep colorisé - affichage de l'intégralité du fichier avec les correspondances en surbrillance

Je trouve que greple --color=alwaysdrapeau de 'est extrêmement utile. Cependant, grep imprime uniquement les lignes avec des correspondances (sauf si vous demandez des lignes de contexte). Étant donné que chaque ligne imprimée a une correspondance, la mise en évidence n'ajoute pas autant de fonctionnalités qu'elle le pourrait.

J'aimerais vraiment catun fichier et voir le fichier entier avec les correspondances de motifs en surbrillance.

Existe-t-il un moyen de dire à grep d'imprimer chaque ligne en cours de lecture, qu'il y ait ou non une correspondance? Je sais que je pourrais écrire un script pour exécuter grep sur chaque ligne d'un fichier, mais j'étais curieux de savoir si cela était possible avec la norme grep.

Voici quelques façons de procéder:

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

Voici quelque chose dans le même sens. Il y a de fortes chances que vous utilisiez moins de toute façon, alors essayez ceci:

less -p pattern file

Il mettra en surbrillance le motif et passera à la première occurrence de celui-ci dans le fichier.

J'aimerais recommander ack - mieux que grep, un outil de recherche de puissance pour les programmeurs .

$ ack --color --passthru --pager = "$ {PAGER: -less -R}" fichiers de motif

$ ack --color --fassthru pattern files | moins -R

$ export ACK_PAGER_COLOR = "$ {PAGER: -less -R}"
$ ack - fichiers de motifs passthru

Je l'adore car il utilise par défaut la recherche récursive de répertoires (et est beaucoup plus intelligent que grep -r), prend en charge les expressions régulières Perl complètes (plutôt que POSIXish regex(3)) et a un affichage de contexte beaucoup plus agréable lors de la recherche de nombreux fichiers.

Vous pouvez utiliser mon highlightscript sur https://github.com/kepkin/dev-shell-essentials

C'est mieux que grepparce que vous pouvez mettre en évidence chaque match avec sa propre couleur .

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

Vous pouvez également créer un alias. Ajoutez cette fonction dans votre .bashrc (ou .bash_profile sur osx)

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

Vous pouvez maintenant utiliser l'alias comme ceci: " ifconfig | grepe inet" ou " grepe css index.html".

(PS: n'oubliez pas source ~/.bashrcde recharger bashrc sur la session en cours)

Utilisez le coloutprogramme: http://nojhan.github.io/colout/

Il est conçu pour ajouter des reflets de couleur à un flux de texte. Étant donné une expression régulière et une couleur (par exemple "rouge"), il reproduit un flux de texte avec des correspondances mises en évidence. par exemple:

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

Vous pouvez chaîner plusieurs invocations pour ajouter plusieurs surbrillances de couleurs différentes:

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 vous pouvez obtenir la même chose en utilisant une expression régulière avec N groupes (parties entre parenthèses de l'expression régulière), suivie d'une liste séparée par des virgules de N couleurs.

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

J'utilise rcg de "Linux Server Hacks", O'Reilly. Il est parfait pour ce que vous voulez et peut mettre en évidence plusieurs expressions chacune avec des couleurs différentes.

#!/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' -zoption pour grep est également assez lisse!

cat file1 | grep -z "pattern"

J'ai ajouté ceci à mes .bash_aliases:

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

Pour mettre en surbrillance des motifs lors de la visualisation de l'ensemble du fichier, h peut le faire.

De plus, il utilise différentes couleurs pour différents motifs.

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

Vous pouvez également diriger la sortie de hvers less -Rpour une meilleure lecture.

Pour grep et utiliser 1 couleur pour chaque motif, cxpgrep pourrait être un bon ajustement.

Ok, c'est une façon,

wc -l filename

vous donnera le nombre de lignes - dites NN, alors vous pouvez faire

grep -C NN --color=always filename

Voici un script shell qui utilise la fonction gsub d'Awk pour remplacer le texte que vous recherchez par la séquence d'échappement appropriée pour l'afficher en rouge vif:

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

Utilisez-le comme ceci:

$ ./cgrep pattern [file]

Malheureusement, il n'a pas toutes les fonctionnalités de grep.

Pour plus d'informations, vous pouvez vous référer à un article " So You Like Color " dans Linux Journal

Une autre réponse mentionne le commutateur -Cn de grep qui comprend n lignes de contexte. Je fais parfois cela avec n = 99 comme un moyen rapide et sale d'obtenir [au moins] un écran plein de contexte lorsque le modèle egrep semble trop compliqué, ou lorsque je suis sur une machine sur laquelle je n'ai pas installé rcg et / ou ccze.

J'ai récemment découvert cczequi est un colorant plus puissant. Mon seul reproche, c'est qu'il est orienté écran (comme less, que je n'utilise jamais pour cette raison), sauf si vous spécifiez le commutateur -A pour la sortie "raw ANSI".

+1 pour la rcgmention ci-dessus. C'est toujours mon préféré car il est si simple à personnaliser dans un alias. Quelque chose comme ça se trouve généralement dans mon ~ / .bashrc:

alias tailc = 'tail -f / my / app / log / file | rcg envoyer "BOLD GREEN" recevoir "CYAN" error "RED" '

une autre façon sale:

grep -A80 -B80 --color FIND_THIS IN_FILE

J'ai fait un

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

à bashrc.

Vous pouvez également utiliser The Silver Searcher et faire

ag <search> --passthrough

Si vous souhaitez mettre en évidence plusieurs motifs avec des couleurs différentes, voyez ceci script bash.

Utilisation de base:

echo warn error debug info 10 nil | colog

Vous pouvez modifier les motifs et les couleurs tout en exécutant en appuyant sur une touche, puis sur la touche Entrée.

J'utilise la commande suivante à des fins similaires:

grep -C 100 searchtext file

Cela indiquera grep pour imprimer 100 * 2 lignes de contexte, avant et après le texte de recherche en surbrillance.

Voici mon approche , inspirée de la solution 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[@]}")
}

Cela accepte plusieurs arguments (mais ne vous permet pas de personnaliser les couleurs). Exemple:

$ noisy_command | highlight ERROR WARN

Existe-t-il un moyen de dire à grep d'imprimer chaque ligne en cours de lecture, qu'il y ait ou non une correspondance?

L'option -C999fera l'affaire en l'absence d'une option pour afficher toutes les lignes de contexte. La plupart des autres variantes de grep le supportent également. Cependant: 1) aucune sortie n'est produite lorsqu'aucune correspondance n'est trouvée et 2) cette option a un impact négatif sur l'efficacité de grep: lorsque la -Cvaleur est grande, de nombreuses lignes peuvent devoir être temporairement stockées en mémoire pour grep afin de déterminer quelles lignes de contexte à afficher lorsqu'une correspondance se produit. Notez que les implémentations grep ne chargent pas les fichiers d'entrée mais lisent plutôt quelques lignes ou utilisent une fenêtre glissante sur l'entrée. La "partie avant" du contexte doit être conservée dans une fenêtre (mémoire) pour sortir les lignes de contexte "avant" plus tard lorsqu'une correspondance est trouvée.

Un motif tel que ^|PATTERNou PATTERN|$ou n'importe quel sous-motif de correspondance vide pour cette question comme [^ -~]?|PATTERNest une bonne astuce. Cependant, 1) ces modèles ne montrent pas de lignes non correspondantes mises en évidence comme contexte et 2) cela ne peut pas être utilisé en combinaison avec d'autres options grep, telles que -Fet -wpar exemple.

Donc, aucune de ces approches ne me satisfait. J'utilise ugrep et grep amélioré avec option -ypour afficher efficacement toutes les sorties non correspondantes sous forme de lignes de contexte surlignées en couleur. D'autres outils de type grep tels que ag et ripgrep offrent également une option d'intercommunication. Mais ugrep est compatible avec GNU / BSD grep et offre un sur-ensemble d'options grep comme -yet -Q. Par exemple, voici ce que l'option -yaffiche lorsqu'elle est combinée avec -Q(interface utilisateur de requête interactive pour saisir des modèles):

ugrep -Q -y FILE ...