Comment utiliser la commande «grep» pour rechercher du texte, y compris des sous-répertoires

Je veux trouver tous les fichiers contenant une chaîne de texte spécifique. La grepcommande fonctionne, mais je ne sais pas comment l'utiliser pour tous les répertoires (je ne peux le faire que pour mon répertoire actuel). J'ai essayé de lire man grep, mais cela ne m'a pas aidé.

Il serait préférable d'utiliser

grep -rl "string" /path

où

• -r(ou --recursive) permet de parcourir également tous les sous-répertoires de /path, alors que
• -l(ou --files-with-matches) option est utilisée pour imprimer uniquement les noms de fichiers des fichiers correspondants, et non les lignes correspondantes (cela pourrait également améliorer la vitesse, étant donné que la greplecture d'un fichier lors de la première correspondance avec cette option).

Si vous recherchez des lignes correspondant aux fichiers, ma commande préférée est:

grep -Hrn 'search term' path/to/files

• -H provoque l'impression du nom de fichier (implicite lorsque plusieurs fichiers sont recherchés)
• -r fait une recherche récursive
• -n provoque l'impression du numéro de ligne

path/to/filespeut être .de chercher dans le répertoire courant

Autres options que je trouve très utiles:

• -Iignorer les fichiers binaires (complément: -atraiter tous les fichiers en tant que texte)
• -Ftraiter search termcomme un littéral, pas une expression régulière
• -i faire une recherche insensible à la casse

• --color=alwayspour forcer les couleurs, même en passant à travers less. Pour créer lessdes couleurs de support, vous devez utiliser l' -roption:

  grep -Hrn search . | less -r
  

• --exclude-dir=dirutile pour exclure des répertoires comme .svnet .git.

Je crois que vous pouvez utiliser quelque chose comme ceci:

find /path -type f -exec grep -l "string" {} \;

Explication des commentaires

findest une commande qui vous permet de rechercher des fichiers et d'autres objets tels que des répertoires et des liens dans les sous-répertoires d'un chemin donné. Si vous ne spécifiez pas de masque que les noms de fichiers doivent rencontrer, il énumère tous les objets de répertoire.

• -type f spécifie qu'il ne devrait traiter que des fichiers, pas des répertoires, etc.
• -exec grepspécifie que pour chaque fichier trouvé, il doit exécuter la commande grep, en lui passant son nom de fichier en tant qu'argument, en le remplaçant {}par le nom de fichier

Ma commande par défaut est

grep -Rin string *

J'utilise un Capitole 'R' parce que lsje l'utilise pour le traitement récursif. Puisque grep accepte les deux, aucune raison de ne pas l'utiliser.

EDIT: par HVNSweeting, apparemment -Rsuivra des liens symboliques où ne le -rfera pas.

Si vous êtes prêt à essayer quelque chose de nouveau, tentez ackvotre chance. La commande pour rechercher récursivement le répertoire actuel stringest la suivante:

ack string

L'installation est assez simple:

curl http://betterthangrep.com/ack-standalone > ~/bin/ack && chmod 0755 !#:3

(À condition que vous ayez déjà le répertoire ~/binet qu'il soit de préférence dans votre PATH.)

La commande rgrep est dédiée à ce besoin

Si non disponible, vous pouvez l'obtenir comme ceci

mkdir -p ~/bin
cd ~/bin
wget http://sdjf.esmartdesign.com/files/rgrep
chmod +x rgrep

Vous pouvez directement définir vos options grep par défaut comme décrit ci-dessus.

J'utilise personnellement

[[  ${#args} -lt 5 && "${args//[[:space:]]/}" == "-i" ]] && args="-Hin"
args="${args:--Hns} --color=auto"

Sujet connexe: comment utiliser toujours rgrep couleur

Mise à jour 2:

Cette ligne de commandes utilisant findet grepcorrige le problème:

$ find path_to_search_in -type f -exec grep -in searchString {} 2> /dev/null +

--color=<always or auto> pour une sortie en couleur:

$ find path_to_search_in -type f \
            -exec grep --color=always -in searchString {} 2>/dev/null +

Exemple:

$ find /tmp/test/ -type f -exec grep --color=auto -in "Search string" {} 2>/dev/null +

Un exemple exécuté dans l'instantané ci-dessous:

Mise à jour 1:

Vous pouvez essayer le code suivant. en fonction de votre .bashrcou .bash_aliasesou dans un script:

wherein () 
{ 
    for i in $(find "$1" -type f 2> /dev/null);
    do
        if grep --color=auto -i "$2" "$i" 2> /dev/null; then
            echo -e "\033[0;32mFound in: $i \033[0m\n";
        fi;
    done
}

Usage: wherein /path/to/search/in/ searchkeyword

exemple:

$ wherein ~/Documents/ "hello world"

(Remarque: comme @enzotib le suggère dans les commentaires ci-dessous, cela ne fonctionne pas avec les fichiers / répertoires incluant des espaces dans leurs noms.)

Original post

Pour rechercher la chaîne et afficher uniquement cette ligne avec la chaîne de recherche:

$ for i in $(find /path/of/target/directory -type f); do \
    grep -i "the string to look for" "$i"; done

par exemple:

$ for i in $(find /usr/share/applications -type f); \
    do grep -i "web browser" "$i"; done

Pour afficher le nom de fichier contenant la chaîne de recherche:

$ for i in $(find /path/of/target/directory -type f); do \
    if grep -i "the string to look for" "$i" > /dev/null; then echo "$i"; fi; done;

par exemple:

$ for i in $(find /usr/share/applications -type f); \
    do if grep -i "web browser" "$i" > /dev/null; then echo "$i"; \
    fi; done;

grep( GNU ou BSD )

Vous pouvez utiliser greptool pour rechercher de manière récursive le dossier actuel avec -rparamètre, comme:

grep -r "pattern" .

^{Remarque: -r- Recherchez de manière récursive les sous-répertoires.}

Pour effectuer une recherche dans des fichiers spécifiques, vous pouvez utiliser une syntaxe globale telle que:

grep "class foo" **/*.c

^{Remarque: En utilisant l' option globbing ( **), il analyse tous les fichiers de manière récursive avec une extension ou un motif spécifique. Pour activer cette syntaxe, exécutez: shopt -s globstar. Vous pouvez également utiliser **/*.*pour tous les fichiers (sauf les fichiers cachés et sans extension) ou tout autre motif.}

Si vous estimez que votre argument est trop long, envisagez de préciser votre recherche ou utilisez findplutôt la syntaxe suivante:

find . -name "*.php" -execdir grep -nH --color=auto foo {} ';'

Alternativement utiliser ripgrep.

ripgrep

Si vous travaillez sur des projets plus volumineux ou de gros fichiers, utilisez ripgrepplutôt:

rg "pattern" .

^{Consultez la documentation, les étapes d'installation ou le code source sur la page du projet GitHub .}

Il est beaucoup plus rapide que tout autre outil comme GNU / BSD grep , ucg, ag, sift, ack, ptou similaire, puisqu'il est construit sur le dessus du moteur de regex de rouille qui utilise des automates finis, SIMD et optimisations littérales agressives pour faire une recherche très rapide.

Il prend en charge les modèles ignorer spécifiés dans les .gitignorefichiers, donc un seul chemin de fichier peut être en correspondance avec plusieurs modèles de glob simultanément.

Vous pouvez utiliser les paramètres communs tels que:

• -i - Recherche insensible.
• -I - Ignorer les fichiers binaires.
• -w - Rechercher les mots entiers (par opposition à la correspondance partielle des mots).
• -n - Montre la ligne de ton match.
• -C/ --context(eg -C5) - Augmente le contexte pour que vous voyiez le code qui l'entoure.
• --color=auto - Marquez le texte correspondant.
• -H - Affiche le nom du fichier où se trouve le texte.
• -c- Affiche le nombre de lignes correspondantes. Peut être combiné avec -H.

Je le fais en utilisant xargs, une commande très sous-estimée

find ./ -type f -print0 | xargs -0 grep 'string_you_are_looking_for'

find ./ vous donne une liste récursive de tous les fichiers d'un dossier en cours, puis dirigez-le vers xargs qui exécute la commande grep sur chacun de ces fichiers.

Je sais qu'il y a beaucoup de réponses ici, mais voici une alternative si vous souhaitez ajouter d'autres restrictions lors de la recherche dans les fichiers:

find . -type f -exec grep --quiet string_to_look_for {} ';' -print

Cela fonctionne car grepretournera 0 s'il a trouvé un résultat, 1 sinon. Par exemple, vous pouvez trouver des fichiers de 1 Mo et contenant quelque chose:

find . -type f -exec grep --quiet string_to_look_for {} ';' -size 1M -print

Pour plusieurs besoins, vous souhaiterez probablement utiliser l'indicateur d'optimiseur -Oexistant dans GNU grep.

Un script (find-in-code) pour rechercher en C, code CPP:

#!/bin/sh

find . \( -iname "*.c" -o -iname "*.cpp" -o -iname "*.h" \) -type f -print0 | xargs -0 grep --color -n "$1"

Utilisation:

find-in-code "search string"