grep un file, ma mostra diverse linee circostanti?

Vorrei grepuna stringa, ma mostra anche le cinque righe precedenti e le cinque righe seguenti, nonché la riga corrispondente. Come potrei farlo?

Per BSD o GNU grep puoi usare -B numper impostare quante linee prima della partita e -A numper il numero di linee dopo la partita.

grep -B 3 -A 2 foo README.txt

Se vuoi lo stesso numero di righe prima e dopo puoi usarlo -C num.

grep -C 3 foo README.txt

Questo mostrerà 3 righe prima e 3 righe dopo.

-Ae -Bfunzionerà, come -C n(per le nlinee di contesto), o semplicemente -n(per le nlinee di contesto ... fintanto che n è da 1 a 9).

ack funziona con argomenti simili a grep e accetta -C. Ma di solito è meglio per la ricerca attraverso il codice.

grep astring myfile -A 5 -B 5

Questo farà "myfile" per "astring" e mostrerà 5 righe prima e dopo ogni incontro

Io normalmente uso

grep searchstring file -C n # n for number of lines of context up and down

Molti strumenti come grep hanno anche file man davvero fantastici. Mi trovo a riferirmi molto alla pagina man di grep perché c'è così tanto che puoi farci.

man grep

Molti strumenti GNU hanno anche una pagina informativa che può contenere informazioni più utili oltre alla pagina man.

info grep

Usa grep

$ grep --help | grep -i context
Context control:
  -B, --before-context=NUM  print NUM lines of leading context
  -A, --after-context=NUM   print NUM lines of trailing context
  -C, --context=NUM         print NUM lines of output context
  -NUM                      same as --context=NUM

Cerca "17655" in "/some/file.txt" che mostra il contesto di 10 righe prima e dopo (usando Awk), l'output è preceduto dal numero di riga seguito da due punti. Usalo su Solaris quando 'grep' non supporta le opzioni "- [ACB]".

awk '

/17655/ {
        for (i = (b + 1) % 10; i != b; i = (i + 1) % 10) {
                print before[i]
        }
        print (NR ":" ($0))
        a = 10
}

a-- > 0 {
        print (NR ":" ($0))
}

{
        before[b] = (NR ":" ($0))
        b = (b + 1) % 10
}' /some/file.txt;

ripgrep

Se ti preoccupi delle prestazioni, usa ripgrepuna sintassi simile a grep, ad es

rg -C5 "pattern" .

-C, --context NUM- Mostra NUM righe prima e dopo ogni corrispondenza.

Ci sono anche parametri come -A/ --after-contexte -B/ --before-context.

Lo strumento è basato sul motore regex di Rust che lo rende molto efficiente per i dati di grandi dimensioni.

Ecco la soluzione @Ygor inawk

awk 'c-->0;$0~s{if(b)for(c=b+1;c>1;c--)print r[(NR-c+1)%b];print;c=a}b{r[NR%b]=$0}' b=3 a=3 s="pattern" myfile

^{Nota: Sostituisci ae bvariabili con il numero di righe prima e dopo.}

E 'particolarmente utile per il sistema che non supporta di grep -A, -Be -Cparametri.

$ grep thestring thefile -5

-5ti mette le 5righe sopra e sotto la corrispondenza 'thestring' equivale a -C 5o -A 5 -B 5.

Grep ha un'opzione chiamata Context Line Control, puoi usare --contextquella semplicemente,

| grep -C 5

o

| grep -5

Dovrebbe fare il trucco

Uso per fare in modo compatto

grep -5 string file

Questo è l'equivalente di

grep -A 5 -B 5 string file

Se cerchi spesso il codice, AG cerca argento è molto più efficiente (cioè più veloce) di grep.

Mostra le linee di contesto usando l'opzione -C.

Per esempio:

ag -C 3 "foo" myFile

line 1
line 2
line 3
line that has "foo"
line 5
line 6
line 7