Como usar o comando “grep” para encontrar texto, incluindo subdiretórios

Quero encontrar todos os arquivos que contêm uma sequência específica de texto. O grepcomando funciona, mas não sei como usá-lo para todos os diretórios (só posso fazê-lo no meu diretório atual). Tentei ler man grep, mas não deu nenhuma ajuda.

Seria melhor usar

grep -rl "string" /path

Onde

• -r(ou --recursive) é usada para percorrer também todos os subdiretórios de /path, enquanto
• -l(ou --files-with-matches) é usada para imprimir apenas nomes de arquivos de arquivos correspondentes, e não as linhas correspondentes (isso também pode melhorar a velocidade, dado que greppara de ler um arquivo na primeira correspondência com esta opção).

Se você estiver procurando por linhas correspondentes nos arquivos, meu comando favorito é:

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

• -H faz com que o nome do arquivo seja impresso (implícito quando vários arquivos são pesquisados)
• -r faz uma pesquisa recursiva
• -n faz com que o número da linha seja impresso

path/to/filespode ser .procurar no diretório atual

Outras opções que eu acho muito úteis:

• -Iignorar arquivos binários (complemento: -atratar todos os arquivos como texto)
• -Ftratar search termcomo uma expressão literal, não regular
• -i faça uma pesquisa que não diferencia maiúsculas de minúsculas

• --color=alwayspara forçar as cores, mesmo durante a passagem less. Para criar lesscores de suporte, você precisa usar a -ropção:

  grep -Hrn search . | less -r
  

• --exclude-dir=dirútil para excluir diretórios como .svne .git.

Eu acredito que você pode usar algo como isto:

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

Explicação dos comentários

findé um comando que permite encontrar arquivos e outros objetos, como diretórios e links, nos subdiretórios de um determinado caminho. Se você não especificar uma máscara que os nomes de arquivos devem atender, ele enumera todos os objetos de diretório.

• -type f especifica que ele deve processar apenas arquivos, não diretórios etc.
• -exec grepespecifica que, para cada arquivo encontrado, ele deve executar o comando grep, passando seu nome de arquivo como argumento, substituindo {}pelo nome do arquivo

Meu comando padrão é

grep -Rin string *

Eu uso um capitólio 'R' porque o lsusa para recursivo. Como o grep aceita os dois, não há razão para não usá-lo.

EDIT: por HVNSweeting, aparentemente -Rseguirá links simbólicos onde, como -rnão será.

Se você estiver disposto a tentar algo novo, tente ack. O comando para pesquisar recursivamente o diretório atual stringé:

ack string

A instalação é bastante simples:

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

(Desde que você já tenha o diretório ~/bine ele esteja de preferência no seu PATH.)

O comando rgrep é dedicado a essa necessidade

Se não estiver disponível, você pode obtê-lo assim

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

Você pode definir diretamente em suas opções padrão de grep, conforme descrito acima.

Eu pessoalmente uso

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

tópico relacionado: como sempre usar rgrep com cores

Atualização 2:

Esta linha de comandos usando finde grepcorrigindo o problema:

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

--color=<always or auto> para saída colorida:

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

Exemplo:

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

Um exemplo executado na captura instantânea abaixo:

Atualização 1:

Você pode tentar seguir o código; como uma função em seu .bashrcou .bash_aliasesou em um 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
}

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

exemplo:

$ wherein ~/Documents/ "hello world"

(Nota: Conforme sugerido nos comentários abaixo por @enzotib, isso não funciona com arquivos / diretórios, incluindo espaços em seus nomes.)

Postagem original

Para procurar a sequência e gerar apenas essa linha com a sequência de pesquisa:

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

por exemplo:

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

Para exibir o nome do arquivo que contém a string de pesquisa:

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

por exemplo:

$ 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 )

Você pode usar a grepferramenta para pesquisar recursivamente a pasta atual com o -rparâmetro, como:

grep -r "pattern" .

^{Nota: -r- Pesquise recursivamente subdiretórios.}

Para pesquisar em arquivos específicos, você pode usar uma sintaxe invejável , como:

grep "class foo" **/*.c

^{Nota: Ao usar a opção globbing ( **), ele verifica todos os arquivos recursivamente com extensão ou padrão específico. Para habilitar essa sintaxe, execute: shopt -s globstar. Você também pode usar **/*.*para todos os arquivos (excluindo oculto e sem extensão) ou qualquer outro padrão.}

Se você tiver o erro de que seu argumento é muito longo, considere restringir sua pesquisa ou use a findsintaxe, como:

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

Como alternativa, use ripgrep.

ripgrep

Se você estiver trabalhando em projetos maiores ou em arquivos grandes, deve usar ripgrep, como:

rg "pattern" .

^{Confira os documentos, as etapas de instalação ou o código-fonte na página do projeto GitHub .}

É muito mais rápido do que qualquer outra ferramenta como o GNU / BSD grep , ucg, ag, sift, ack, ptou similar, uma vez que é construído em cima do motor de regex de Rust que usa autômatos finitos, SIMD e otimizações literais agressivos para tornar a busca muito rápido.

Ele suporta padrões de ignorar especificados em .gitignorearquivos, para que um único caminho de arquivo possa ser comparado com vários padrões glob simultaneamente.

Você pode usar os parâmetros comuns, como:

• -i - Pesquisa insensível.
• -I - Ignore os arquivos binários.
• -w - Pesquise as palavras inteiras (ao contrário da correspondência parcial de palavras).
• -n - Mostre a linha do seu jogo.
• -C/ --context(por exemplo -C5) - Aumenta o contexto, para que você veja o código ao redor.
• --color=auto - Marque o texto correspondente.
• -H - Exibe o nome do arquivo onde o texto é encontrado.
• -c- Exibe contagem de linhas correspondentes. Pode ser combinado com -H.

Eu faço isso usando xargs, um comando muito subestimado

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

find ./ fornece uma lista recursiva de todos os arquivos em uma pasta atual e, em seguida, você o envia para o xargs que executa o comando grep em cada um desses arquivos

Sei que há muitas respostas aqui, mas aqui está uma alternativa, se você quiser adicionar outras restrições ao pesquisar os arquivos:

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

Isso funciona porque grepretornará 0 se encontrou um resultado, 1 caso contrário. Por exemplo, você pode encontrar arquivos com 1 MB de tamanho e contendo algo:

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

Para vários requisitos, você provavelmente deseja usar o sinalizador otimizador -Oque existe no GNU grep.

Um script (localizar no código) para pesquisar em C, código CPP:

#!/bin/sh

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

Usar:

find-in-code "search string"