Como faço para encontrar todos os arquivos contendo texto específico no Linux?

Você pode usar grep -ilR:

grep -Ril "text-to-find-here" /

• i significa ignore case (opcional no seu caso).
• R significa recursivo.
• l significa "mostre o nome do arquivo, não o resultado em si".
• / significa iniciar na raiz da sua máquina.

Você pode usar ack . É como grep para o código-fonte. Você pode escanear todo o seu sistema de arquivos com ele.

Apenas faça:

ack 'text-to-find-here'

No seu diretório raiz.

Você também pode usar expressões regulares , especifique o tipo de arquivo, etc.

UPDATE

Acabei de descobrir O Silver Searcher , que é como ack, mas 3-5x mais rápido do que ele e até ignora os padrões de um arquivo .gitignore.

Você pode usar:

grep -r "string to be searched"  /path/to/dir

A variável r significa recursiva e, portanto, pesquisará o caminho especificado e também seus subdiretórios. Isto irá dizer-lhe o nome do arquivo, bem como imprimir a linha no arquivo onde a string aparece.

Ou um comando semelhante ao que você está tentando (exemplo:) para pesquisar em todos os arquivos javascript (* .js):

find . -name '*.js' -exec grep -i 'string to search for' {} \; -print

Isso imprimirá as linhas nos arquivos onde o texto aparece, mas não imprimirá o nome do arquivo.

Além deste comando, podemos escrever isto também: grep -rn "String para pesquisar"/caminho/para/diretório/ou/arquivo -r: pesquisa recursiva n: o número da linha será mostrado para correspondências

Você pode usar isto:

grep -inr "Text" folder/to/be/searched/

Lista de nomes de arquivos contendo um determinado texto

Primeiro de tudo, acredito que você tenha usado -H em vez de -l. Além disso, você pode tentar adicionar o texto dentro de citações seguido por {} \.

find / -type f -exec grep -l "text-to-find-here" {} \; 

Exemplo

Digamos que você esteja procurando por arquivos contendo texto específico "Apache License" dentro do seu diretório. Ele exibirá resultados um pouco semelhantes aos abaixo (a saída será diferente com base no conteúdo do seu diretório).

bash-4.1$ find . -type f -exec grep -l "Apache License" {} \; 
./net/Java/jvnet-parent/5/jvnet-parent-5.pom
./commons-cli/commons-cli/1.3.1/commons-cli-1.3.1.pom
./io/swagger/swagger-project/1.5.10/swagger-project-1.5.10.pom
./io/netty/netty-transport/4.1.7.Final/netty-transport-4.1.7.Final.pom
./commons-codec/commons-codec/1.9/commons-codec-1.9.pom
./commons-io/commons-io/2.4/commons-io-2.4.pom
bash-4.1$ 

Remova a sensibilidade do caso

Mesmo se você não estiver usando o caso como "texto" vs "TEXTO", você pode usar o switch -i para ignorar o caso. Você pode ler mais detalhes aqui .

Espero que isso ajude você.

Se a sua grep não suporta pesquisa recursiva, você pode combinar find com xargs:

find / -type f | xargs grep 'text-to-find-here'

Acho isso mais fácil de lembrar do que o formato para find -exec.

Isso produzirá o nome do arquivo e o conteúdo da linha correspondente, por exemplo,.

/home/rob/file:text-to-find-here

Sinalizadores opcionais que você pode querer adicionar a grep:

• -i - pesquisa insensível a maiúsculas e minúsculas
• -l - apenas exibe o nome do arquivo onde a correspondência foi encontrada
• -h - apenas mostra a linha correspondente (não o nome do arquivo)

grepNAME_ ( GNU ou BSD )

Você pode usar a ferramenta greppara pesquisar recursivamente a pasta atual, como:

grep -r "class foo" .

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

Você também pode usar a sintaxe globbing para pesquisar arquivos específicos, como:

grep "class foo" **/*.c

^{Nota: Usando a opção globbing (**), ele verifica todos os arquivos recursivamente com extensão ou padrão específico. Para ativar esta sintaxe, execute: shopt -s globstar . Você também pode usar **/*.* para todos os arquivos (excluindo ocultos 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 sintaxe findcomo:

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

Como alternativa, use ripgrepNAME_ .

ripgrepNAME_

Se você estiver trabalhando em projetos maiores ou arquivos grandes, use ripgrepname__, como:

rg "class foo" .

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

É muito mais rápido que qualquer outra ferramenta como GNU / BSDgrepNAME_ , ucgNAME_ , agNAME_ , siftNAME_ , ackNAME_ , ptNAME_ ou similar, uma vez que é construído sobre mecanismo de regex de Rust que usa autômatos finitos, SIMD e otimizações literais agressivas para tornar a pesquisa muito rápida.

Ele suporta padrões de ignorar especificados em arquivos .gitignore, portanto, um único caminho de arquivo pode ser comparado a vários padrões glob simultaneamente.

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

• -i - pesquisa insensível.
• -I - Ignora os arquivos binários.
• -w - Procura pelas palavras inteiras (no oposto da correspondência parcial do Word).
• -n - Mostra a linha do seu jogo.
• -C/--context (por exemplo -C5) - Aumenta o contexto, assim você vê o código ao redor.
• --color=auto - Marque o texto correspondente.
• -H - Exibe o nome do arquivo onde o texto é encontrado.
• -c - Exibe a contagem de linhas correspondentes. Pode ser combinado com -H.

grep -insr "pattern" *

• i: Ignora distinções de maiúsculas e minúsculas no PATTERN e nos arquivos de entrada.
• n: Prefixar cada linha de saída com o número de linha baseado em 1 em seu arquivo de entrada.
• s: Suprime as mensagens de erro sobre arquivos inexistentes ou ilegíveis.
• r: lê todos os arquivos em cada diretório, recursivamente.

Experimentar:

find . -name "*.txt" | xargs grep -i "text_pattern"

Como faço para encontrar todos os arquivos contendo texto específico no Linux? (...)

Me deparei com esta solução duas vezes:

find / -type f -exec grep -H 'text-to-find-here' {} \;

Se estiver usando findlike no seu exemplo, adicione -s--no-messages) grep e 2>/dev/null no final do comando para evitar um grande número de Permission denied mensagens emitidas por grep e find:

find / -type f -exec grep -sH 'text-to-find-here' {} \; 2>/dev/null

_ ( findé a ferramenta padrão para procurar arquivos - combinada com o grep ao procurar por texto específico - em plataformas semelhantes ao Unix. O comando find é frequentemente combinado com xargs , por o caminho.

Ferramentas mais rápidas e fáceis existem para o mesmo propósito - veja abaixo. É melhor experimentá-los desde que estejam disponíveis em sua plataforma, é claro:

Alternativas mais rápidas e fáceis

RipGrep- ferramenta de pesquisa mais rápida em torno de:

rg 'text-to-find-here' / -l

O pesquisador de prata:

ag 'text-to-find-here' / -l

ack:

ack 'text-to-find-here' / -l

Nota: Você também pode adicionar 2>/dev/null a esses comandos para ocultar muitas mensagens de erro.

Warning: a menos que você realmente não possa evitá-lo, não pesquise de '/'(o diretório raiz) para evitar uma busca longa e ineficiente! Assim, nos exemplos acima, é melhor você substituir '/' por um nome de subdiretório, por exemplo, "/ home" dependendo de onde você realmente deseja pesquisar ...

Existe um novo utilitário chamado O Silversearcher

Sudo apt install silversearcher-ag

Trabalha em estreita colaboração com o Git e outros VCS. Então você não vai conseguir nada em um .git ou outro diretório.

Você pode simplesmente usar

ag -ia "Search query"

E vai fazer a tarefa para você!

Use pwd para pesquisar em qualquer diretório em que estiver, recorrendo para baixo

grep -rnw `pwd` -e "pattern"

Update Dependendo da versão do grep que você está usando, você pode omitir pwd. Em versões mais recentes, . parece ser o caso padrão para grep se nenhum diretório for dado assim:

grep -rnw -e "pattern"

ou

grep -rnw "pattern"

fará o mesmo que acima!

grep pode ser usado mesmo se não estivermos procurando por uma string.

Simplesmente correndo,

grep -RIl "" .

imprimirá o caminho para todos os arquivos de texto, ou seja, aqueles contendo apenas caracteres imprimíveis.

Aqui estão as várias listas de comandos que podem ser usados ​​para pesquisar arquivos.

grep "text string to search” directory-path

grep [option] "text string to search” directory-path

grep -r "text string to search” directory-path

grep -r -H "text string to search” directory-path

egrep -R "Word-1|Word-2” directory-path

egrep -w -R "Word-1|Word-2” directory-path

Uma simples find pode funcionar bem. alias no seu arquivo ~/.bashrc:

alias ffind find / -type f | xargs grep

Inicie um novo terminal e emita:

ffind 'text-to-find-here'

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 em 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 specifies that it should proceed only files, not directories etc.
-exec grep specifies that for every found file, it should run grep command, passing its filename as an argument to it, by replacing {} with the filename

Espero que isso seja de ajuda ...

Expandir o grep um pouco para dar mais informações na saída, por exemplo, para obter o número da linha no arquivo onde o texto está pode ser feito da seguinte forma:

find . -type f -name "*.*" -print0 | xargs --null grep --with-filename --line-number --no-messages --color --ignore-case "searthtext"

E se você tem uma idéia de qual é o tipo de arquivo, você pode restringir sua pesquisa especificando as extensões de tipo de arquivo a procurar, neste caso .pas OR .dfm arquivos:

find . -type f \( -name "*.pas" -o -name "*.dfm" \) -print0 | xargs --null grep --with-filename --line-number --no-messages --color --ignore-case "searchtext"

Breve explicação das opções:

1. . na find especifica a partir do diretório atual.
2. -name "*.*": para todos os arquivos (-name "*.pas" -o -name "*.dfm"): Somente os arquivos *.pas OR *.dfm, OR especificados com -o
3. -type f especifica que você está procurando por arquivos
4. -print0 e --null do outro lado do | (pipe) são os cruciais, passando o nome do arquivo de find para grep incorporado em xargs, permitindo a passagem de nomes de arquivos com espaços nos nomes de arquivos, permitindo que grep trate o caminho e nome do arquivo como uma string, e não dividi-la em cada espaço.

O Silver Searcher é uma ótima ferramenta, mas o ripgrep pode ser ainda melhor.

Ele funciona em Linux, Mac e Windows, e foi escrito em Hacker News alguns meses atrás (isso tem um link para o blog de Andrew Gallant que tem um link GitHub):

Ripgrep - Uma nova ferramenta de pesquisa de linha de comando

Experimentar:

find / -type f -exec grep -H 'text-to-find-here' {} \;

que pesquisará todos os sistemas de arquivos, porque / é a pasta raiz.

Para uso da pasta inicial:

find ~/ -type f -exec grep -H 'text-to-find-here' {} \;

Para uso da pasta atual:

find ./ -type f -exec grep -H 'text-to-find-here' {} \;

Eu escrevi um script Python que faz algo semelhante. É assim que se deve usar esse script.

./sniff.py path pattern_to_search [file_pattern]

O primeiro argumento, path, é o diretório no qual procuraremos recursivamente. O segundo argumento, pattern_to_search, é uma expressão regular que queremos procurar em um arquivo. Usamos o formato de expressão regular definido na biblioteca Pythonre. Neste script, o . também corresponde à nova linha.

O terceiro argumento, file_pattern, é opcional. Esta é outra expressão regular que funciona em um nome de arquivo. Apenas os arquivos que correspondem a essa expressão regular serão considerados.

Por exemplo, se eu quiser pesquisar arquivos Python com a extensão py contendo Pool( seguido por Word Adaptor, faço o seguinte,

./sniff.py . "Pool(.*?Adaptor"  .*py
./Demos/snippets/cubeMeshSigNeur.py:146 
./Demos/snippets/testSigNeur.py:259 
./python/moose/multiscale/core/mumbl.py:206 
./Demos/snippets/multiComptSigNeur.py:268 

E voila, gera o caminho dos arquivos correspondentes e o número da linha na qual a correspondência foi encontrada. Se mais de uma correspondência for encontrada, cada número de linha será anexado ao nome do arquivo.

Usar:

grep -c Your_Pattern *

Isso informará quantas cópias de seu padrão estão em cada um dos arquivos no diretório atual.

grep é seu bom amigo para conseguir isso.

grep -r <text_fo_find> <directory>

se você não se importa com o caso do texto para encontrar, em seguida, use

grep -ir <text_to_find> <directory>

Todas as respostas anteriores sugerem grep e find. Mas há outra maneira: Use Midnight Commander

É um utilitário gratuito (30 anos, comprovado pelo tempo) que é visual sem ser GUI. Tem toneladas de funções e encontrar arquivos é apenas um deles.

Para procurar a string e produzir apenas essa linha com a string 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;

Existe uma ferramenta ack que faria exatamente o que você está procurando.

http://linux.die.net/man/1/ack

ack -i search_string folder_path/*

Você pode ignorar -i para pesquisa sensível a maiúsculas e minúsculas

O comando abaixo funcionará bem para essa abordagem:

find ./ -name "file_pattern_name"  -exec grep -r "pattern" {} \;

Tente isto:

find . | xargs grep 'Word' -sl

Eu sou fascinado por quão simples o grep faz com 'rl'

grep -rl 'pattern_to_find' /path/where/to/find

-r to find recursively file / directory inside directories..
-l to list files matching the 'pattern'

Use '-r' sem 'l' para ver os nomes dos arquivos seguidos de texto no qual o padrão é encontrado !

grep -r 'pattern_to_find' /path/where/to/find

Funciona apenas perfeito ..

Espero que ajude!

Você pode usar o comando abaixo, pois não deseja o nome do arquivo, mas deseja procurar em todos os arquivos. Aqui estão eu estou capturando o formulário "TEXT" Todos os arquivos de log, certificando-se que o nome do arquivo não é impresso

grep -e TEXT *.log | cut -d' ' --complement -s -f1

grep com opção -e é bastante rápida em comparação com outra opção, pois é para o jogo PATTERN

Evite o incômodo e instale o ack-grep. Elimina muitos problemas de permissão e cotação.

apt-get install ack-grep

Em seguida, vá para o diretório que você deseja pesquisar e execute o comando abaixo

cd /
ack-grep "find my keyword"

find com xargs é preferível quando há muitas correspondências possíveis para filtrar. Ele corre mais devagar que outras opções, mas sempre funciona. Como alguns descobriram, xargs não manipula arquivos com espaços incorporados por padrão. Você pode superar isso especificando a opção -d.

Aqui está a resposta do @ RobEarl, aprimorada para lidar com arquivos com espaços:

find / -type f | xargs -d '\n' grep 'text-to-find-here'

Aqui está a resposta do @venkat, similarmente aprimorada:

find . -name "*.txt" | xargs -d '\n' grep -i "text_pattern"

Aqui está a resposta de @Gert van Biljon, igualmente aprimorada:

find . -type f -name "*.*" -print0 | xargs -d '\n' --null grep --with-filename --line-number --no-messages --color --ignore-case "searthtext"

Aqui está a resposta do @LesalProgrammer, similarmente aprimorada:

alias ffind find / -type f | xargs -d '\n' grep

Aqui está a resposta do @Tayab Hussain, similarmente aprimorada:

find . | xargs -d '\n' grep 'Word' -sl

Se você tiver um conjunto de arquivos que sempre verificará, poderá aliasar seus caminhos, por exemplo:

alias fd='find . -type f -regex ".*\.\(inc\|info\|module\|php\|test\|install\|uninstall\)"'

Então você pode simplesmente filtrar a lista assim:

grep -U -l $'\015' $(fd)

Que filtra a lista fd para arquivos que contêm o padrão CR.

Eu acho que aliasing os arquivos que eu estou interessado em me ajuda a criar scripts mais fáceis, em seguida, sempre tentando lembrar como obter todos esses arquivos. O material recursivo também funciona, mas, mais cedo ou mais tarde, você terá que lidar com tipos de arquivos específicos. É por isso que eu acabei de encontrar todos os tipos de arquivos que eu estou interessado em começar.

Se você quiser usar estritamente find, então:

find /path/to/somewhere/ -type f -exec grep -nw 'textPattern' {} \;

find + grep

1.Use find para pesquisar arquivos, 2.Em seguida, execute grep em todos eles.

Pode ser combinado em um comando como abaixo:

find /path/to/somewhere/ -type f -exec grep -nw 'textPattern' {} \;

• Use -name Pattern se você quiser grep apenas alguns arquivos:

  find /path/to/somewhere/ -type f -name \*.cpp -exec grep -nw 'textPattern' {} \;

Isso pode dar a você o poder de find para encontrar arquivos. Você pode brincar com ele e usar diferentes opções de find para melhorar ou restringir sua pesquisa de arquivos.

Tente isto:

find / -type f -name "*" -exec grep -il "String_to_search" {} \;

Ou

for i in /*;do grep -Ril "String_to_search" $i;done 2> /dev/null

Usar:

grep -Erni + "text you wanna search"

O comando pesquisará recursivamente em todos os arquivos e diretórios do diretório atual e imprimirá o resultado.

Nota: se sua saída do grep não estiver colorida, você pode alterá-la usando o alias grep = 'grep --color = always' no seu arquivo de origem do Shell.

Você pode usar os seguintes comandos para encontrar um texto específico de um arquivo:

cat file | grep 'abc' | cut -d':' -f2

Como Peter na resposta anterior mencionada , todas as respostas anteriores sugerem grep e find.

Mas existe uma maneira mais sofisticada de usar Gnome Commander com um perfeitoGUIe com toneladas de opções desde 2001, e encontrar arquivos é apenas um deles. É um utilitário gratuito também, comprovado pelo tempo.

Tente isso

find . -type f -name some_file_name.xml -exec grep -H PUT_YOUR_STRING_HERE {} \;

Alternativa de Pesquisa da GUI - Para uso na área de trabalho:

_{- Como a questão não é exatamente pedir comandos}

Searchmonkey : Ferramenta avançada de pesquisa de arquivos sem ter que indexar seu sistema usando expressões regulares. Equivalente gráfico para encontrar/grep. Disponível para Linux (Gnome/KDE/Java) e Windows (Java) - open source GPL v3

Recursos:

• _{Expressões Regulares Avançadas}
• _{Resultados apresentados no contexto}
• _{Pesquisa contendo texto}
• _{Painel para exibir linha contendo texto}
• _{Novas atualizações de 2018}
• _etc.

Download - Links:

• _{Homepage: http://searchmonkey.embeddediq.com/}
• _{Download: http://searchmonkey.embeddediq.com/index.php/download-latest}
• _{Repo: https://sourceforge.net/projects/searchmonkey/files/}

.

Captura de tela:

seu comando está correto. Só precisa adicionar -l ao grep.

find / -type f -exec grep -l 'text-to-find-here' {} \;