Сопоставьте две строки в одной строке с grep

Я пытаюсь использовать grepдля сопоставления строк, которые содержат две разные строки. Я пробовал следующее, но это соответствует строки, которые содержат либо string1 или string2, что не то, что я хочу.

grep 'string1\|string2' filename

Так как же сопоставить grepтолько строки, содержащие обе строки ?

Ты можешь использовать grep 'string1' filename | grep 'string2'

Или, grep 'string1.*string2\|string2.*string1' filename

Я думаю, это то, что вы искали:

grep -E "string1|string2" filename

Я думаю, что ответы таковы:

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

соответствует только случаю, когда присутствуют оба, а не один или другой или оба.

Для поиска файлов, содержащих все слова в любом порядке в любом месте:

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

Первый grep запускает рекурсивный поиск ( r), игнорируя case ( i) и перечисляя (распечатывая) имена файлов, которые соответствуют ( l) для одного термина ( 'action'с одинарными кавычками), встречающегося в любом месте файла.

Последующие greps ищут другие термины, сохраняя нечувствительность к регистру и выводя соответствующие файлы.

Окончательный список файлов, которые вы получите, будет содержать эти термины в любом порядке в любом месте файла.

Если у вас есть grepс -Pвозможностью для ограниченного perlрегулярного выражения, вы можете использовать

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

который имеет преимущество работы с перекрывающимися строками. Использование perlas несколько проще grep, потому что вы можете указать логику и непосредственно:

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

Ваш метод был почти хорош, пропустил только -w

grep -w 'string1\|string2' filename

|Оператор в регулярном выражении означает или. То есть будут совпадать либо string1, либо string2. Вы могли бы сделать:

grep 'string1' filename | grep 'string2'

который передаст результаты первой команды во второй grep. Это должно дать вам только те строки, которые соответствуют обоим.

Вы можете попробовать что-то вроде этого:

(pattern1.*pattern2|pattern2.*pattern1)

И как люди предложили Perl и Python, а также сложные сценарии оболочки, вот простой подход awk :

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

Посмотрев на комментарии к принятому ответу: нет, это не делает многострочным; но это также не то, о чем просил автор вопроса.

Не пытайтесь использовать grep для этого, используйте вместо этого awk. Чтобы сопоставить 2 регулярных выражения R1 и R2 в grep, можно подумать, что это будет:

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

в то время как в awk это будет:

awk '/R1/ && /R2/'

но что, если R2перекрывается или является подмножеством R1? Эта команда grep просто не будет работать, в то время как команда awk будет работать. Допустим, вы хотите найти строки, которые содержат theи heat:

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

Для этого вам нужно использовать 2 greps и трубу:

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

и, конечно, если вы действительно требовали, чтобы они были отдельными, вы всегда можете написать в awk то же регулярное выражение, которое вы использовали в grep, и есть альтернативные решения awk, которые не предполагают повторение регулярных выражений в каждой возможной последовательности.

Если оставить в стороне, что делать, если вы хотите расширить свое решение для соответствия 3 регулярным выражениям R1, R2 и R3. В grep это был бы один из этих неудачных вариантов:

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

в то время как в awk это будет кратким, очевидным, простым, эффективным:

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

Теперь, что если вы действительно хотите сопоставить литеральные строки S1 и S2 вместо регулярных выражений R1 и R2? Вы просто не можете сделать это за один вызов grep, вы должны либо написать код, чтобы экранировать все метасхемы RE, прежде чем вызывать grep:

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

или снова используйте 2 greps и трубу:

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

что опять-таки плохой выбор, тогда как с помощью awk вы просто используете строковый оператор вместо оператора регулярного выражения:

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

А что если вы хотите сопоставить 2 регулярных выражения в абзаце, а не в строке? Не может быть сделано в grep, тривиально в awk:

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

Как насчет всего файла? Снова не может быть сделано в grep и тривиально в awk (на этот раз я использую GNU awk для multi-char RS для краткости, но это не намного больше кода в любом awk, или вы можете выбрать контрольный char, который вы не знаете быть на входе для RS, чтобы сделать то же самое):

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

Итак, если вы хотите найти несколько регулярных выражений или строк в строке, абзаце или файле, не используйте grep, используйте awk.

grep ‘string1\|string2’ FILENAME 

GNU grep версия 3.1

Найдены строки, которые начинаются только с 6 пробелов и заканчиваются:

 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

Допустим, нам нужно найти количество слов в тестовом файле. Есть два способа сделать это

1) Используйте команду grep с шаблоном сопоставления регулярных выражений

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

2) Используйте команду egrep

egrep -c 'DOG|CAT' testfile 

С egrep вам не нужно беспокоиться о выражении, а просто разделяйте слова разделителем каналов.

git grep

Вот синтаксис, использующий git grepнесколько шаблонов:

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

Вы также можете комбинировать шаблоны с логическими выражениями, такими как --and, --orи--not .

Проверьте man git-grepна помощь.

--all-matchПри предоставлении нескольких выражений шаблонов этот флаг указывается для ограничения соответствия файлам, строки которых соответствуют всем из них .

--no-index Поиск файлов в текущем каталоге, который не управляется Git.

-l/ --files-with-matches/--name-only Показывать только имена файлов.

-eСледующий параметр - это шаблон. По умолчанию используется базовое регулярное выражение.

Другие параметры для рассмотрения:

--threads Количество рабочих потоков grep для использования.

-q/ --quiet/ --silentНе выводить соответствует линии; выйти со статусом 0, когда есть совпадение.

Чтобы изменить тип шаблона, вы также можете использовать -G/ --basic-regexp(по умолчанию), -F/ --fixed-strings, -E/ --extended-regexp, -P/ --perl-regexp,-f file и другие.

Связанный:

• Как найти два слова в одной строке?
• Проверьте, существуют ли все несколько строк или регулярных выражений в файле
• Как запустить grep с несколькими шаблонами AND? И сопоставить все шаблоны из файла одновременно

Для операции ИЛИ см .:

• Как выполнить поиск нескольких шаблонов с шаблоном, имеющим символ трубы?
• Grep: как добавить условие «ИЛИ»?

Поместите строки, которые вы хотите grep для в файл

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

Затем поиск с использованием -f

grep -f find.txt BIG_FILE_TO_SEARCH.txt 

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

получит строку с string1 и string2 в любом порядке

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

Это работает для точного совпадения слов и совпадения слов без учета регистра, для этого используется -i

для многострочного соответствия:

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

или

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

нам просто нужно удалить символ новой строки, и это работает!

Вы должны иметь grepвот так:

$ grep 'string1' file | grep 'string2'

Я часто сталкиваюсь с той же проблемой, что и ваша, и я просто написал фрагмент сценария:

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
}

Использование:

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

Вы можете положить его в .bashrc, если хотите.

Когда обе строки в последовательности, поместите шаблон между ними в grepкоманде:

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

Пример, если следующие строки содержатся в файле с именем Dockerfile:

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

Чтобы получить строку, содержащую строки: FROM pythonи as build-pythonзатем используйте:

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

Тогда в выводе будет показана только строка, содержащая обе строки :

FROM python:3.8 as build-python

ripgrep

Вот пример использования rg:

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

Это один из самых быстрых инструментов поиска, так как он построен на основе движка регулярных выражений Rust который использует конечные автоматы, SIMD и агрессивные буквальные оптимизации, чтобы сделать поиск очень быстрым.

Используйте его, особенно когда вы работаете с большими данными.

^{См. Также запрос связанных функций на GH-875 .}