Faire correspondre deux chaînes en une seule ligne avec grep

J'essaie d'utiliser greppour faire correspondre les lignes qui contiennent deux chaînes différentes. J'ai essayé ce qui suit mais cela correspond aux lignes qui contiennent soit string1 ou string2 qui ne correspondent pas à ce que je veux.

grep 'string1\|string2' filename

Alors, comment puis-je faire correspondre grepuniquement les lignes contenant les deux chaînes ?

Vous pouvez utiliser grep 'string1' filename | grep 'string2'

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

Je pense que c'est ce que vous cherchiez:

grep -E "string1|string2" filename

Je pense que des réponses comme celle-ci:

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

correspond uniquement au cas où les deux sont présents, pas l'un ou l'autre ou les deux.

Pour rechercher des fichiers contenant tous les mots dans n'importe quel ordre, n'importe où:

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

Le premier grep lance une recherche récursive ( r), ignorant la casse ( i) et listant (imprimant) le nom des fichiers qui correspondent ( l) pour un terme ( 'action'avec les guillemets simples) se trouvant n'importe où dans le fichier.

Les greps suivants recherchent les autres termes, conservent l'insensibilité à la casse et répertorient les fichiers correspondants.

La liste finale des fichiers que vous obtiendrez sera celle qui contient ces termes, dans n'importe quel ordre n'importe où dans le fichier.

Si vous avez un grepavec une -Poption pour une perlexpression rationnelle limitée , vous pouvez utiliser

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

ce qui a l'avantage de travailler avec des chaînes qui se chevauchent. C'est un peu plus simple d'utiliser perlas grep, car vous pouvez spécifier la logique et plus directement:

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

Votre méthode était presque bonne, il ne manquait que le -w

grep -w 'string1\|string2' filename

L' |opérateur dans une expression régulière signifie ou. C'est-à-dire que string1 ou string2 correspondra. Vous pourriez faire:

grep 'string1' filename | grep 'string2'

qui dirigera les résultats de la première commande vers le deuxième grep. Cela ne devrait vous donner que des lignes qui correspondent aux deux.

Vous pouvez essayer quelque chose comme ceci:

(pattern1.*pattern2|pattern2.*pattern1)

Et comme les gens ont suggéré perl et python, et des scripts shell compliqués, voici une approche awk simple :

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

Après avoir regardé les commentaires de la réponse acceptée: non, cela ne fait pas plusieurs lignes; mais ce n'est pas non plus ce que l'auteur de la question a demandé.

N'essayez pas d'utiliser grep pour cela, utilisez plutôt awk. Pour faire correspondre 2 expressions rationnelles R1 et R2 dans grep, vous penseriez que ce serait:

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

alors qu'en awk ce serait:

awk '/R1/ && /R2/'

mais que se passe-t-il si R2chevauche ou est un sous-ensemble de R1? Cette commande grep ne fonctionnerait tout simplement pas alors que la commande awk le ferait. Disons que vous voulez trouver des lignes qui contiennent theet heat:

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

Il faudrait utiliser 2 greps et un pipe pour ça:

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

et bien sûr, si vous aviez réellement demandé qu'ils soient séparés, vous pouvez toujours écrire dans awk la même expression régulière que celle utilisée dans grep et il existe des solutions alternatives à awk qui n'impliquent pas de répéter les expressions rationnelles dans chaque séquence possible.

Mis à part cela, que se passe-t-il si vous souhaitez étendre votre solution pour correspondre à 3 regexps R1, R2 et R3. En grep, ce serait l'un de ces mauvais choix:

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

alors qu'en awk, ce serait concis, évident, simple, efficace:

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

Maintenant, que se passe-t-il si vous vouliez réellement faire correspondre les chaînes littérales S1 et S2 au lieu des expressions rationnelles R1 et R2? Vous ne pouvez tout simplement pas faire cela en un seul appel à grep, vous devez soit écrire du code pour échapper à toutes les métachars RE avant d'appeler grep:

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

ou encore utiliser 2 greps et un pipe:

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

qui sont encore de mauvais choix alors qu'avec awk vous utilisez simplement un opérateur de chaîne au lieu de l'opérateur regexp:

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

Maintenant, que se passe-t-il si vous souhaitez faire correspondre 2 expressions rationnelles dans un paragraphe plutôt qu'une ligne? Ne peut pas être fait dans grep, trivial dans awk:

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

Que diriez-vous de l'ensemble d'un fichier? Encore une fois, cela ne peut pas être fait en grep et trivial en awk (cette fois, j'utilise GNU awk pour RS multi-caractères pour la concision, mais ce n'est pas beaucoup plus de code dans n'importe quel awk ou vous pouvez choisir un contrôle-caractère que vous ne savez pas être en entrée pour que le RS fasse de même):

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

Donc - si vous voulez trouver plusieurs expressions rationnelles ou chaînes dans une ligne ou un paragraphe ou un fichier, n'utilisez pas grep, utilisez awk.

grep ‘string1\|string2’ FILENAME 

GNU grep version 3.1

Lignes trouvées commençant seulement par 6 espaces et se terminant par:

 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

Disons que nous devons trouver le nombre de mots multiples dans un fichier de test de fichier. Il y a deux façons de procéder

1) Utilisez la commande grep avec le modèle de correspondance d'expression régulière

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

2) Utilisez la commande egrep

egrep -c 'DOG|CAT' testfile 

Avec egrep, vous n'avez pas à vous soucier de l'expression et juste séparer les mots par un séparateur de tuyau.

git grep

Voici la syntaxe à utiliser git grepavec plusieurs modèles:

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

Vous pouvez également combiner des modèles avec des expressions booléennes telles que --and, --oret --not.

Cherchez man git-grepde l'aide.

--all-matchLorsque vous donnez plusieurs expressions de modèle, cet indicateur est spécifié pour limiter la correspondance aux fichiers dont les lignes correspondent à toutes .

--no-index Recherchez des fichiers dans le répertoire en cours qui ne sont pas gérés par Git.

-l/ --files-with-matches/ --name-onlyAfficher uniquement les noms des fichiers.

-eLe paramètre suivant est le motif. La valeur par défaut consiste à utiliser l'expression rationnelle de base.

Autres paramètres à considérer:

--threads Nombre de threads de travail grep à utiliser.

-q/ --quiet/ --silentNe pas sortir de lignes correspondantes; quitter avec le statut 0 en cas de correspondance.

Pour modifier le type de modèle, vous pouvez également utiliser -G/ --basic-regexp(par défaut), -F/ --fixed-strings, -E/ --extended-regexp, -P/ --perl-regexp, -f fileet d' autres.

En relation:

• Comment grep pour deux mots existant sur la même ligne?
• Vérifiez si toutes les chaînes ou expressions régulières multiples existent dans un fichier
• Comment exécuter grep avec plusieurs modèles AND? & Faire correspondre tous les modèles du fichier à la fois

Pour l' opération OR , voir:

• Comment puis-je rechercher plusieurs motifs avec un motif ayant un caractère pipe?
• Grep: comment ajouter une condition «OU»?

Placez les chaînes que vous souhaitez grep dans un fichier

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

Recherchez ensuite à l'aide de -f

grep -f find.txt BIG_FILE_TO_SEARCH.txt 

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

obtiendra la ligne avec string1 et string2 dans n'importe quel ordre

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

Cela fonctionne pour une correspondance exacte des mots et des mots insensibles à la casse, pour que -i soit utilisé

pour une correspondance multiligne:

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

ou

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

nous avons juste besoin de supprimer le caractère de nouvelle ligne et cela fonctionne!

Vous devriez avoir grepcomme ça:

$ grep 'string1' file | grep 'string2'

Je rencontre souvent le même problème que le vôtre, et je viens d'écrire un morceau de script:

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
}

Usage:

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

Vous pouvez le mettre en .bashrc si vous le souhaitez.

Lorsque les deux chaînes sont en séquence, mettez un motif entre les deux sur la grepcommande:

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

Exemple si les lignes suivantes sont contenues dans un fichier nommé Dockerfile:

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

Pour obtenir la ligne qui contient les chaînes: FROM pythonet as build-pythonpuis utilisez:

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

Ensuite, la sortie n'affichera que la ligne qui contient les deux chaînes :

FROM python:3.8 as build-python

ripgrep

Voici l'exemple utilisant rg:

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

C'est l'un des outils les plus rapides, car il est construit sur le moteur regex de Rust qui utilise des automates finis, SIMD et des optimisations littérales agressives pour rendre la recherche très rapide.

Utilisez-le, surtout lorsque vous travaillez avec des données volumineuses.

^{Voir également la demande de fonctionnalité associée au GH-875 .}