Usa grep --exclude / - include la sintassi per non grep attraverso determinati file

Sto cercando la stringa foo=nei file di testo in un albero di directory. È su una macchina Linux comune, ho bash shell:

grep -ircl "foo=" *

Nelle directory ci sono anche molti file binari che corrispondono a "foo =". Poiché questi risultati non sono pertinenti e rallentano la ricerca, voglio che grep salti la ricerca di questi file (principalmente immagini JPEG e PNG). Come potrei farlo?

So che ci sono le opzioni --exclude=PATTERNe --include=PATTERN, ma qual è il formato del modello? La pagina man di grep dice:

--include=PATTERN     Recurse in directories only searching file matching PATTERN.
--exclude=PATTERN     Recurse in directories skip file matching PATTERN.

La ricerca su grep include , grep include exclude , grep exclude e le varianti non hanno trovato nulla di rilevante

Se esiste un modo migliore di eseguire il grepping solo in determinati file, sono pronto per questo; spostare i file offensivi non è un'opzione. Non riesco a cercare solo determinate directory (la struttura delle directory è un gran casino, con tutto ovunque). Inoltre, non riesco a installare nulla, quindi ho a che fare con strumenti comuni (come grep o la ricerca suggerita ).

Usa la sintassi globbing della shell:

grep pattern -r --include=\*.{cpp,h} rootdir

La sintassi per --excludeè identica.

Nota che la stella è sfuggita a una barra rovesciata per impedire che venga espansa dalla shell (citandola, come --include="*.{cpp,h}", funzionerebbe altrettanto bene). Altrimenti, se nella directory di lavoro corrente fossero presenti file che corrispondessero al modello, la riga di comando si espanderebbe in qualcosa del genere grep pattern -r --include=foo.cpp --include=bar.h rootdir, che cercherebbe solo i file con nome foo.cppe bar.hche probabilmente non è quello che volevi.

Se vuoi solo saltare i file binari, ti suggerisco di guardare l' -Iopzione (maiuscola i). Ignora i file binari. Uso regolarmente il seguente comando:

grep -rI --exclude-dir="\.svn" "pattern" *

Cerca in modo ricorsivo, ignora i file binari e non cerca nelle cartelle nascoste di Subversion, qualunque sia il modello che voglio. Ho alias come "grepsvn" sulla mia scatola al lavoro.

Dai un'occhiata a ack , che è progettato proprio per queste situazioni. Il tuo esempio di

grep -ircl --exclude=*.{png,jpg} "foo=" *

è fatto con ack come

ack -icl "foo="

perché ack non cerca mai nei file binari per impostazione predefinita e -r è attivo per impostazione predefinita. E se vuoi solo file CPP e H, allora fallo

ack -icl --cpp "foo="

grep 2.5.3 ha introdotto il parametro --exclude-dir che funzionerà nel modo desiderato.

grep -rI --exclude-dir=\.svn PATTERN .

Puoi anche impostare una variabile d'ambiente: GREP_OPTIONS = "- exclude-dir = .svn"

Io secondo di Andy voto per ack però, è il migliore.

L'ho trovato dopo molto tempo, è possibile aggiungere più inclusioni ed esclusioni come:

grep "z-index" . --include=*.js --exclude=*js/lib/* --exclude=*.min.js

Il comando suggerito:

grep -Ir --exclude="*\.svn*" "pattern" *

è concettualmente sbagliato, perché --exclude funziona sul nome di base. In altre parole, salterà solo il .svn nella directory corrente.

In grep 2.5.1 devi aggiungere questa linea al profilo ~ / .bashrc o ~ / .bash

export GREP_OPTIONS="--exclude=\*.svn\*"

Trovo che l'output di grep grep sia molto utile a volte:

grep -rn "foo=" . | grep -v "Binary file"

Tuttavia, ciò non gli impedisce di cercare i file binari.

Se non sei contrario all'utilizzo find, mi piace la sua -prunefunzionalità:

find [directory] \
        -name "pattern_to_exclude" -prune \
     -o -name "another_pattern_to_exclude" -prune \
     -o -name "pattern_to_INCLUDE" -print0 \
| xargs -0 -I FILENAME grep -IR "pattern" FILENAME

Nella prima riga, si specifica la directory che si desidera cercare. .(directory corrente) è un percorso valido, ad esempio.

Al 2 ° e 3 ° linee, uso "*.png", "*.gif", "*.jpg", e così via. Usa tanti di questi -o -name "..." -prunecostrutti quanti sono i tuoi schemi.

Sulla quarta riga, hai bisogno di un altro -o(specifica "o" a find), i modelli che vuoi, e hai bisogno di uno -printo -print0alla fine di esso. Se si desidera solo "tutto il resto", che rimane dopo la potatura la *.gif, *.pngecc immagini, quindi utilizzare -o -print0e il gioco è fatto con il 4 ° riga.

Infine, sulla 5a riga è la pipe in xargscui prende ciascuno di quei file risultanti e li memorizza in una variabile FILENAME. Passa quindi grepi -IRflag, il "pattern", e quindi FILENAMEviene espanso xargsper diventare quell'elenco di nomi di file trovati da find.

Per la tua domanda particolare, la dichiarazione potrebbe assomigliare a:

find . \
     -name "*.png" -prune \
     -o -name "*.gif" -prune \
     -o -name "*.svn" -prune \
     -o -print0 | xargs -0 -I FILES grep -IR "foo=" FILES

Su CentOS 6.6 / Grep 2.6.3, devo usarlo in questo modo:

grep "term" -Hnir --include \*.php --exclude-dir "*excluded_dir*"

Si noti la mancanza di segni di uguale "=" (altrimenti --include, --exclude, include-dire --exclude-dirvengono ignorati)

git grep

Utilizzo git grepottimizzato per le prestazioni e finalizzato alla ricerca in determinati file.

Di default ignora i file binari e onora il tuo .gitignore. Se non stai lavorando con la struttura Git, puoi comunque usarlo passando --no-index.

Sintassi di esempio:

git grep --no-index "some_pattern"

Per altri esempi, vedere:

• Come escludere determinate directory / file dalla ricerca di git grep .
• Controlla se tutte le stringhe o regex multiple esistono in un file

Sono un dilettante, garantito, ma ecco come appare il mio ~ / .bash_profile:

export GREP_OPTIONS = "- orl --exclude-dir = .svn --exclude-dir = .cache --color = auto" GREP_COLOR = '1; 32'

Nota che per escludere due directory, ho dovuto usare --exclude-dir due volte.

Prova questo:

$ find. -name "* .txt" -type f -print | file xargs | grep "foo =" | cut -d: -f1

Fondato qui: http://www.unix.com/shell-programming-scripting/42573-search-files-excluding-binary-files.html

Se cerchi in modo non ricorsivo, puoi usare i pattern glop per abbinare i nomi dei file.

grep "foo" *.{html,txt}

include html e txt. Cerca solo nella directory corrente.

Per cercare nelle sottodirectory:

   grep "foo" */*.{html,txt}

Nelle directory secondarie:

   grep "foo" */*/*.{html,txt}

Nelle directory ci sono anche molti file binari. Non riesco a cercare solo determinate directory (la struttura delle directory è un gran casino). Esiste un modo migliore per eseguire il grepping solo in determinati file?

ripgrep

Questo è uno degli strumenti più veloci progettati per la ricerca ricorsiva della directory corrente. È scritto in Rust , costruito sulla base del motore regex di Rust per la massima efficienza. Controlla qui l'analisi dettagliata .

Quindi puoi semplicemente eseguire:

rg "some_pattern"

Rispetta il tuo .gitignoree salta automaticamente file / directory nascosti e file binari.

È ancora possibile personalizzare includere o escludere file e directory utilizzando -g/ --glob. Le regole dei globbing corrispondono ai .gitignoreglobs. Cerca man rgaiuto.

Per altri esempi, vedi: Come escludere alcuni file che non corrispondono a determinate estensioni con grep?

Su macOS, puoi installarlo tramite brew install ripgrep.

find e xargs sono i tuoi amici. Usali per filtrare l'elenco dei file piuttosto che --exclude di grep

Prova qualcosa del genere

find . -not -name '*.png' -o -type f -print | xargs grep -icl "foo="

Il vantaggio di abituarsi a questo è che è espandibile ad altri casi d'uso, ad esempio per contare le righe in tutti i file non png:

find . -not -name '*.png' -o -type f -print | xargs wc -l

Per rimuovere tutti i file non png:

find . -not -name '*.png' -o -type f -print | xargs rm

eccetera.

Come sottolineato nei commenti, se alcuni file possono contenere spazi nei loro nomi, utilizzare -print0e xargs -0invece.

quegli script non risolvono tutto il problema ... Prova meglio:

du -ha | grep -i -o "\./.*" | grep -v "\.svn\|another_file\|another_folder" | xargs grep -i -n "$1"

questo script è molto meglio, perché usa espressioni regolari "reali" per evitare la ricerca di directory. basta separare i nomi di cartelle o file con "\ |" sul grep -v

divertirsi! trovato sulla mia shell Linux! XD

Guarda @ questo.

grep --exclude="*\.svn*" -rn "foo=" * | grep -v Binary | grep -v tags

L' --binary-files=without-matchopzione GNU grepconsente di saltare i file binari. (Equivalente -Iall'interruttore menzionato altrove.)

(Ciò potrebbe richiedere una versione recente di grep; 2.5.3 ce l'ha, almeno.)

adatto per il file tcsh .alias:

alias gisrc 'grep -I -r -i --exclude="*\.svn*" --include="*\."{mm,m,h,cc,c} \!* *'

Mi ci è voluto un po 'per capire che la parte {mm, m, h, cc, c} NON dovrebbe essere racchiusa tra virgolette. ~ Keith

Per ignorare tutti i risultati binari di grep

grep -Ri "pattern" * | awk '{if($1 != "Binary") print $0}'

La parte awk filtra tutte le righe corrispondenti al file binario

Prova questo:

1. Crea una cartella denominata " --F" sotto currdir .. (o collega un'altra cartella lì rinominata in " --F" cioè double-minus-F.
2. #> grep -i --exclude-dir="\-\-F" "pattern" *