Abbina due stringhe in una riga con grep

Sto cercando di utilizzare grepper abbinare le linee che contengono due stringhe diverse. Ho provato quanto segue ma questo corrisponde a righe che contengono sia string1 o string2 che non è quello che voglio.

grep 'string1\|string2' filename

Quindi, come posso abbinare grepsolo le linee che contengono entrambe le stringhe ?

Puoi usare grep 'string1' filename | grep 'string2'

O, grep 'string1.*string2\|string2.*string1' filename

Penso che questo sia quello che stavi cercando:

grep -E "string1|string2" filename

Penso che le risposte in questo modo:

grep 'string1.*string2\|string2.*string1' filename

corrisponde solo al caso in cui entrambi sono presenti, non l'uno o l'altro o entrambi.

Per cercare file contenenti tutte le parole in qualsiasi ordine e ovunque:

grep -ril \'action\' | xargs grep -il \'model\' | xargs grep -il \'view_type\'

Il primo grep dà il via a una ricerca ricorsiva ( r), ignorando case ( i) e elencando (stampando) il nome dei file che corrispondono ( l) per un termine ( 'action'con le virgolette singole) che si verificano in qualsiasi punto del file.

I greps successivi cercano gli altri termini, mantenendo l'insensibilità del caso e elencando i file corrispondenti.

L'elenco finale dei file che otterrai saranno quelli che contengono questi termini, in qualsiasi ordine in qualsiasi parte del file.

Se hai un grepcon -Pun'opzione per un perlregex limitato , puoi usare

grep -P '(?=.*string1)(?=.*string2)'

che ha il vantaggio di lavorare con stringhe sovrapposte. È un po 'più semplice usare perlas grep, perché puoi specificare la logica e più direttamente:

perl -ne 'print if /string1/ && /string2/'

Il tuo metodo era quasi buono, mancava solo il -w

grep -w 'string1\|string2' filename

L' |operatore in un'espressione regolare significa o. Vale a dire che stringa1 o stringa2 corrisponderanno. Potresti fare:

grep 'string1' filename | grep 'string2'

che invierà i risultati dal primo comando al secondo grep. Questo dovrebbe darti solo linee che corrispondono ad entrambi.

Potresti provare qualcosa del genere:

(pattern1.*pattern2|pattern2.*pattern1)

E come le persone hanno suggerito perl e python e script di shell contorti, ecco un semplice approccio awk :

awk '/string1/ && /string2/' filename

Dopo aver guardato i commenti alla risposta accettata: no, questo non fa multilinea; ma poi non è nemmeno quello che l'autore della domanda ha chiesto.

Non provare a usare grep per questo, usa invece awk. Per abbinare 2 regexps R1 e R2 in grep penseresti che sarebbe:

grep 'R1.*R2|R2.*R1'

mentre in awk sarebbe:

awk '/R1/ && /R2/'

ma cosa succede se si R2sovrappone o è un sottoinsieme di R1? Quel comando grep semplicemente non avrebbe funzionato mentre il comando awk avrebbe funzionato. Diciamo che vuoi trovare linee che contengono thee heat:

$ echo 'theatre' | grep 'the.*heat|heat.*the'
$ echo 'theatre' | awk '/the/ && /heat/'
theatre

Dovresti usare 2 greps e una pipe per quello:

$ echo 'theatre' | grep 'the' | grep 'heat'
theatre

e ovviamente se avevi richiesto loro di essere separati, puoi sempre scrivere in awk lo stesso regexp usato in grep e ci sono soluzioni awk alternative che non implicano la ripetizione dei regexps in ogni possibile sequenza.

Mettendolo da parte, cosa succede se si desidera estendere la soluzione per abbinare 3 regexps R1, R2 e R3. In grep sarebbe una di queste povere scelte:

grep 'R1.*R2.*R3|R1.*R3.*R2|R2.*R1.*R3|R2.*R3.*R1|R3.*R1.*R2|R3.*R2.*R1' file
grep R1 file | grep R2 | grep R3

mentre in awk sarebbe il conciso, ovvio, semplice, efficiente:

awk '/R1/ && /R2/ && /R3/'

Ora, cosa succederebbe se davvero volessi abbinare le stringhe letterali S1 e S2 invece di regexps R1 e R2? Semplicemente non puoi farlo in una chiamata a grep, devi scrivere il codice per sfuggire a tutti i metachar RE prima di chiamare grep:

S1=$(sed 's/[^^]/[&]/g; s/\^/\\^/g' <<< 'R1')
S2=$(sed 's/[^^]/[&]/g; s/\^/\\^/g' <<< 'R2')
grep 'S1.*S2|S2.*S1'

o ancora usa 2 greps e una pipa:

grep -F 'S1' file | grep -F 'S2'

che di nuovo sono scelte sbagliate mentre con awk usi semplicemente un operatore stringa invece dell'operatore regexp:

awk 'index($0,S1) && index($0.S2)'

E se volessi abbinare 2 regexps in un paragrafo anziché in una riga? Non può essere fatto in grep, banale in awk:

awk -v RS='' '/R1/ && /R2/'

Che ne dici di un intero file? Di nuovo non può essere fatto in grep e banale in awk (questa volta sto usando GNU awk per RS ​​multi-char per concisione, ma non c'è molto più codice in qualsiasi awk o puoi scegliere un control-char che sai che non lo farà essere nell'input affinché RS faccia lo stesso):

awk -v RS='^$' '/R1/ && /R2/'

Quindi - se vuoi trovare più regexps o stringhe in una riga, in un paragrafo o in un file, non usare grep, usa awk.

grep ‘string1\|string2’ FILENAME 

GNU grep versione 3.1

Linee trovate che iniziano solo con 6 spazi e finiscono con:

 cat my_file.txt | grep
 -e '^      .*(\.c$|\.cpp$|\.h$|\.log$|\.out$)' # .c or .cpp or .h or .log or .out
 -e '^      .*[0-9]\{5,9\}$' # numers between 5 and 9 digist
 > nolog.txt

Diciamo che dobbiamo trovare il conteggio di più parole in un file testfile. Ci sono due modi per farlo

1) Utilizzare il comando grep con il modello di corrispondenza regex

grep -c '\<\(DOG\|CAT\)\>' testfile

2) Utilizzare il comando egrep

egrep -c 'DOG|CAT' testfile 

Con egrep non devi preoccuparti dell'espressione e semplicemente separare le parole da un separatore di tubi.

git grep

Ecco la sintassi usando git grepcon più pattern:

git grep --all-match --no-index -l -e string1 -e string2 -e string3 file

È inoltre possibile combinare motivi con espressioni booleane come --and, --ore--not .

Cerca man git-grepaiuto.

--all-match Quando si danno espressioni di pattern multipli, viene specificato questo flag limitare la corrispondenza ai file che hanno linee che corrispondono a tutte .

--no-index Cerca i file nella directory corrente che non è gestita da Git.

-l/ --files-with-matches/--name-only Mostra solo i nomi dei file.

-eIl prossimo parametro è il modello. L'impostazione predefinita è utilizzare regexp di base.

Altri parametri da considerare:

--threads Numero di thread di lavoro grep da utilizzare.

-q/ --quiet/--silent Non emette righe corrispondenti; esce con lo stato 0 quando c'è una corrispondenza.

Per cambiare il tipo di motivo, puoi anche usare -G/ --basic-regexp(impostazione predefinita), -F/ --fixed-strings, -E/ --extended-regexp, -P/--perl-regexp ,-f file e altri.

Relazionato:

• Come grep per due parole esistenti sulla stessa riga?
• Controlla se tutte le stringhe o regex multiple esistono in un file
• Come eseguire grep con più pattern AND? & Abbina tutti i modelli dal file contemporaneamente

Per il funzionamento OR , vedere:

• Come posso grep per più pattern con pattern con un carattere pipe?
• Grep: come aggiungere una condizione "OR"?

Inserire le stringhe che si desidera eseguire il grep in un file

echo who    > find.txt
echo Roger >> find.txt
echo [44][0-9]{9,} >> find.txt

Quindi cerca usando -f

grep -f find.txt BIG_FILE_TO_SEARCH.txt 

grep '(string1.*string2 | string2.*string1)' filename

otterrà la linea con string1 e string2 in qualsiasi ordine

grep -i -w 'string1\|string2' filename

Funziona per la corrispondenza esatta delle parole e per la corrispondenza delle parole senza distinzione tra maiuscole e minuscole, poiché viene utilizzato -i

per la partita multilinea:

echo -e "test1\ntest2\ntest3" |tr -d '\n' |grep "test1.*test3"

o

echo -e "test1\ntest5\ntest3" >tst.txt
cat tst.txt |tr -d '\n' |grep "test1.*test3\|test3.*test1"

dobbiamo solo rimuovere il carattere newline e funziona!

Dovresti avere grepcosì:

$ grep 'string1' file | grep 'string2'

Mi capita spesso di riscontrare lo stesso problema del tuo e ho appena scritto un pezzo di sceneggiatura:

function m() { # m means 'multi pattern grep'

    function _usage() {
    echo "usage: COMMAND [-inH] -p<pattern1> -p<pattern2> <filename>"
    echo "-i : ignore case"
    echo "-n : show line number"
    echo "-H : show filename"
    echo "-h : show header"
    echo "-p : specify pattern"
    }

    declare -a patterns
    # it is important to declare OPTIND as local
    local ignorecase_flag  filename linum header_flag colon result OPTIND

    while getopts "iHhnp:" opt; do
    case $opt in
        i)
        ignorecase_flag=true ;;
        H)
        filename="FILENAME," ;;
        n)
        linum="NR," ;;
        p)
        patterns+=( "$OPTARG" ) ;;
        h)
        header_flag=true ;;
        \?)
        _usage
        return ;;
    esac
    done

    if [[ -n $filename || -n $linum ]]; then
    colon="\":\","
    fi

    shift $(( $OPTIND - 1 ))

    if [[ $ignorecase_flag == true ]]; then
    for s in "${patterns[@]}"; do
            result+=" && s~/${s,,}/"
    done
    result=${result# && }
    result="{s=tolower(\$0)} $result"
    else
    for s in "${patterns[@]}"; do
            result="$result && /$s/"
    done
    result=${result# && }
    fi

    result+=" { print "$filename$linum$colon"\$0 }"

    if [[ ! -t 0 ]]; then       # pipe case
    cat - | awk "${result}"
    else
    for f in "$@"; do
        [[ $header_flag == true ]] && echo "########## $f ##########"
        awk "${result}" $f
    done
    fi
}

Uso:

echo "a b c" | m -p A 
echo "a b c" | m -i -p A # a b c

Puoi metterlo in .bashrc se vuoi.

Quando entrambe le stringhe sono in sequenza, inserire un modello tra il grepcomando:

$ grep -E "string1(?.*)string2" file

Esempio se le seguenti righe sono contenute in un file denominato Dockerfile:

FROM python:3.8 as build-python
FROM python:3.8-slim

Per ottenere la riga che contiene le stringhe: FROM pythone as build-pythonquindi utilizzare:

$ grep -E "FROM python:(?.*) as build-python" Dockerfile

Quindi l'output mostrerà solo la linea che contiene entrambe le stringhe :

FROM python:3.8 as build-python

ripgrep

Ecco l'esempio usando rg:

rg -N '(?P<p1>.*string1.*)(?P<p2>.*string2.*)' file.txt

È uno degli strumenti più veloci per il grepping, dato che è costruito sul motore regex di Rust che utilizza automi finiti, SIMD e ottimizzazioni letterali aggressive per rendere la ricerca molto veloce.

Usalo, specialmente quando lavori con dati di grandi dimensioni.

^{Vedere anche la richiesta di funzionalità correlate su GH-875 .}