Come cercare tutti i file che iniziano con il nome "ABC" in una directory?

Devo cercare i file che iniziano con un nome particolare. Possono esserci più file che iniziano con un modello particolare e voglio elencare tutti questi file presenti nella directory.

Per completare le risposte esistenti:

ls

L'utilità dell'elenco di directory predefinito lspuò essere utilizzata in combinazione con i caratteri jolly della shell. Per cercare tutti i file con motivo abc:

ls abc*   # list all files starting with abc---
ls *abc*  # list all files containing --abc--
ls *abc   # list all files ending with --abc

Si noti che l'estensione del file è rilevante anche per i risultati della ricerca.

tree

Nel caso in cui abbiamo bisogno di elencare i file in un albero di directory possiamo anche emettere treeper cercare un dato modello come:

tree -P 'abc*'  # list directory tree of file starting with abc---
tree -l 'def*'  # exclude files starting with def---

In questo caso, esso treestesso supporta i caratteri jolly.

È possibile utilizzare il findcomando per cercare file con pattern

find . -type f -name "abc*" 

Il comando sopra cercherà il file che inizia con abc nella directory di lavoro corrente.

-name 'abc'elencherà i file che corrispondono esattamente. Ad esempio: abc

Puoi anche usare

 -iname
 -regex 

opzione con findcomando per cercare il nome del file usando un modello

Esistono molti modi per farlo, a seconda di cosa esattamente vuoi fare con loro. Generalmente, se vuoi semplicemente elencarli, puoi farlo in un terminale usando:

find | grep '^\./ABC'

... e sostituendo ABCcon il tuo testo.

Per capire il comando, suddividiamolo un po ':

• findelenca tutti i file nella directory corrente e nelle sue sottodirectory; usandolo da solo elencherà tutto lì. Si noti che findgenera ogni file o directory che inizia con ./, indicando che il loro percorso è relativo alla directory corrente. Essere consapevoli di questo è importante perché significa che cercheremo risultati a partire da ./ABCe non solo ABC.

• Il carattere pipe |reindirizza l'output di un comando a un altro, in questo caso l'output di findviene reindirizzato a grep. Questo si chiama piping.

• grepprende l'uscita e filtra usando il pattern specificato, ^\./ABC.

  • Si noti che il modello è citato con virgolette singole ' 'per impedire alla shell di interpretare i caratteri speciali al suo interno.

• Ora il modello stesso è scritto in una particolare sintassi chiamata espressione regolare , o regex in breve. Regex è uno strumento di ricerca estremamente potente se lo padroni, e ci sono siti come questo che ti insegnano in modo più approfondito, ma nota che grepnon è un vero motore regex e non puoi farci tutto.

• Per il nostro scopo:

  • ^in regex corrisponde all'inizio della stringa; questo impedisce che corrisponda al modello se non si verifica all'inizio del nome del file.

  • .in regex ha anche un significato speciale: significa "abbina un singolo carattere qui". Nel caso in cui tu voglia usarlo come un punto letterale, dovrai "scappare" usando una barra rovesciata \prima di esso. (Sì, abbinare qualsiasi personaggio sarebbe innocuo nel nostro caso, ma l'ho fatto per completezza.)

puoi usare GREP, penso che questa sia la soluzione più semplice, probabilmente aggiungi anche alcuni altri parametri grep per rendere la corrispondenza più accurata

tree | grep ABC

Puoi cercare un modello particolare usando il file manager Nautilus e le espressioni regolari.

Per fare ciò, fai clic su Seleziona elementi corrispondenti nel menu a ingranaggi come di seguito (puoi anche premere Ctrl+ s).

Quindi, basta digitare l' espressione regolare ABC* e confermare.

Ogni file il cui nome corrisponde al modello verrà automaticamente selezionato.

Sto usando Nautilus 3.6. * Da GNOME3 PPA su Ubuntu 12.10 (Quantal).

La soluzione più semplice per me

ls | grep PATTERN

Qui puoi dare qualsiasi espressione regolare nel MODELLO.

Ad esempio, per trovare file con "ab" in qualsiasi punto del suo nome, digitare

ls | grep ".*ab.*"

Per trovare i file che iniziano con "ab", digitare

ls | grep "^ab"

Se non conosci la directory in cui ABC*si trovano i file e hai milioni di file, il locatecomando è il metodo più veloce.

$ locate /ABC
/mnt/clone/home/rick/.cache/mozilla/firefox/9fu0cuql.default/cache2/entries/ABC6AD2FEC16465049B48D39FD2FE538258F2A34
/mnt/clone/home/rick/.cache/mozilla/firefox/9fu0cuql.default/cache2/entries/ABCBFDA54262F47253F95ED6ED4131A465EE0E39
/mnt/clone/usr/src/linux-headers-5.0.1-050001/tools/lib/lockdep/tests/ABCABC.sh
/mnt/clone/usr/src/linux-headers-5.0.1-050001/tools/lib/lockdep/tests/ABCDBCDA.sh
/mnt/clone/usr/src/linux-headers-5.0.1-050001/tools/lib/lockdep/tests/ABCDBDDA.sh
/mnt/old/home/rick/.cache/mozilla/firefox/3vkvi6ov.default/cache2/entries/ABC0C99FCEABAD0C6AA2078CD025A1CDE48D7BA1
/usr/src/linux-headers-5.0.1-050001/tools/lib/lockdep/tests/ABCABC.sh
/usr/src/linux-headers-5.0.1-050001/tools/lib/lockdep/tests/ABCDBCDA.sh
/usr/src/linux-headers-5.0.1-050001/tools/lib/lockdep/tests/ABCDBDDA.sh

Appunti:

• Il comando sopra richiede 1 secondo per essere eseguito su 1 milione di file.
• In confronto, il findcomando che inizia nella /directory principale richiederà molto tempo e genererà molti errori di autorizzazione.
• Se i file sono stati creati oggi, è necessario eseguire sudo updatedbprima.

Io uso

ls | grep abc

o

ls -la | grep abc

Mostra tutti i file con abc, non solo iniziando con abc. Ma è un modo davvero semplice per me farlo.

Pitone:

$ python -c 'import sys,os;found=[os.path.join(r,i) for r,s,f in os.walk(".") for i in f if i.startswith("ABC")];map(lambda x: sys.stdout.write(x+"\n") ,found)'

Perl:

$ perl -le 'use File::Find;find(sub{ -f && $_ =~/^ABC/ && print $File::Find::name  },".")' 

printf "%s" /path/to/files/ABC*

Questa è la corrispondenza del motivo glob che è ancorata ad entrambe le estremità. Ciò corrisponderà a tutte le occorrenze di file che iniziano con "ABC" come "ABC", "ABC.txt", "ABC123", ma non "xABC". Dalla riga di comando usare 'ls' al posto di 'printf' qui è un'alternativa sicura, a seconda dell'opinione con cui sei d'accordo, 'ls' non è sicuro per l'uso in uno script. In tal caso, l'uso di "printf" con la corrispondenza del motivo glob è considerato sicuro. Se lo utilizzerai in uno script, l'output di 'printf' non conterrà un nuovo carattere di linea fino alla fine del flusso di output in quanto tale:

printf "%s" /path/to/files/ABC*  

Ritorna:

/path/to/files/ABC /path/to/files/ABC123

Se hai bisogno di interruzioni di riga dopo ogni istanza:

printf "%s\n" /path/to/files/ABC*

Ritorna:

/path/to/files/ABC 

/path/to/files/ABC123

"/ path / to / files /" rimane nell'output se è stato immesso in quel modo quando è stato eseguito il comando 'printf'. Senza di essa appare solo il nome del file:

printf "%s" ABC* 

ritorna

ABC ABC123

Supponendo di eseguire il comando all'interno della directory in cui esistono i file.

Comando-t in uno dei miei plugin vim preferiti, è un plugin basato su ruby ​​sopra l'integrazione con FZF.

Utilizzando Comamnd-T e FZF è possibile effettuare la ricerca con un meccanismo "fuzzy" estremamente veloce per:

• Apertura di file e buffer
• Saltare ai tag e aiutare
• Esecuzione di comandi o ricerche e comandi precedenti
• con un numero minimo di tasti.

Come potete vedere

Cerco sempre nella cronologia dei comandi aprendo un nuovo terminale e premo:

CTRL+R

Oltre a cercare ricorsivamente in tutte le cartelle scrivendo in qualsiasi scheda del terminale:

fzf

Quindi avviare il nome del file

ABC

Inoltre, puoi scrivere all'interno vim

:CommandT 

Davvero utile soprattutto nelle cartelle di grandi dimensioni.

Supponiamo che io sia nella directory principale e voglio solo l'elenco della directory etc: scriviamo,

find -type d -name "etc"

risultato che otteniamo,

[root@unix /]# find -type d -name "etc"

./etc
./usr/lib/firefox/bundled/etc
./usr/lib/unix-yarn/etc
./usr/lib/unix/etc
./usr/lib/festival/etc
./usr/bin/lib/vmware-tools/lib64/libconf/etc
./usr/bin/lib/vmware-tools/lib32/libconf/etc
./usr/etc
./usr/share/doc/oddjob-0.30/sample/etc
./usr/share/festival/lib/etc
./usr/local/etc
./usr/java/jdk1.7.0_25/lib/visualvm/etc
./home/user1/Desktop/VMware Tools/vmware-tools-distrib/lib/lib64/libconf/etc
./home/user1/Desktop/VMware Tools/vmware-tools-distrib/lib/lib32/libconf/etc
./home/user1/Desktop/VMware Tools/vmware-tools-distrib/etc
./home/user1/Desktop/VMware Tools/vmware-tools-distrib/caf/etc

Un altro esempio,

Inoltre possiamo scrivere:

ls | grep "etc"

noi abbiamo,

etc