Come escludere / ignorare file e directory nascosti in una ricerca "trova" con caratteri jolly?

A partire da (notare i caratteri jolly prima e dopo "un po 'di testo")

find . -type f -name '*some text*'

come si possono escludere / ignorare tutti i file e le directory nascosti?

Ho già cercato su Google per troppo tempo , mi sono imbattuto in qualche prugna e! (punto esclamativo) parametri, ma nessun esempio appropriato (e parsimonioso) che ha appena funzionato .

Effettuare il piping | su grepsarebbe un'opzione e accetterei anche con favore esempi di ciò; ma principalmente mi interessa un breve one-liner (o un paio di one-liner indipendenti, che illustrano modi diversi per raggiungere lo stesso obiettivo da riga di comando) semplicemente usando find.

ps: trovare file in linux ed escludere directory specifiche sembra strettamente correlato, ma a) non è ancora accettato eb) è correlato ma diverso e distinto, ma c) può fornire ispirazione e aiutare a individuare la confusione!

modificare

find . \( ! -regex '.*/\..*' \) -type f -name "whatever", lavori. Il regex cerca "qualsiasi cosa, quindi una barra, quindi un punto, quindi qualsiasi cosa" (ovvero tutti i file e le cartelle nascosti, comprese le relative sottocartelle), e il "!" nega la regex.

Questo stampa tutti i file che discendono dalla tua directory, saltando i file e le directory nascosti:

find . -not -path '*/\.*'

Quindi se stai cercando un file con il some textsuo nome e vuoi saltare file e directory nascosti, esegui:

find . -not -path '*/\.*' -type f -name '*some text*'

Spiegazione:

L' -pathopzione esegue un modello su tutta la stringa del percorso. *è un carattere jolly, /è un separatore di directory, \.è un punto (deve essere evitato per evitare un significato speciale) ed *è un altro carattere jolly. -notsignifica che non selezionare i file che corrispondono a questo test.

Non penso che findsia abbastanza intelligente da evitare la ricerca ricorsiva di directory nascoste nel comando precedente, quindi se hai bisogno di velocità, usa -pruneinvece, in questo modo:

 find . -type d -path '*/\.*' -prune -o -not -name '.*' -type f -name '*some text*' -print

Questo è uno dei pochi mezzi per escludere i file dot che funziona correttamente anche su BSD, Mac e Linux:

find "$PWD" -name ".*" -prune -o -print

• $PWD stampa il percorso completo nella directory corrente in modo che il percorso non inizi con ./
• -name ".*" -prune corrisponde a tutti i file o directory che iniziano con un punto e quindi non scendono
• -o -printsignifica stampare il nome del file se l'espressione precedente non corrisponde a nulla. L'uso -printo -print0fa sì che tutte le altre espressioni non vengano stampate per impostazione predefinita.

find $DIR -not -path '*/\.*' -type f \( ! -iname ".*" \)

Esclude tutte le directory nascoste e i file nascosti in $ DIR

^{La risposta che ho pubblicato inizialmente come "modifica" alla mia domanda originale sopra:}

find . \( ! -regex '.*/\..*' \) -type f -name "whatever", lavori. Il regex cerca "qualsiasi cosa, quindi una barra, quindi un punto, quindi qualsiasi cosa" (ovvero tutti i file e le cartelle nascosti, comprese le relative sottocartelle), e il "!" nega la regex.

Non devi usarlo findper quello. Usa globstar in shell stesso, come:

echo **/*foo*

o:

ls **/*foo*

dove **/rappresenta qualsiasi cartella ricorsivamente e *foo*qualsiasi file che ha il foosuo nome.

Per impostazione predefinita, utilizzando lsverranno stampati i nomi dei file, esclusi i file e le directory nascosti.

Se non hai abilitato il globbing, fallo da shopt -s globstar.

^{Nota: una nuova opzione globbing funziona in Bash 4, zsh e shell simili.}

Esempio:

$ mkdir -vp a/b/c/d
mkdir: created directory 'a'
mkdir: created directory 'a/b'
mkdir: created directory 'a/b/c'
mkdir: created directory 'a/b/c/d'
$ touch a/b/c/d/foo a/b/c/d/bar  a/b/c/d/.foo_hidden a/b/c/d/foo_not_hidden
$ echo **/*foo*
a/b/c/d/foo  a/b/c/d/foo_not_hidden

La risposta di @ Flimm è buona, soprattutto perché impedisce che il ritrovamento scenda in directory nascoste . Preferisco questa semplificazione:

Generalmente per escludere tutti i percorsi nascosti (file regolari, directory, ecc.):

find <start-point> -path '*/.*' -prune -o <expression> -print

Ad esempio, utilizzando la directory di lavoro come punto iniziale e -name '*some text*'come espressione:

find . -path '*/.*' -prune -o -name '*some text*' -print

Contrariamente a quanto suggerisce la risposta di @ Flimm, nessun caso o file nascosti è il caso semplice. L' -path '*/.*'espressione è vero per qualsiasi percorso (file regolari, directory, ecc) che ha una .subito dopo l'separatore di file /. Quindi questa linea eliminerà sia i file che le directory nascoste.

Consentire i file nascosti escludendo le directory nascoste è il caso che richiede un ulteriore filtro. È qui che dovresti includere -type dl'espressione da potare.

find <start-point> -type d -path '*/.*' -prune -o <expression> -print 

Per esempio:

find . -type d -path '*/.*' -prune -o -name '*some text*' -print

In questo caso -type d -path '*/.*'è truesolo per le directory, quindi vengono eliminate solo le directory.

findha interruttori logici accurati come -ande -notpuoi usarli a tuo vantaggio per trovare un file corrispondente con due regole in questo modo:

$ touch non_hidden_file.txt .hidden_file.txt somethings/.another_hidden_file.txt                                                 

$ find . -type f -name '*hidden_file*' -and \( -not -name ".*" \)                            
./non_hidden_file.txt

Come puoi vedere, findusa due regole -name '*hidden_file*'e -and \( -not -name ".*" \)trova quei nomi di file che soddisfano entrambe le condizioni - nome file con hidden_filedentro ma senza punto iniziale. Nota le barre davanti alla parentesi: sono usate per definire le parentesi come findargomenti piuttosto che definire una sottostruttura (che è ciò che significa parentesi altrimenti senza barre)

$ pwd
/home/victoria

$ find $(pwd) -maxdepth 1 -type f -not -path '*/\.*' | sort
/home/victoria/new
/home/victoria/new1
/home/victoria/new2
/home/victoria/new3
/home/victoria/new3.md
/home/victoria/new.md
/home/victoria/package.json
/home/victoria/Untitled Document 1
/home/victoria/Untitled Document 2

$ find . -maxdepth 1 -type f -not -path '*/\.*' | sed 's/^\.\///g' | sort
new
new1
new2
new3
new3.md
new.md
package.json
Untitled Document 1
Untitled Document 2

Appunti:

• . : cartella corrente
• rimuovi -maxdepth 1per cercare ricorsivamente
• -type f: trova i file, non le directory ( d)
• -not -path '*/\.*' : non tornare .hidden_files
• sed 's/^\.\///g': rimuove l'elemento anteposto ./dall'elenco dei risultati