Comment exclure / ignorer les fichiers et répertoires cachés dans une recherche "trouver" avec caractères génériques?

À partir de (remarquez les caractères génériques avant et après "du texte")

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

Comment peut-on exclure / ignorer tous les fichiers et répertoires cachés?

Cela fait trop longtemps que je googe dans Google . paramètres (point d’exclamation), mais aucun exemple approprié (et parcimonieux) qui a juste fonctionné .

La tuyauterie | à grepserait une option et j’aimerais aussi des exemples de cela; mais je m'intéresse surtout à une brève ligne unique (ou à deux lignes uniques, illustrant différentes manières d'atteindre le même objectif de ligne de commande), simplement à l' aide de find.

ps: Trouver des fichiers sous Linux et exclure des répertoires spécifiques semble étroitement lié, mais a) n'est pas encore accepté et b) est lié-mais-différent-et-distinct, mais c) peut être une source d'inspiration et permettre de mettre le doigt sur la confusion!

Modifier

find . \( ! -regex '.*/\..*' \) -type f -name "whatever", travaux. La regex recherche "n'importe quoi, puis une barre oblique, puis un point, puis n'importe quoi" (c'est-à-dire tous les fichiers et dossiers cachés, y compris leurs sous-dossiers) et le "!" nie la regex.

Ceci imprime tous les fichiers qui sont les descendants de votre répertoire, en ignorant les fichiers et répertoires cachés:

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

Donc, si vous cherchez un fichier avec some textson nom et que vous voulez ignorer les fichiers et répertoires cachés, lancez:

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

Explication:

L' -pathoption run vérifie qu'un modèle correspond à la chaîne de chemin d'accès complète. *est un caractère générique, /un séparateur de répertoire, \.un point (il doit être échappé pour éviter toute signification spéciale) et *un autre caractère générique. -notsignifie que ne sélectionnez pas les fichiers correspondant à ce test.

Je ne pense pas que ce findsoit assez intelligent pour éviter de rechercher récursivement les répertoires cachés dans la commande précédente, aussi si vous avez besoin de rapidité, utilisez -pruneplutôt, comme ceci:

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

C'est l'un des rares moyens d'exclure les fichiers de points qui fonctionnent également correctement sous BSD, Mac et Linux:

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

• $PWD affiche le chemin complet du répertoire actuel pour que le chemin ne commence pas par ./
• -name ".*" -prune correspond à tous les fichiers ou répertoires qui commencent par un point, puis ne descendent pas
• -o -printsignifie imprimer le nom du fichier si l'expression précédente ne correspond à rien. L'utilisation de -printou -print0empêche toutes les autres expressions de s'imprimer par défaut.

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

Exclut tous les répertoires cachés et les fichiers cachés sous $ DIR

^{La réponse que j'avais initialement publiée en tant que "modification" de ma question initiale ci-dessus:}

find . \( ! -regex '.*/\..*' \) -type f -name "whatever", travaux. La regex recherche "n'importe quoi, puis une barre oblique, puis un point, puis n'importe quoi" (c'est-à-dire tous les fichiers et dossiers cachés, y compris leurs sous-dossiers) et le "!" nie la regex.

Vous n'êtes pas obligé d'utiliser findpour cela. Utilisez simplement globstar dans shell it-self, comme ceci:

echo **/*foo*

ou:

ls **/*foo*

où **/représente n'importe quel dossier de manière récursive et *foo*n'importe quel fichier qui a fooson nom.

Par défaut, using lsimprimera les noms de fichiers à l’exclusion des fichiers et répertoires cachés.

Si vous n'avez pas activé la fonction de recherche, faites-le en shopt -s globstar.

^{Remarque: une nouvelle option de globbing fonctionne dans les shell Bash 4, zsh et similaires.}

Exemple:

$ 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 réponse de @ Flimm est bonne, en particulier parce qu'elle empêche la recherche de descendre dans des répertoires cachés . Je préfère cette simplification:

Généralement pour exclure tous les chemins cachés (fichiers normaux, répertoires, etc.):

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

Par exemple, en utilisant votre répertoire de travail comme point de départ et -name '*some text*'comme expression:

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

Contrairement à ce que suggère la réponse de @ Flimm, il n’ya pas de fichiers cachés ni de répertoires cachés. L' -path '*/.*'expression est vraie pour tout chemin (fichiers réguliers, répertoires, etc.) qui a un .immédiatement après votre séparateur de fichiers, /. Donc, cette ligne va élaguer les fichiers cachés et les répertoires.

Autoriser les fichiers cachés tout en excluant les répertoires cachés est le cas qui nécessite un filtre supplémentaire. C’est là que vous incluez -type ddans l’expression à élaguer.

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

Par exemple:

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

Dans ce cas, il -type d -path '*/.*'s’agit trueuniquement de répertoires et seuls les répertoires sont élagués.

finda des commutateurs logiques ordonnés tels que -andet -notvous pouvez les utiliser à votre avantage pour trouver un fichier correspondant avec deux règles comme ceci:

$ 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

Comme vous pouvez le voir, findutilise deux règles -name '*hidden_file*'et -and \( -not -name ".*" \)de trouver les noms de fichiers qui correspondent à deux conditions - le nom de fichier avec hidden_fileen elle , mais sans point de premier plan. Notez les barres obliques devant les parenthèses - elles sont utilisées pour définir les parenthèses en tant findqu'arguments plutôt que pour définir un sous-shell (c'est ce que signifient les parenthèses sinon sans barres obliques)

$ 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

Remarques:

• . : dossier en cours
• supprimer -maxdepth 1pour rechercher récursivement
• -type f: recherche de fichiers, pas de répertoires ( d)
• -not -path '*/\.*' : ne pas revenir .hidden_files
• sed 's/^\.\///g': supprimer le préfixe ./de la liste des résultats