Comment utiliser la commande "grep" pour trouver du texte, y compris des sous-répertoires

Il serait préférable d'utiliser

grep -rl "string" /path

où

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

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

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

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

path/to/files peut être . pour rechercher dans le répertoire en cours

Autres options que je trouve très utiles:

• -I ignore les fichiers binaires (complément: -a traite tous les fichiers comme du texte)
• -F traite search term comme un littéral, pas comme une expression régulière
• -i effectue une recherche insensible à la casse

• --color=always pour forcer les couleurs même lors du passage de less . Pour que less supporte les couleurs, vous devez utiliser l'option -r :

  grep -Hrn search . | less -r
  

• --exclude-dir=dir utile pour exclure les répertoires comme .svn et .git .

Je crois que vous pouvez utiliser quelque chose comme ceci:

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

Explication des commentaires

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

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

Ma commande par défaut est

grep -Rin string *

J'utilise un capitol 'R' car ls l'utilise pour récursif. Puisque grep accepte les deux, aucune raison de ne pas l'utiliser.

EDIT: par HVNSweeting, apparemment -R suivra les liens symboliques où -r ne le sera pas.

Si vous souhaitez essayer quelque chose de nouveau, donnez un coup d’œil à ack . La commande de recherche récursive dans le répertoire en cours pour string est:

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 ~/bin et 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 de 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 toujours utiliser rgrep en couleur

Mise à jour 2:

Cette ligne de commandes utilisant find et grep corrige le problème:

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

--color=<always or auto> pour la 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 tant que fonction dans vos .bashrc ou .bash_aliases ou dans un script:

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

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

exemple:

$ wherein ~/Documents/ "hello world"

(Remarque: comme suggéré dans les commentaires ci-dessous par @enzotib, cela ne fonctionne pas avec les fichiers / répertoires, y compris les espaces dans leurs noms.)

Poste d'origine

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 du 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;

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 vous le dirigez vers xargs qui exécute la commande grep sur chacun de ces fichiers

Je sais qu’il ya 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 grep renverra 0 s'il a trouvé un résultat, 1 sinon. Par exemple, vous pouvez trouver des fichiers de 1 Mo de large et contenant quelque chose:

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

Pour plusieurs exigences, vous souhaiterez probablement utiliser l'indicateur d'optimisation -O qui existe dans GNU grep.

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

#!/bin/sh

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

Utiliser:

find-in-code "search string"

grep ( GNU ou BSD )

Vous pouvez utiliser l'outil grep pour rechercher récursivement le dossier actuel avec le paramètre -r , comme:

grep -r "pattern" .

^{Remarque: -r - Recherche récursive dans les sous-répertoires.}

Pour rechercher dans des fichiers spécifiques, vous pouvez utiliser une syntaxe de regroupement , telle que:

grep "class foo" **/*.c

^{Remarque: En utilisant l’option de globalisation ( ** ), 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 (à l'exclusion des fichiers cachés et sans extension) ou tout autre modèle.}

Si vous constatez que votre argument est trop long, envisagez de limiter votre recherche ou utilisez plutôt la syntaxe find telle que:

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

Vous pouvez également utiliser ripgrep .

ripgrep

Si vous travaillez sur de plus gros projets ou de gros fichiers, utilisez plutôt ripgrep , par exemple:

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 tel que GNU / BSD grep , ucg , ag , sift , ack , pt ou similaire, car il est construit sur la regex de Rust moteur qui utilise des automates finis, SIMD et optimisations littérales agressives pour rendre la recherche très rapide.

Il prend en charge les motifs d’ignorance spécifiés dans les fichiers .gitignore , de sorte qu’un chemin de fichier unique peut être comparé à plusieurs modèles de globes simultanément.

Vous pouvez utiliser les paramètres communs tels que:

• -i - Recherche insensible.
• -I - Ignore les fichiers binaires.
• -w - Recherchez les mots entiers (à l'opposé de la correspondance de mots partielle).
• -n - Affiche la ligne de votre correspondance.
• -C / --context (par exemple -C5 ) - Augmente le contexte, vous voyez donc le code environnant.
• --color=auto - Marque le texte correspondant.
• -H - Affiche le nom du fichier où le texte est trouvé.
• -c - Affiche le nombre de lignes correspondantes. Peut être combiné avec -H .