Como recursivamente grep
todos os diretórios e subdiretórios?
find . | xargs grep "texthere" *
grep -rin xlsx *.pl
não funciona para mim no Redhat Linux. Eu recebo um erro "sem correspondência".
Como recursivamente grep
todos os diretórios e subdiretórios?
find . | xargs grep "texthere" *
grep -rin xlsx *.pl
não funciona para mim no Redhat Linux. Eu recebo um erro "sem correspondência".
Respostas:
grep -r "texthere" .
O primeiro parâmetro representa a expressão regular a ser pesquisada, enquanto o segundo representa o diretório que deve ser pesquisado. Nesse caso, .
significa o diretório atual.
Nota: Isso funciona para o GNU grep e, em algumas plataformas como o Solaris, você deve usar especificamente o GNU grep em vez da implementação herdada. Para Solaris, este é o ggrep
comando.
AIX 5.3
por exemplo.
Se você conhece a extensão ou o padrão do arquivo que deseja, outro método é usar a --include
opção:
grep -r --include "*.txt" texthere .
Você também pode mencionar arquivos para excluir --exclude
.
Se você pesquisar com frequência o código, o Ag (The Silver Searcher) é uma alternativa muito mais rápida ao grep, personalizada para pesquisar o código. Por exemplo, é recursivo por padrão e ignora automaticamente os arquivos e diretórios listados .gitignore
, para que você não precise continuar passando as mesmas opções de exclusão complicadas para grep ou find.
=
funcionar muito bem no Ubuntu. PS: esse é um espaço reservado, mas o analisador de remarcação SO falhou.
grep
, não para o Ag, só assim você sabe :)
--include "*.txt" --include "*.TXT"
Além disso:
find ./ -type f -print0 | xargs -0 grep "foo"
mas grep -r
é uma resposta melhor.
find . -type f -exec grep "foo" '{}' \;
funciona bem quando suportado.
find ./ -type f -print0 | xargs -0 grep "foo"
Agora eu sempre uso (mesmo no Windows com GoW - Gnu no Windows ):
grep --include="*.xxx" -nRHI "my Text to grep" *
Isso inclui as seguintes opções:
--include=PATTERN
Recursar em diretórios apenas pesquisando a correspondência de arquivos
PATTERN
.
-n, --line-number
Prefixe cada linha de saída com o número da linha em seu arquivo de entrada.
(Nota: phuclv adiciona nos comentários que -n
diminuem muito o desempenho , portanto, você pode pular essa opção)
-R, -r, --recursive
Leia todos os arquivos em cada diretório, recursivamente; isso é equivalente à
-d recurse
opção.
-H, --with-filename
Imprima o nome do arquivo para cada correspondência.
-I
Processe um arquivo binário como se não contivesse dados correspondentes;
isso é equivalente à--binary-files=without-match
opção.
E posso adicionar ' i
' ( -nRHIi
), se quiser resultados que não diferenciam maiúsculas de minúsculas.
Eu posso conseguir:
/home/vonc/gitpoc/passenger/gitlist/github #grep --include="*.php" -nRHI "hidden" *
src/GitList/Application.php:43: 'git.hidden' => $config->get('git', 'hidden') ? $config->get('git', 'hidden') : array(),
src/GitList/Provider/GitServiceProvider.php:21: $options['hidden'] = $app['git.hidden'];
tests/InterfaceTest.php:32: $options['hidden'] = array(self::$tmpdir . '/hiddenrepo');
vendor/klaussilveira/gitter/lib/Gitter/Client.php:20: protected $hidden;
vendor/klaussilveira/gitter/lib/Gitter/Client.php:170: * Get hidden repository list
vendor/klaussilveira/gitter/lib/Gitter/Client.php:176: return $this->hidden;
...
-R
opção) às pastas.
*
ou .
é um padrão glob (interpretado pelo shell): unix.stackexchange.com/a/64695/7490 . ' .
' selecionará arquivos de pontos ou pastas de pontos (como .git/
)
grep -rnI
, mas então eu aprendi que -n
diminui o desempenho muito , então eu só usá-lo quando realmente necessário e, normalmente, eu vou usar-rI
Nos sistemas POSIX, você não encontra -r
parâmetro para grep
e grep -rn "stuff" .
não será executado, mas se você usar o find
comando, ele irá:
find . -type f -exec grep -n "stuff" {} \; -print
Acordado por Solaris
e HP-UX
.
-exec
option - symbol {}
é uma referência ao nome do arquivo encontrado atualmente pela find
ferramenta (isto é, para fazer algo com o nome do arquivo que encontramos), também a -exec
opção deve ser encerrada com o ;
símbolo (para marcar o final dos comandos exec), mas porque isso é tudo executando em um shell que símbolo deve ser escapado .. e finalmente a -print
opção permite que a find
ferramenta imprima os nomes de arquivos encontrados na tela.
**
Usando grep -r
obras, mas pode exagerar, especialmente em pastas grandes.
Para uso mais prático, aqui está a sintaxe que usa a sintaxe de globbing ( **
):
grep "texthere" **/*.txt
que recebe apenas arquivos específicos com o padrão selecionado. Ele funciona para shells suportados, como Bash +4 ou zsh .
Para ativar esse recurso, execute: shopt -s globstar
.
Veja também: Como encontro todos os arquivos que contêm texto específico no Linux?
git grep
Para projetos sob controle de versão do Git, use:
git grep "pattern"
o que é muito mais rápido.
ripgrep
Para projetos maiores, a ferramenta de grepping mais rápida é a de ripgrep
que greps arquivos recursivamente por padrão:
rg "pattern" .
Ele foi construído sobre o mecanismo de regex da Rust, que usa autômatos finitos, SIMD e otimizações literais agressivas para tornar a pesquisa muito rápida. Verifique a análise detalhada aqui .
Para encontrar o nome de files
com path
contendo recursivamente o particular string
uso abaixo de comando para UNIX
:
find . | xargs grep "searched-string"
para Linux
:
grep -r "searched-string" .
encontre um arquivo no UNIX
servidor
find . -type f -name file_name
encontre um arquivo no servidor LINUX
find . -name file_name
Se você deseja apenas seguir diretórios reais, e não links simbólicos,
grep -r "thingToBeFound" directory
Se você deseja seguir os links simbólicos e os diretórios reais (tenha cuidado com a recursão infinita),
grep -R "thing to be found" directory
Como você está tentando grep recursivamente, as seguintes opções também podem ser úteis para você:
-H: outputs the filename with the line
-n: outputs the line number in the file
Portanto, se você deseja encontrar todos os arquivos que contêm Darth Vader no diretório atual ou em qualquer subdiretório e capturar o nome do arquivo e o número da linha, mas não deseja que a recursão siga os links simbólicos, o comando será
grep -rnH "Darth Vader" .
Se você quiser encontrar todas as menções à palavra gato no diretório
/home/adam/Desktop/TomAndJerry
e você está atualmente no diretório
/home/adam/Desktop/WorldDominationPlot
e você deseja capturar o nome do arquivo, mas não o número da linha de qualquer instância da string "cats", e deseja que a recursão siga os links simbólicos, se os encontrar, você pode executar um dos seguintes
grep -RH "cats" ../TomAndJerry #relative directory
grep -RH "cats" /home/adam/Desktop/TomAndJerry #absolute directory
Fonte:
executando "grep --help"
Uma breve introdução aos links simbólicos, para qualquer pessoa que esteja lendo esta resposta e confusa com a minha referência a eles: https://www.nixtutor.com/freebsd/understanding-symbolic-links/
ag é minha maneira favorita de fazer isso agora github.com/ggreer/the_silver_searcher . É basicamente a mesma coisa que ack, mas com mais algumas otimizações.
Aqui está uma pequena referência. Limpo o cache antes de cada teste (consulte /ubuntu/155768/how-do-i-clean-or-disable-the-memory-cache )
ryan@3G08$ sync && echo 3 | sudo tee /proc/sys/vm/drop_caches
3
ryan@3G08$ time grep -r "hey ya" .
real 0m9.458s
user 0m0.368s
sys 0m3.788s
ryan@3G08:$ sync && echo 3 | sudo tee /proc/sys/vm/drop_caches
3
ryan@3G08$ time ack-grep "hey ya" .
real 0m6.296s
user 0m0.716s
sys 0m1.056s
ryan@3G08$ sync && echo 3 | sudo tee /proc/sys/vm/drop_caches
3
ryan@3G08$ time ag "hey ya" .
real 0m5.641s
user 0m0.356s
sys 0m3.444s
ryan@3G08$ time ag "hey ya" . #test without first clearing cache
real 0m0.154s
user 0m0.224s
sys 0m0.172s
Isso deve funcionar:
grep -R "texthere" *
Se você estiver procurando por um conteúdo específico em todos os arquivos de uma estrutura de diretórios, poderá usar, find
pois fica mais claro o que está fazendo:
find -type f -exec grep -l "texthere" {} +
Observe que -l
(letras minúsculas de L) mostra o nome do arquivo que contém o texto. Remova-o se desejar imprimir a correspondência em si. Ou use -H
para reunir o arquivo com a correspondência. No conjunto, outras alternativas são:
find -type f -exec grep -Hn "texthere" {} +
Onde -n
imprime o número da linha.
find
solução para evitar o uso desnecessário xargs
e o uso em +
vez de \;
com ele -exec
, evitando toneladas de lançamentos desnecessários de processos. :-)
Este é o que funcionou para o meu caso na minha máquina atual (git bash no windows 7):
find ./ -type f -iname "*.cs" -print0 | xargs -0 grep "content pattern"
Eu sempre esqueço o -print0 e -0 para caminhos com espaços.
EDIT: Agora minha ferramenta preferida é ripgrep: https://github.com/BurntSushi/ripgrep/releases . É muito rápido e tem melhores padrões (como recursivo por padrão). Mesmo exemplo da minha resposta original, mas usando ripgrep:rg -g "*.cs" "content pattern"
grep -r "texthere" .
(período de notificação no final)
(^ credit: https://stackoverflow.com/a/1987928/1438029 )
Esclarecimento:
grep -r "texthere" /
(grep recursivamente todos os diretórios e subdiretórios)
grep -r "texthere" .
(grep recursivamente esses diretórios e subdiretórios)
grep [options] PATTERN [FILE...]
[opções]
-R, -r, --recursive
Leia todos os arquivos em cada diretório, recursivamente.
Isso é equivalente à opção
-d recurse
ou--directories=recurse
.
$ grep --help
$ grep --help |grep recursive
-r, --recursive like --directories=recurse
-R, --dereference-recursive
ack
( http://beyondgrep.com/ )
Em 2018, você deseja usar ripgrep
ou the-silver-searcher
porque eles são muito mais rápidos que as alternativas.
Aqui está um diretório com 336 subdiretórios de primeiro nível:
% find . -maxdepth 1 -type d | wc -l
336
% time rg -w aggs -g '*.py'
...
rg -w aggs -g '*.py' 1.24s user 2.23s system 283% cpu 1.222 total
% time ag -w aggs -G '.*py$'
...
ag -w aggs -G '.*py$' 2.71s user 1.55s system 116% cpu 3.651 total
% time find ./ -type f -name '*.py' | xargs grep -w aggs
...
find ./ -type f -name '*.py' 1.34s user 5.68s system 32% cpu 21.329 total
xargs grep -w aggs 6.65s user 0.49s system 32% cpu 22.164 total
No OSX, este instala ripgrep
: brew install ripgrep
. Isso instala silver-searcher
: brew install the_silver_searcher
.
rg
tem uma vantagem considerável em juntar um comando grep recursivo do zero. Usando rg
: rg foo
. Usando ferramentas UNIX: find . | xargs grep foo
. E se algum dos seus arquivos tiver uma citação, você precisará usá-lo find . -print0 | xargs -0 grep foo
. Você vai se lembrar que se você usar isso algumas vezes por ano?
find . -type f -exec grep 'regex' {} +
que é realmente fácil de lembrar se você usar essas ferramentas com alguma regularidade. Mas provavelmente você deve executar ctags
ou etags
na sua árvore de origem de qualquer maneira, se precisar encontrar coisas com frequência.
No meu IBM AIX Server (versão do SO: AIX 5.2), use:
find ./ -type f -print -exec grep -n -i "stringYouWannaFind" {} \;
isso imprimirá o nome do caminho / arquivo e o número da linha relativa no arquivo, como:
./inc/xxxx_x.h
2865: / ** Descrição: stringYouWannaFind * /
de qualquer forma, funciona para mim :)
Abaixo está o comando para pesquisar um ambiente e String
recursivamente .Unix
Linux
para UNIX
comando é:
find . -name "string to be searched" -exec grep "text" "{}" \;
para Linux
comando é:
grep -r "string to be searched" .
Para uma lista de sinalizadores disponíveis:
grep --help
Retorna todas as correspondências para o texto regexp no diretório atual, com o número da linha correspondente:
grep -rn "texthere" .
Retorna todas as correspondências para o texto aqui , começando no diretório raiz, com o número da linha correspondente e o caso de ignorância:
grep -rni "texthere" /
bandeiras usadas aqui:
-r
recursivo -n
número da linha de impressão com saída -i
ignorar casoEu acho que é isso que você está tentando escrever
grep myText $(find .)
e isso pode ser outra coisa útil se você deseja encontrar os arquivos grep hit
grep myText $(find .) | cut -d : -f 1 | sort | uniq
Observe que find . -type f | xargs grep whatever
tipos de soluções serão executados em erros de "lista de argumentos longos" quando houver muitos arquivos correspondidos por localização.
A melhor aposta é grep -r
que, se isso não estiver disponível, use-o find . -type f -exec grep -H whatever {} \;
.
xargs
é especificamente uma solução alternativa para o problema "A lista de argumentos é muito longa".
find . -type f | xargs -L 100 grep whatever
xargs
é padronizado para ter esse comportamento pronto para uso. "O xargs
utilitário limitará o comprimento da linha de comando de forma que, quando a linha de comando for chamada, as listas combinadas de argumentos e ambiente ... não excederão {ARG_MAX} -2048 bytes."
Aqui está uma função recursiva (testada levemente com bash e sh) que percorre todas as subpastas de uma determinada pasta ($ 1) e usa grep
pesquisas para uma determinada string ($ 3) em determinados arquivos ($ 2):
$ cat script.sh
#!/bin/sh
cd "$1"
loop () {
for i in *
do
if [ -d "$i" ]
then
# echo entering "$i"
cd "$i"
loop "$1" "$2"
fi
done
if [ -f "$1" ]
then
grep -l "$2" "$PWD/$1"
fi
cd ..
}
loop "$2" "$3"
Executando-o e um exemplo de saída:
$ sh script start_folder filename search_string
/home/james/start_folder/dir2/filename