Générer la distribution des tailles de fichiers à partir de l'invite de commande

Cela semble fonctionner plutôt bien :

find . -type f -print0 | xargs -0 ls -l | awk '{size[int(log($5)/log(2))]++}END{for (i in size) printf("%10d %3d\n", 2^i, size[i])}' | sort -n

Sa sortie ressemble à ceci :

         0   1
         8   3
        16   2
        32   2
        64   6
       128   9
       256   9
       512   6
      1024   8
      2048   7
      4096  38
      8192  16
     16384  12
     32768   7
     65536   3
    131072   3
    262144   3
    524288   6
   2097152   2
   4194304   1
  33554432   1
 134217728   4

où le nombre à gauche est la limite inférieure d'une plage allant de cette valeur à deux fois cette valeur et le nombre à droite est le nombre de fichiers dans cette plage.

Basé sur la réponse de Garyjohn, voici un one-liner, qui formate également la sortie en lisible par l'homme :

find . -type f -print0 | xargs -0 ls -l | awk '{ n=int(log($5)/log(2)); if (n<10) { n=10; } size[n]++ } END { for (i in size) printf("%d %d\n", 2^i, size[i]) }' | sort -n | awk 'function human(x) { x[1]/=1024; if (x[1]>=1024) { x[2]++; human(x) } } { a[1]=$1; a[2]=0; human(a); printf("%3d%s: %6d\n", a[1],substr("kMGTEPYZ",a[2]+1,1),$2) }'

En voici la version étendue :

find . -type f -print0                                                   \ 
 | xargs -0 ls -l                                                        \
 | awk '{ n=int(log($5)/log(2));                                         \
          if (n<10) n=10;                                                \
          size[n]++ }                                                    \
      END { for (i in size) printf("%d %d\n", 2^i, size[i]) }'           \
 | sort -n                                                               \ 
 | awk 'function human(x) { x[1]/=1024;                                  \
                            if (x[1]>=1024) { x[2]++;                    \
                                              human(x) } }               \
        { a[1]=$1;                                                       \ 
          a[2]=0;                                                        \
          human(a);                                                      \
          printf("%3d%s: %6d\n", a[1],substr("kMGTEPYZ",a[2]+1,1),$2) }'

Dans le premier awk J'ai défini une taille de fichier minimale pour rassembler tous les fichiers de moins de 1 Ko en un seul endroit. Au deuxième awk , fonction human(x) est défini pour créer une taille lisible par l'homme. Cette partie est basée sur l'une des réponses ici :https://unix.stackexchange.com/questions/44040/a-standard-tool-to-convert-a-byte-count-into-human-kib-mib-etc -like-du-ls1

L'exemple de sortie ressemble à :

  1k:    335
  2k:     16
 32k:      5
128k:     22
  1M:     54
  2M:     11
  4M:     13
  8M:      3

Essayez ceci :

find . -type f -exec ls -lh {} \; | 
 gawk '{match($5,/([0-9.]+)([A-Z]+)/,k); if(!k[2]){print "1K"} \
        else{printf "%.0f%s\n",k[1],k[2]}}' | 
sort | uniq -c | sort -hk 2

SORTIE :

EXPLICATION :

find . -type f -exec ls -lh {} \; :assez simple, recherchez les fichiers dans le répertoire actuel et exécutez ls -lh sur eux
match($5,/([0-9.]+)([A-Z]+)/,k); :cela va extraire la taille du fichier et enregistrer chaque correspondance dans le tableau k .
if(!k[2]){print "1K"} :si k[2] n'est pas défini, la taille du fichier est <1K. Puisque j'imagine que vous ne vous souciez pas de ces petites tailles, le script imprimera 1K pour tous les fichiers dont la taille est <=1K.
else{printf "%.0f%s\n",k[1],k[2]} :si le fichier est supérieur à 1 Ko, arrondissez la taille du fichier à l'entier le plus proche et imprimez avec son modificateur (K, M ou G).
sort | uniq -c :compte les occurrences de chaque ligne (taille du fichier) imprimée.
sort -hk 2 :tri selon le deuxième champ au format lisible par l'homme. Par ici, 7G est trié après 8M .