Comment puis-je compter les fichiers avec une extension particulière et les répertoires dans lesquels ils se trouvent?

Je veux savoir combien de fichiers normaux ont l'extension .cdans une grande structure de répertoires complexes, et aussi combien de répertoires ces fichiers sont répartis sur. La sortie que je veux est juste ces deux nombres.

J'ai vu cette question sur la façon d'obtenir le nombre de fichiers, mais je dois également connaître le nombre de répertoires dans lesquels se trouvent les fichiers.

• Mes noms de fichiers (y compris les répertoires) peuvent avoir n'importe quel caractère; ils peuvent commencer par .ou -et avoir des espaces ou des nouvelles lignes.
• Je pourrais avoir des liens symboliques dont les noms se terminent par .c, et des liens symboliques vers des répertoires. Je ne veux pas que les liens symboliques soient suivis ou comptés, ou je veux au moins savoir si et quand ils sont comptés.
• La structure du répertoire a plusieurs niveaux et le répertoire de niveau supérieur (le répertoire de travail) contient au moins un .cfichier.

J'ai écrit à la hâte quelques commandes dans le shell (Bash) pour les compter moi-même, mais je ne pense pas que le résultat soit exact ...

shopt -s dotglob
shopt -s globstar
mkdir out
for d in **/; do
     find "$d" -maxdepth 1 -type f -name "*.c" >> out/$(basename "$d")
done
ls -1Aq out | wc -l
cat out/* | wc -l

Cela génère des plaintes concernant les redirections ambiguës, des fichiers manquants dans le répertoire en cours et déclenche des caractères spéciaux (par exemple, la sortie redirigée findaffiche les nouvelles lignes dans les noms de fichiers ) et écrit tout un tas de fichiers vides (oups).

Comment puis-je énumérer de manière fiable mes .cfichiers et leurs répertoires contenant?

Au cas où cela aiderait, voici quelques commandes pour créer une structure de test avec de mauvais noms et des liens symboliques:

mkdir -p cfiles/{1..3}/{a..b} && cd cfiles
mkdir space\ d
touch -- i.c -.c bad\ .c 'terrible
.c' not-c .hidden.c
for d in space\ d 1 2 2/{a..b} 3/b; do cp -t "$d" -- *.c; done
ln -s 2 dirlink
ln -s 3/b/i.c filelink.c

Dans la structure résultante, 7 répertoires contiennent des .cfichiers et 29 fichiers normaux se terminent par .c(si dotglobest désactivé lorsque les commandes sont exécutées) (si j'ai mal compté, faites-le moi savoir). Ce sont les chiffres que je veux.

N'hésitez pas à ne pas utiliser ce test en particulier.

_{NB: Les réponses dans n'importe quel shell ou autre langue seront testées et appréciées par moi. Si je dois installer de nouveaux packages, pas de problème. Si vous connaissez une solution GUI, je vous encourage à la partager (mais je n'irai peut-être pas jusqu'à installer un DE complet pour la tester) :) J'utilise Ubuntu MATE 17.10.}

Je n'ai pas examiné la sortie avec des liens symboliques mais:

find . -type f -iname '*.c' -printf '%h\0' |
  sort -z |
  uniq -zc |
  sed -zr 's/([0-9]) .*/\1 1/' |
  tr '\0' '\n' |
  awk '{f += $1; d += $2} END {print f, d}'

• La findcommande imprime le nom du répertoire de chaque .cfichier trouvé.
• sort | uniq -c will nous indique le nombre de fichiers dans chaque répertoire (le sort peut être inutile ici, ne sais pas)
• avec sed, je remplace le nom du répertoire par 1, éliminant ainsi tous les caractères étranges possibles, avec juste le nombre et1 reste
• me permettant de convertir en sortie séparée par des sauts de ligne avec tr
• que je résume ensuite avec awk, pour obtenir le nombre total de fichiers et le nombre de répertoires qui contenaient ces fichiers. Notez dqu'ici est essentiellement le même que NR. J'aurais pu omettre l'insertion 1dans la sedcommande, et juste imprimer NRici, mais je pense que c'est un peu plus clair.

Jusqu'au tr, les données sont délimitées par NUL, à l'abri de tous les noms de fichiers valides.

Avec zsh et bash, vous pouvez utiliser printf %qpour obtenir une chaîne entre guillemets, qui ne contiendrait pas de retour à la ligne. Donc, vous pourriez peut-être faire quelque chose comme:

shopt -s globstar dotglob nocaseglob
printf "%q\n" **/*.c | awk -F/ '{NF--; f++} !c[$0]++{d++} END {print f, d}'

Cependant, même s'il **n'est pas censé se développer pour les liens symboliques vers les répertoires , je n'ai pas pu obtenir la sortie souhaitée sur bash 4.4.18 (1) (Ubuntu 16.04).

$ shopt -s globstar dotglob nocaseglob
$ printf "%q\n" ./**/*.c | awk -F/ '{NF--; f++} !c[$0]++{d++} END {print f, d}'
34 15
$ echo $BASH_VERSION
4.4.18(1)-release

Mais zsh a bien fonctionné, et la commande peut être simplifiée:

$ printf "%q\n" ./**/*.c(D.:h) | awk '!c[$0]++ {d++} END {print NR, d}'
29 7

Dpermet à ce glob de sélectionner des fichiers de points, .sélectionne des fichiers normaux (donc pas des liens symboliques), et :himprime uniquement le chemin du répertoire et non le nom du fichier (comme findle sien %h) (voir les sections sur la génération de nom de fichier et les modificateurs ). Donc, avec la commande awk, nous avons juste besoin de compter le nombre de répertoires uniques qui apparaissent, et le nombre de lignes est le nombre de fichiers.

Python a os.walk, ce qui rend des tâches comme celle-ci faciles, intuitives et automatiquement robustes même face à des noms de fichiers étranges tels que ceux qui contiennent des caractères de nouvelle ligne. Ce script Python 3, que j'avais initialement publié dans le chat , est destiné à être exécuté dans le répertoire actuel (mais il n'a pas besoin d'être situé dans le répertoire actuel, et vous pouvez changer le chemin vers lequel il passe os.walk):

#!/usr/bin/env python3

import os

dc = fc = 0
for _, _, fs in os.walk('.'):
    c = sum(f.endswith('.c') for f in fs)
    if c:
        dc += 1
        fc += c
print(dc, fc)

Cela affiche le nombre de répertoires contenant directement au moins un fichier dont le nom se termine .c, suivi d'un espace, suivi du nombre de fichiers dont le nom se termine .c. Les fichiers "masqués" - c'est-à-dire les fichiers dont le nom commence par - .sont inclus et les répertoires masqués sont parcourus de la même manière.

os.walktraverse récursivement une hiérarchie de répertoires. Il énumère tous les répertoires qui sont accessibles de manière récursive à partir du point de départ que vous lui donnez, fournissant des informations sur chacun d'eux sous la forme d'un tuple de trois valeurs,root, dirs, files . Pour chaque répertoire vers lequel il passe (y compris le premier dont vous lui donnez le nom):

• rootcontient le chemin d'accès de ce répertoire. Notez que ceci est totalement sans rapport avec « répertoire racine » du système /(et sans rapport /root) mais il serait aller à ceux si vous commencez là. Dans ce cas, rootcommence au chemin. --ie, le répertoire courant - et va partout en dessous.
• dirscontient une liste des chemins d'accès de tous les sous - répertoires du répertoire dont le nom est actuellement conservé root.
• filescontient une liste des chemins d'accès de tous les fichiers qui résident dans le répertoire dont le nom est actuellement conservé rootmais qui ne sont pas eux-mêmes des répertoires. Notez que cela inclut d'autres types de fichiers que les fichiers normaux, y compris les liens symboliques, mais il semble que vous ne vous attendiez pas à ce que de telles entrées se terminent par.c et que vous souhaitiez en voir d'autres.

Dans ce cas, je n'ai qu'à examiner le troisième élément du tuple files(que j'appelle fsdans le script). Comme la findcommande, Python os.walktraverse pour moi des sous-répertoires; la seule chose que je dois inspecter moi-même est le nom des fichiers que chacun d'eux contient. Contrairement à la findcommande, cependant, os.walkme fournit automatiquement une liste de ces noms de fichiers.

Ce script ne suit pas de liens symboliques. Vous ne voulez probablement pas que les liens symboliques soient suivis pour une telle opération, car ils pourraient former des cycles, et parce que même s'il n'y a pas de cycles, les mêmes fichiers et répertoires peuvent être parcourus et comptés plusieurs fois s'ils sont accessibles via différents liens symboliques.

Si vous avez déjà voulu os.walksuivre des liens symboliques - ce que vous ne feriez pas habituellement - alors vous pouvez y passer followlinks=true. Autrement dit, au lieu d'écrire, os.walk('.')vous pourriez écrire os.walk('.', followlinks=true). Je réitère que vous voudriez rarement cela, en particulier pour une tâche comme celle-ci où vous énumérez récursivement une structure de répertoires entière, quelle que soit sa taille, et en comptant tous les fichiers qui répondent à certaines exigences.

Rechercher + Perl:

$ find . -type f -iname '*.c' -printf '%h\0' | 
    perl -0 -ne '$k{$_}++; }{ print scalar keys %k, " $.\n" '
7 29

Explication

La findcommande trouvera tous les fichiers normaux (donc pas de liens symboliques ou de répertoires), puis affichera le nom du répertoire dans lequel ils se trouvent ( %h) suivi de \0.

• perl -0 -ne: lire l'entrée ligne par ligne ( -n) et appliquer le script donné par -eà chaque ligne. Le -0définit le séparateur de ligne d'entrée sur \0afin que nous puissions lire une entrée délimitée par des valeurs nulles.
• $k{$_}++: $_est une variable spéciale qui prend la valeur de la ligne courante. Ceci est utilisé comme clé du hachage %k , dont les valeurs sont le nombre de fois où chaque ligne d'entrée (nom du répertoire) a été vue.
• }{: il s'agit d'un raccourci pour écrire END{}. Toutes les commandes après le }{seront exécutées une fois, une fois toutes les entrées traitées.
• print scalar keys %k, " $.\n": keys %kretourne un tableau des clés dans le hachage %k. scalar keys %kdonne le nombre d'éléments dans ce tableau, le nombre de répertoires vus. Ceci est imprimé avec la valeur actuelle de $., une variable spéciale qui contient le numéro de ligne d'entrée actuel. Comme cela est exécuté à la fin, le numéro de ligne d'entrée actuel sera le numéro de la dernière ligne, donc le nombre de lignes vues jusqu'à présent.

Vous pouvez étendre la commande perl à ceci, pour plus de clarté:

find  . -type f -iname '*.c' -printf '%h\0' | 
    perl -0 -e 'while($line = <STDIN>){
                    $dirs{$line}++; 
                    $tot++;
                } 
                $count = scalar keys %dirs; 
                print "$count $tot\n" '

Voici ma suggestion:

#!/bin/bash
tempfile=$(mktemp)
find -type f -name "*.c" -prune >$tempfile
grep -c / $tempfile
sed 's_[^/]*$__' $tempfile | sort -u | grep -c /

Ce script court crée un fichier temporaire, trouve tous les fichiers dans et sous le répertoire courant se terminant par .cet écrit la liste dans le fichier temporaire. grepest ensuite utilisé pour compter les fichiers (après Comment puis-je obtenir un nombre de fichiers dans un répertoire à l'aide de la ligne de commande? ) deux fois: La deuxième fois, les répertoires répertoriés plusieurs fois sont supprimés à l'aide de la suppression des sort -unoms de fichier de chaque ligne à l'aide de sed.

Cela fonctionne également correctement avec les nouvelles lignes dans les noms de fichiers: grep -c / ne compte que les lignes avec une barre oblique et ne considère donc que la première ligne d'un nom de fichier multiligne dans la liste.

Production

$ tree
.
├── 1
│   ├── 1
│   │   ├── test2.c
│   │   └── test.c
│   └── 2
│       └── test.c
└── 2
    ├── 1
    │   └── test.c
    └── 2

$ tempfile=$(mktemp);find -type f -name "*.c" -prune >$tempfile;grep -c / $tempfile;sed 's_[^/]*$__' $tempfile | sort -u | grep -c /
4
3

Petit shellscript

Je suggère un petit shellscript bash avec deux lignes de commande principales (et une variable filetype pour faciliter le changement afin de rechercher d'autres types de fichiers).

Il ne recherche pas ou dans les liens symboliques, seulement les fichiers normaux.

#!/bin/bash

filetype=c
#filetype=pdf

# count the 'filetype' files

find -type f -name "*.$filetype" -ls|sed 's#.* \./##'|wc -l | tr '\n' ' '

# count directories containing 'filetype' files

find -type d -exec bash -c "ls -AF '{}'|grep -e '\.'${filetype}$ -e '\.'${filetype}'\*'$ > /dev/null && echo '{} contains file(s)'" \;|grep 'contains file(s)$'|wc -l

Shellscript verbeux

Ceci est une version plus verbeuse qui prend également en compte les liens symboliques,

#!/bin/bash

filetype=c
#filetype=pdf

# counting the 'filetype' files

echo -n "number of $filetype files in the current directory tree: "
find -type f -name "*.$filetype" -ls|sed 's#.* \./##'|wc -l

echo -n "number of $filetype symbolic links in the current directory tree: "
find -type l -name "*.$filetype" -ls|sed 's#.* \./##'|wc -l
echo -n "number of $filetype normal files in the current directory tree: "
find -type f -name "*.$filetype" -ls|sed 's#.* \./##'|wc -l
echo -n "number of $filetype symbolic links in the current directory tree including linked directories: "
find -L -type f -name "*.$filetype" -ls 2> /tmp/c-counter |sed 's#.* \./##' | wc -l; cat /tmp/c-counter; rm /tmp/c-counter

# list directories with and without 'filetype' files (good for manual checking; comment away after test)
echo '---------- list directories:'
 find    -type d -exec bash -c "ls -AF '{}'|grep -e '\.'${filetype}$ -e '\.'${filetype}'\*'$ > /dev/null && echo '{} contains file(s)' || echo '{} empty'" \;
echo ''
#find -L -type d -exec bash -c "ls -AF '{}'|grep -e '\.'${filetype}$ -e '\.'${filetype}'\*'$ > /dev/null && echo '{} contains file(s)' || echo '{} empty'" \;

# count directories containing 'filetype' files

echo -n "number of directories with $filetype files: "
find -type d -exec bash -c "ls -AF '{}'|grep -e '\.'${filetype}$ -e '\.'${filetype}'\*'$ > /dev/null && echo '{} contains file(s)'" \;|grep 'contains file(s)$'|wc -l

# list and count directories including symbolic links, containing 'filetype' files
echo '---------- list all directories including symbolic links:'
find -L -type d -exec bash -c "ls -AF '{}' |grep -e '\.'${filetype}$ -e '\.'${filetype}'\*'$ > /dev/null && echo '{} contains file(s)' || echo '{} empty'" \;
echo ''
echo -n "number of directories (including symbolic links) with $filetype files: "
find -L -type d -exec bash -c "ls -AF '{}'|grep -e '\.'${filetype}$ -e '\.'${filetype}'\*'$ > /dev/null && echo '{} contains file(s)'" \; 2>/dev/null |grep 'contains file(s)$'|wc -l

# count directories without 'filetype' files (good for checking; comment away after test)

echo -n "number of directories without $filetype files: "
find -type d -exec bash -c "ls -AF '{}'|grep -e '\.'${filetype}$ -e '\.'${filetype}'\*'$ > /dev/null || echo '{} empty'" \;|grep 'empty$'|wc -l

Sortie test

À partir d'un court shellscript:

$ ./ccntr 
29 7

Du shellscript verbeux:

$ LANG=C ./c-counter
number of c files in the current directory tree: 29
number of c symbolic links in the current directory tree: 1
number of c normal files in the current directory tree: 29
number of c symbolic links in the current directory tree including linked directories: 42
find: './cfiles/2/2': Too many levels of symbolic links
find: './cfiles/dirlink/2': Too many levels of symbolic links
---------- list directories:
. empty
./cfiles contains file(s)
./cfiles/2 contains file(s)
./cfiles/2/b contains file(s)
./cfiles/2/a contains file(s)
./cfiles/3 empty
./cfiles/3/b contains file(s)
./cfiles/3/a empty
./cfiles/1 contains file(s)
./cfiles/1/b empty
./cfiles/1/a empty
./cfiles/space d contains file(s)

number of directories with c files: 7
---------- list all directories including symbolic links:
. empty
./cfiles contains file(s)
./cfiles/2 contains file(s)
find: './cfiles/2/2': Too many levels of symbolic links
./cfiles/2/b contains file(s)
./cfiles/2/a contains file(s)
./cfiles/3 empty
./cfiles/3/b contains file(s)
./cfiles/3/a empty
./cfiles/dirlink empty
find: './cfiles/dirlink/2': Too many levels of symbolic links
./cfiles/dirlink/b contains file(s)
./cfiles/dirlink/a contains file(s)
./cfiles/1 contains file(s)
./cfiles/1/b empty
./cfiles/1/a empty
./cfiles/space d contains file(s)

number of directories (including symbolic links) with c files: 9
number of directories without c files: 5
$ 

Doublure simple Perl one:

perl -MFile::Find=find -le'find(sub{/\.c\z/ and -f and $c{$File::Find::dir}=++$c}, @ARGV); print 0 + keys %c, " $c"' dir1 dir2

Ou plus simple avec la findcommande:

find dir1 dir2 -type f -name '*.c' -printf '%h\0' | perl -l -0ne'$c{$_}=1}{print 0 + keys %c, " $."'

Si vous aimez le golf et que vous avez un Perl récent (comme il y a moins de dix ans):

perl -MFile::Find=find -E'find(sub{/\.c$/&&-f&&($c{$File::Find::dir}=++$c)},".");say 0+keys%c," $c"'

find -type f -name '*.c' -printf '%h\0'|perl -0nE'$c{$_}=1}{say 0+keys%c," $."'

Pensez à utiliser la locatecommande qui est beaucoup plus rapide que la findcommande.

Exécution sur des données de test

$ sudo updatedb # necessary if files in focus were added `cron` daily.
$ printf "Number Files: " && locate -0r "$PWD.*\.c$" | xargs -0 -I{} sh -c 'test ! -L "$1" && echo "regular file"' _  {} | wc -l &&  printf "Number Dirs.: " && locate -r "$PWD.*\.c$" | sed 's%/[^/]*$%/%' | uniq -cu | wc -l
Number Files: 29
Number Dirs.: 7

Merci à Muru pour sa réponse pour m'aider à supprimer les liens symboliques du nombre de fichiers dans la réponse Unix et Linux .

Merci à Terdon pour sa réponse $PWD(non dirigée contre moi) dans la réponse Unix et Linux .

Réponse originale ci-dessous référencée par des commentaires

Forme courte:

$ cd /
$ sudo updatedb
$ printf "Number Files: " && locate -cr "$PWD.*\.c$"
Number Files: 3523
$ printf "Number Dirs.: " && locate -r "$PWD.*\.c$" | sed 's%/[^/]*$%/%' | uniq -c | wc -l 
Number Dirs.: 648

• sudo updatedbMettre à jour la base de données utilisée par la locatecommande si les .cfichiers ont été créés aujourd'hui ou si vous les avez supprimés .caujourd'hui.
• locate -cr "$PWD.*\.c$"localisez tous les .cfichiers dans le répertoire courant et ses enfants ( $PWD). Au lieu d'imprimer les noms de fichiers et d'imprimer le nombre avec un -cargument. Le rspécifie l'expression régulière au lieu de la *pattern*correspondance par défaut, ce qui peut donner trop de résultats.
• locate -r "$PWD.*\.c$" | sed 's%/[^/]*$%/%' | uniq -c | wc -l. Recherchez tous les *.cfichiers dans le répertoire actuel et ci-dessous. Supprimez le nom du fichier seden ne laissant que le nom du répertoire. Comptez le nombre de fichiers dans chaque répertoire en utilisant uniq -c. Comptez le nombre de répertoires avec wc -l.

Commencez au répertoire actuel avec une ligne

$ cd /usr/src
$ printf "Number Files: " && locate -cr "$PWD.*\.c$" &&  printf "Number Dirs.: " && locate -r "$PWD.*\.c$" | sed 's%/[^/]*$%/%' | uniq -c | wc -l
Number Files: 3430
Number Dirs.: 624

Notez comment le nombre de fichiers et le nombre de répertoires ont changé. Je crois que tous les utilisateurs ont le /usr/srcrépertoire et peuvent exécuter les commandes ci-dessus avec différents nombres en fonction du nombre de noyaux installés.

Forme longue:

Le formulaire long comprend le temps afin que vous puissiez voir à quel point la vitesse locateest terminée find. Même si vous devez l'exécuter, sudo updatedbil est beaucoup plus rapide qu'un simple find /.

───────────────────────────────────────────────────────────────────────────────────────────
rick@alien:~/Downloads$ sudo time updatedb
0.58user 1.32system 0:03.94elapsed 48%CPU (0avgtext+0avgdata 7568maxresident)k
48inputs+131920outputs (1major+3562minor)pagefaults 0swaps
───────────────────────────────────────────────────────────────────────────────────────────
rick@alien:~/Downloads$ time (printf "Number Files: " && locate -cr $PWD".*\.c$")
Number Files: 3523

real    0m0.775s
user    0m0.766s
sys     0m0.012s
───────────────────────────────────────────────────────────────────────────────────────────
rick@alien:~/Downloads$ time (printf "Number Dirs.: " && locate -r $PWD".*\.c$" | sed 's%/[^/]*$%/%' | uniq -c | wc -l) 
Number Dirs.: 648

real    0m0.778s
user    0m0.788s
sys     0m0.027s
───────────────────────────────────────────────────────────────────────────────────────────

Remarque: il s'agit de tous les fichiers sur TOUS les lecteurs et partitions. c'est-à-dire que nous pouvons également rechercher des commandes Windows:

$ time (printf "Number Files: " && locate *.exe -c)
Number Files: 6541

real    0m0.946s
user    0m0.761s
sys     0m0.060s
───────────────────────────────────────────────────────────────────────────────────────────
rick@alien:~/Downloads$ time (printf "Number Dirs.: " && locate *.exe | sed 's%/[^/]*$%/%' | uniq -c | wc -l) 
Number Dirs.: 3394

real    0m0.942s
user    0m0.803s
sys     0m0.092s

J'ai trois partitions Windows 10 NTFS montées automatiquement dans /etc/fstab . Soyez conscient de localiser sait tout!

Compte intéressant:

$ time (printf "Number Files: " && locate / -c &&  printf "Number Dirs.: " && locate / | sed 's%/[^/]*$%/%' | uniq -c | wc -l)
Number Files: 1637135
Number Dirs.: 286705

real    0m15.460s
user    0m13.471s
sys     0m2.786s

Il faut 15 secondes pour compter 1 637 135 fichiers dans 286 705 répertoires. YMMV.

Pour une ventilation détaillée de locatela gestion des regex de la commande (il semble que ce ne soit pas nécessaire dans ce Q&R mais utilisé juste au cas où), veuillez lire ceci: Utilisez "Locate" sous un répertoire spécifique?

Lecture supplémentaire d'articles récents:

• Tecmint - 10 exemples pratiques de commandes de localisation pour les débutants Linux
• HowtoForge - Commande Linux Locate pour les débutants (8 exemples)
• Computer Hope - Commande de localisation Linux