Jak korzystać z grep, aby dopasować wiele ciągów w tej samej linii?

Question

Próbuję użyć grep, aby dopasować wiersze zawierające dwa różne ciągi. Próbowałem następujące, ale to dopasowuje linie, które zawierają albo string1lubstring2 które nie jest to, co chcę.

grep 'string1\|string2' filename 

Więc jak mogę się równać z grep tylko linie, które zawierają oba ciągi?

Answer 1

Można użyć grep 'string1' filename | grep 'string2'

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

Answer 2

Operator | w wyrażeniu regularnym oznacza lub. Oznacza to, że albo string1, albo string2 będą pasować. Możesz zrobić:

grep 'string1' filename | grep 'string2' 

, który przefaksuje wyniki z pierwszego polecenia do drugiego grepa. To powinno dać ci tylko linie, które pasują do obu.

Answer 3

Można spróbować czegoś takiego:

(pattern1.*pattern2|pattern2.*pattern1) 

Answer 4

Trzeba grep takiego:

$ grep 'string1' file | grep 'string2' 

Answer 5

Jeśli masz a grep z -P rozwiązaniem dla ograniczonej perl regex, można użyć

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

który ma tę zaletę, że działa z nakładających strun. Jest to nieco prostsze przy użyciu perl jako grep, ponieważ można określić i logika bardziej bezpośrednio:

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

Answer 6

myślę, że to jest to, czego szukali:

grep -E "string1|string2" filename 

Myślę, że odpowiedzi tak:

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

pasuje tylko do przypadku, w którym oba są obecne, a nie jedno lub drugie lub oba.

Answer 7

dla wielowierszowego meczu:

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

lub

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

musimy tylko usunąć znak nowej linii i to działa!

Answer 8

Aby wyszukać pliki zawierające wszystkie słowa w dowolnej kolejności wszędzie:

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

Pierwszy grep startuje rekurencyjne przeszukiwanie (r), ignorując sprawę (i) wystawianie (drukowanie) nazwę pliki, które pasują (l) na jeden termin ('action' z pojedynczymi cudzysłowami) występujące w dowolnym miejscu pliku.

Kolejne greps wyszukuje inne warunki, nie rozróżnia wielkości liter i wyświetla listę pasujących plików.

Ostateczna lista plików, które otrzymasz, zawiera te warunki, w dowolnej kolejności w dowolnym miejscu pliku.

Answer 9

Twoja metoda było prawie dobrze, tylko brakuje -w

grep -w 'string1\|string2' filename 

Answer 10

Wystarczy dać mu wiele -e opcje.

-e pattern, --regexp=pattern 
     Specify a pattern used during the search of the input: an input 
     line is selected if it matches any of the specified patterns. 
     This option is most useful when multiple -e options are used to 
     specify multiple patterns, or when a pattern begins with a dash 
     (`-'). 

W ten sposób staje się komenda:

grep -e "string1" -e "string2" filename 

_{Uwaga: Powyżej przytoczyłem podręcznik wersji BSD, ale wygląda na to, że to the same on Linux.}

Answer 11

Place struny chcesz grep do do pliku

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

Następnie wyszukać używając -f

grep -f find.txt BIG_FILE_TO_SEARCH.txt 

Answer 12

Znaleziono linie, które uruchamia się tylko z 6 pomieszczeń i wykończony:

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 

Answer 13

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

dostanie linię łańcuch1 i łańcuch2 w dowolnej kolejności

Answer 14

często napotkasz ten sam problem jak ty, a ja po prostu napisał kawałek skryptu:

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 
} 

Zastosowanie:

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

Możesz umieścić go w .bashrc, jeśli chcesz.

Answer 15

Powiedzmy, że musimy znaleźć liczbę wielu słów w pliku testowym pliku. Istnieją dwa sposoby, aby przejść o nim

1) Użyj polecenia grep z pasującym regex wzór

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

2) Korzystanie z egrep dowodzić

egrep -c 'DOG|CAT' testfile 

Z egrep nie musisz się martwić o wyrażeniu i po prostu oddziel słowa przez separator rur.

Answer 16

A jak ludzie sugerują, Perl i Python, i zawiłe skrypty powłoki, tutaj prosty awk podejście:

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

Spojrzeliśmy w komentarzach do przyjętej Odpowiedź: Nie, to nie robi wielu -linia; ale to też nie jest to, o co pytał autor pytania.

Answer 17

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

Działa to na dokładne dopasowanie słowo i dopasowywanie wielkość liter ma znaczenie słów, na które służy -i