J'essaie de trouver le meilleur moyen de trouver le nombre de fichiers dans un répertoire particulier lorsqu'il y a un très grand nombre de fichiers (> 100 000).

Lorsqu'il y a autant de fichiers, l'exécution ls | wc -lprend beaucoup de temps. Je pense que c'est parce qu'il renvoie les noms de tous les fichiers. J'essaie de prendre le moins possible d'E / S disque.

J'ai essayé en vain des scripts shell et Perl. Des idées?

Par défaut, lstrie les noms, ce qui peut prendre un certain temps s'il y en a beaucoup. De plus, il n'y aura pas de sortie tant que tous les noms ne seront pas lus et triés. Utilisez l' ls -foption pour désactiver le tri.

ls -f | wc -l

Notez que cela permettra aussi -a, donc ., ..et d' autres fichiers commençant par .seront comptés.

Le moyen le plus rapide est un programme spécialement conçu, comme celui-ci:

#include <stdio.h>
#include <dirent.h>

int main(int argc, char *argv[]) {
    DIR *dir;
    struct dirent *ent;
    long count = 0;

    dir = opendir(argv[1]);

    while((ent = readdir(dir)))
            ++count;

    closedir(dir);

    printf("%s contains %ld files\n", argv[1], count);

    return 0;
}

De mes tests sans égard au cache, j'ai exécuté chacun de ces environ 50 fois chacun sur le même répertoire, encore et encore, pour éviter le biais des données basées sur le cache, et j'ai obtenu à peu près les chiffres de performance suivants (en temps réel):

ls -1  | wc - 0:01.67
ls -f1 | wc - 0:00.14
find   | wc - 0:00.22
dircnt | wc - 0:00.04

Ce dernier,, dircntest le programme compilé à partir de la source ci-dessus.

MODIFIER 2016-09-26

En raison de la demande générale, j'ai réécrit ce programme pour qu'il soit récursif, il tombera donc dans les sous-répertoires et continuera à compter les fichiers et les répertoires séparément.

Comme il est clair que certaines personnes veulent savoir comment faire tout cela, j'ai beaucoup de commentaires dans le code pour essayer de rendre évident ce qui se passe. Je l'ai écrit et testé sur Linux 64 bits, mais cela devrait fonctionner sur n'importe quel système compatible POSIX, y compris Microsoft Windows. Les rapports de bogue sont les bienvenus; Je suis heureux de mettre à jour ceci si vous ne pouvez pas le faire fonctionner sur votre AIX ou OS / 400 ou autre.

Comme vous pouvez le voir, c'est beaucoup plus compliqué que l'original et forcément: au moins une fonction doit exister pour être appelée de manière récursive à moins que vous ne souhaitiez que le code devienne très complexe (par exemple gérer une pile de sous-répertoires et traiter cela en une seule boucle). Comme nous devons vérifier les types de fichiers, les différences entre les différents systèmes d'exploitation, les bibliothèques standard, etc. entrent en jeu, j'ai donc écrit un programme qui essaie d'être utilisable sur n'importe quel système où il compilera.

Il y a très peu de vérification des erreurs et la countfonction elle-même ne signale pas vraiment les erreurs. Les seuls appels qui peuvent vraiment échouer sont opendiret stat(si vous n'avez pas de chance et que votre système direntcontient déjà le type de fichier). Je ne suis pas paranoïaque à propos de la vérification de la longueur totale des chemins des sous-répertoires, mais théoriquement, le système ne devrait autoriser aucun nom de chemin plus long que PATH_MAX. S'il y a des soucis, je peux résoudre ça, mais c'est juste plus de code qui doit être expliqué à quelqu'un qui apprend à écrire C. Ce programme est destiné à être un exemple de la façon de plonger dans les sous-répertoires de manière récursive.

#include <stdio.h>
#include <dirent.h>
#include <string.h>
#include <stdlib.h>
#include <limits.h>
#include <sys/stat.h>

#if defined(WIN32) || defined(_WIN32) 
#define PATH_SEPARATOR '\\' 
#else
#define PATH_SEPARATOR '/' 
#endif

/* A custom structure to hold separate file and directory counts */
struct filecount {
  long dirs;
  long files;
};

/*
 * counts the number of files and directories in the specified directory.
 *
 * path - relative pathname of a directory whose files should be counted
 * counts - pointer to struct containing file/dir counts
 */
void count(char *path, struct filecount *counts) {
    DIR *dir;                /* dir structure we are reading */
    struct dirent *ent;      /* directory entry currently being processed */
    char subpath[PATH_MAX];  /* buffer for building complete subdir and file names */
    /* Some systems don't have dirent.d_type field; we'll have to use stat() instead */
#if !defined ( _DIRENT_HAVE_D_TYPE )
    struct stat statbuf;     /* buffer for stat() info */
#endif

/* fprintf(stderr, "Opening dir %s\n", path); */
    dir = opendir(path);

    /* opendir failed... file likely doesn't exist or isn't a directory */
    if(NULL == dir) {
        perror(path);
        return;
    }

    while((ent = readdir(dir))) {
      if (strlen(path) + 1 + strlen(ent->d_name) > PATH_MAX) {
          fprintf(stdout, "path too long (%ld) %s%c%s", (strlen(path) + 1 + strlen(ent->d_name)), path, PATH_SEPARATOR, ent->d_name);
          return;
      }

/* Use dirent.d_type if present, otherwise use stat() */
#if defined ( _DIRENT_HAVE_D_TYPE )
/* fprintf(stderr, "Using dirent.d_type\n"); */
      if(DT_DIR == ent->d_type) {
#else
/* fprintf(stderr, "Don't have dirent.d_type, falling back to using stat()\n"); */
      sprintf(subpath, "%s%c%s", path, PATH_SEPARATOR, ent->d_name);
      if(lstat(subpath, &statbuf)) {
          perror(subpath);
          return;
      }

      if(S_ISDIR(statbuf.st_mode)) {
#endif
          /* Skip "." and ".." directory entries... they are not "real" directories */
          if(0 == strcmp("..", ent->d_name) || 0 == strcmp(".", ent->d_name)) {
/*              fprintf(stderr, "This is %s, skipping\n", ent->d_name); */
          } else {
              sprintf(subpath, "%s%c%s", path, PATH_SEPARATOR, ent->d_name);
              counts->dirs++;
              count(subpath, counts);
          }
      } else {
          counts->files++;
      }
    }

/* fprintf(stderr, "Closing dir %s\n", path); */
    closedir(dir);
}

int main(int argc, char *argv[]) {
    struct filecount counts;
    counts.files = 0;
    counts.dirs = 0;
    count(argv[1], &counts);

    /* If we found nothing, this is probably an error which has already been printed */
    if(0 < counts.files || 0 < counts.dirs) {
        printf("%s contains %ld files and %ld directories\n", argv[1], counts.files, counts.dirs);
    }

    return 0;
}

MODIFIER 2017-01-17

J'ai incorporé deux changements suggérés par @FlyingCodeMonkey:

1. Utilisez à la lstatplace de stat. Cela changera le comportement du programme si vous avez des répertoires liés par un lien symbolique dans le répertoire que vous analysez. Le comportement précédent était que le sous-répertoire (lié) verrait son nombre de fichiers ajouté au nombre global; le nouveau comportement est que le répertoire lié comptera comme un seul fichier et que son contenu ne sera pas compté.
2. Si le chemin d'un fichier est trop long, un message d'erreur sera émis et le programme s'arrêtera.

MODIFIER 2017-06-29

Avec un peu de chance, ce sera la dernière modification de cette réponse :)

J'ai copié ce code dans un référentiel GitHub pour faciliter l'obtention du code (au lieu de copier / coller, vous pouvez simplement télécharger la source ), et il est plus facile pour quiconque de suggérer une modification en soumettant un tirage -request de GitHub.

La source est disponible sous Apache License 2.0. Patchs ^* bienvenus!

• "patch" est ce que les personnes âgées comme moi appellent une "pull request".

Avez-vous essayé de trouver? Par exemple:

find . -name "*.ext" | wc -l

find, ls et perl testés sur 40000 fichiers: même vitesse (même si je n'ai pas essayé de vider le cache):

[user@server logs]$ time find . | wc -l
42917

real    0m0.054s
user    0m0.018s
sys     0m0.040s
[user@server logs]$ time /bin/ls -f | wc -l
42918

real    0m0.059s
user    0m0.027s
sys     0m0.037s

et avec perl opendir / readdir, en même temps:

[user@server logs]$ time perl -e 'opendir D, "."; @files = readdir D; closedir D; print scalar(@files)."\n"'
42918

real    0m0.057s
user    0m0.024s
sys     0m0.033s

note: j'ai utilisé / bin / ls -f pour m'assurer de contourner l'option alias qui pourrait ralentir un peu et -f pour éviter l'ordre des fichiers. ls sans -f est deux fois plus lent que find / perl sauf si ls est utilisé avec -f, cela semble être le même temps:

[user@server logs]$ time /bin/ls . | wc -l
42916

real    0m0.109s
user    0m0.070s
sys     0m0.044s

Je voudrais également avoir un script pour demander directement au système de fichiers sans toutes les informations inutiles.

tests basés sur la réponse de Peter van der Heijden, glenn jackman et mark4o.

Thomas

Vous pouvez modifier la sortie en fonction de vos besoins, mais voici un bash one-liner que j'ai écrit pour compter et rapporter de manière récursive le nombre de fichiers dans une série de répertoires nommés numériquement.

dir=/tmp/count_these/ ; for i in $(ls -1 ${dir} | sort -n) ; { echo "$i => $(find ${dir}${i} -type f | wc -l),"; }

Cela recherche récursivement tous les fichiers (pas les répertoires) dans le répertoire donné et renvoie les résultats dans un format de type hachage. De simples ajustements à la commande find pourraient rendre le type de fichiers que vous cherchez à compter plus spécifique, etc.

Résultats en quelque chose comme ceci:

1 => 38,
65 => 95052,
66 => 12823,
67 => 10572,
69 => 67275,
70 => 8105,
71 => 42052,
72 => 1184,

Étonnamment pour moi, une découverte simple est très comparable à ls -f

> time ls -f my_dir | wc -l
17626

real    0m0.015s
user    0m0.011s
sys     0m0.009s

contre

> time find my_dir -maxdepth 1 | wc -l
17625

real    0m0.014s
user    0m0.008s
sys     0m0.010s

Bien sûr, les valeurs de la troisième décimale décalent un peu chaque fois que vous exécutez l'une de ces dernières, elles sont donc fondamentalement identiques. Notez cependant que cela findrenvoie une unité supplémentaire, car il compte le répertoire lui-même (et, comme mentionné précédemment, ls -fretourne deux unités supplémentaires, car il compte également. Et ..).

Juste en ajoutant ceci par souci d'exhaustivité. La bonne réponse a bien sûr déjà été publiée par quelqu'un d'autre, mais vous pouvez également obtenir un nombre de fichiers et de répertoires avec le programme d'arborescence.

Exécutez la commande tree | tail -n 1pour obtenir la dernière ligne, qui dira quelque chose comme "763 répertoires, 9290 fichiers". Cela compte les fichiers et les dossiers de manière récursive, à l'exclusion des fichiers cachés, qui peuvent être ajoutés avec l'indicateur -a. Pour référence, il a fallu 4,8 secondes sur mon ordinateur pour que tree compte tout mon répertoire personnel, qui était de 24777 répertoires, 238680 fichiers. find -type f | wc -la pris 5,3 secondes, une demi-seconde de plus, donc je pense que tree est assez compétitif en termes de vitesse.

Tant que vous n'avez pas de sous-dossiers, l'arborescence est un moyen rapide et facile de compter les fichiers.

De plus, et uniquement pour le plaisir, vous pouvez utiliser tree | grep '^├'pour afficher uniquement les fichiers / dossiers dans le répertoire actuel - il s'agit essentiellement d'une version beaucoup plus lente de ls.

Nombre de fichiers Linux rapide

Le nombre de fichiers Linux le plus rapide que je connaisse est

locate -c -r '/home'

Il n'est pas nécessaire d'invoquer grep! Mais comme mentionné, vous devriez avoir une nouvelle base de données (mise à jour quotidiennement par un travail cron, ou manuelle parsudo updatedb ).

De l' homme localiser

-c, --count
    Instead  of  writing  file  names on standard output, write the number of matching
    entries only.

De plus, sachez qu'il compte également les répertoires sous forme de fichiers!

BTW: Si vous voulez un aperçu de vos fichiers et répertoires sur votre type de système

locate -S

Il affiche le nombre de répertoires, de fichiers, etc.

Ecrire ceci ici car je n'ai pas assez de points de réputation pour commenter une réponse, mais je suis autorisé à laisser le mien réponse, ce qui n'a pas de sens. En tous cas...

En ce qui concerne la réponse de Christopher Schultz , je suggère de changer stat en lstat et éventuellement d'ajouter une vérification des limites pour éviter un débordement de tampon:

if (strlen(path) + strlen(PATH_SEPARATOR) + strlen(ent->d_name) > PATH_MAX) {
    fprintf(stdout, "path too long (%ld) %s%c%s", (strlen(path) + strlen(PATH_SEPARATOR) + strlen(ent->d_name)), path, PATH_SEPARATOR, ent->d_name);
    return;
}

La suggestion d'utiliser lstat est d'éviter de suivre des liens symboliques qui pourraient conduire à des cycles si un répertoire contient un lien symbolique vers un répertoire parent.

Vous pouvez essayer si l'utilisation de opendir()et readdir()dans Perlest plus rapide. Pour un exemple de ces fonctions, regardez ici

Cette réponse ici est plus rapide que presque tout le reste de cette page pour les très grands répertoires très imbriqués:

https://serverfault.com/a/691372/84703

locate -r '.' | grep -c "^$PWD"

Je suis venu ici en essayant de compter les fichiers dans un ensemble de données de ~ 10K dossiers avec ~ 10K fichiers chacun. Le problème avec de nombreuses approches est qu'elles statuent implicitement 100 millions de fichiers, ce qui prend des années.

J'ai pris la liberté d'étendre l'approche par christopher-schultz afin qu'elle supporte le passage de répertoires via args (son approche récursive utilise également stat).

Mettez ce qui suit dans le fichier dircnt_args.c:

#include <stdio.h>
#include <dirent.h>

int main(int argc, char *argv[]) {
    DIR *dir;
    struct dirent *ent;
    long count;
    long countsum = 0;
    int i;

    for(i=1; i < argc; i++) {
        dir = opendir(argv[i]);
        count = 0;
        while((ent = readdir(dir)))
            ++count;

        closedir(dir);

        printf("%s contains %ld files\n", argv[i], count);
        countsum += count;
    }
    printf("sum: %ld\n", countsum);

    return 0;
}

Après un, gcc -o dircnt_args dircnt_args.cvous pouvez l'invoquer comme ceci:

dircnt_args /your/dirs/*

Sur 100M de fichiers dans 10K dossiers, ce qui précède se termine assez rapidement (~ 5 min pour la première exécution, suivi sur le cache: ~ 23 s).

La seule autre approche qui a terminé en moins d'une heure était ls avec environ 1 min sur le cache: ls -f /your/dirs/* | wc -l. Le décompte est cependant décalé de quelques nouvelles lignes par répertoire ...

Autre que prévu, aucune de mes tentatives n'est findrevenue dans l'heure: - /

Le moyen le plus rapide sur linux (la question est étiquetée comme linux), est d'utiliser l'appel système direct. Voici un petit programme qui compte les fichiers (uniquement, pas de répertoires) dans un répertoire. Vous pouvez compter des millions de fichiers et c'est environ 2,5 fois plus rapide que "ls -f" et environ 1,3 à 1,5 fois plus rapide que la réponse de Christopher Schultz.

#define _GNU_SOURCE
#include <dirent.h>
#include <stdio.h>
#include <fcntl.h>
#include <stdlib.h>
#include <sys/syscall.h>

#define BUF_SIZE 4096

struct linux_dirent {
    long d_ino;
    off_t d_off;
    unsigned short d_reclen;
    char d_name[];
};

int countDir(char *dir) {


    int fd, nread, bpos, numFiles = 0;
    char d_type, buf[BUF_SIZE];
    struct linux_dirent *dirEntry;

    fd = open(dir, O_RDONLY | O_DIRECTORY);
    if (fd == -1) {
        puts("open directory error");
        exit(3);
    }
    while (1) {
        nread = syscall(SYS_getdents, fd, buf, BUF_SIZE);
        if (nread == -1) {
            puts("getdents error");
            exit(1);
        }
        if (nread == 0) {
            break;
        }

        for (bpos = 0; bpos < nread;) {
            dirEntry = (struct linux_dirent *) (buf + bpos);
            d_type = *(buf + bpos + dirEntry->d_reclen - 1);
            if (d_type == DT_REG) {
                // Increase counter
                numFiles++;
            }
            bpos += dirEntry->d_reclen;
        }
    }
    close(fd);

    return numFiles;
}

int main(int argc, char **argv) {

    if (argc != 2) {
        puts("Pass directory as parameter");
        return 2;
    }
    printf("Number of files in %s: %d\n", argv[1], countDir(argv[1]));
    return 0;
}

PS: Ce n'est pas récursif mais vous pouvez le modifier pour y parvenir.

lspasse plus de temps à trier les noms de fichiers, l'utilisation de -fpour désactiver le tri permettra d'économiser un certain temps :

ls -f | wc -l

ou vous pouvez utiliser find:

find . -type f | wc -l

Je me suis rendu compte que ne pas utiliser dans le traitement de la mémoire lorsque vous avez une énorme quantité de données est plus rapide que de "piping" les commandes. J'ai donc enregistré le résultat dans un fichier et après l'avoir analysé

ls -1 /path/to/dir > count.txt && cat count.txt | wc -l

Vous devriez utiliser "getdents" à la place de ls / find

Voici un très bon article qui décrit l'approche getdents.

http://be-n.com/spw/you-can-list-a-million-files-in-a-directory-but-not-with-ls.html

Voici l'extrait:

ls et pratiquement toutes les autres méthodes de listage d'un répertoire (y compris python os.listdir, find.) reposent sur la libc readdir (). Cependant readdir () ne lit que 32K d'entrées de répertoire à la fois, ce qui signifie que si vous avez beaucoup de fichiers dans le même répertoire (c'est-à-dire 500M d'entrées de répertoire), il va falloir un temps incroyablement long pour lire toutes les entrées de répertoire , en particulier sur un disque lent. Pour les répertoires contenant un grand nombre de fichiers, vous devrez creuser plus profondément que les outils qui reposent sur readdir (). Vous devrez utiliser directement l'appel système getdents (), plutôt que les méthodes d'assistance de la libc.

Nous pouvons trouver le code C pour lister les fichiers en utilisant getdents () à partir d' ici :

Il y a deux modifications que vous devrez faire pour lister rapidement tous les fichiers d'un répertoire.

Tout d'abord, augmentez la taille de la mémoire tampon de X à quelque chose comme 5 mégaoctets.

#define BUF_SIZE 1024*1024*5

Puis modifiez la boucle principale où il imprime les informations sur chaque fichier dans le répertoire pour sauter les entrées avec inode == 0. Je l'ai fait en ajoutant

if (dp->d_ino != 0) printf(...);

Dans mon cas, je ne me souciais vraiment que des noms de fichiers dans le répertoire, donc j'ai également réécrit l'instruction printf () pour n'imprimer que le nom de fichier.

if(d->d_ino) printf("%sn ", (char *) d->d_name);

Compilez-le (il n'a pas besoin de bibliothèques externes, donc c'est super simple à faire)

gcc listdir.c -o listdir

Maintenant, cours

./listdir [directory with insane number of files]

Je préfère la commande suivante pour suivre les changements dans le nombre de fichiers dans un répertoire.

watch -d -n 0.01 'ls | wc -l'

La commande garde une fenêtre ouverte pour garder une trace du nombre de fichiers qui se trouvent dans le répertoire avec un taux de rafraîchissement de 0,1 sec.

Les 10 premiers directeurs avec le plus grand nombre de fichiers.

dir=/ ; for i in $(ls -1 ${dir} | sort -n) ; { echo "$(find ${dir}${i} \
    -type f | wc -l) => $i,"; } | sort -nr | head -10