Какой самый эффективный способ подсчета количества файлов в каталоге?

CentOS 5.9

Я столкнулся с проблемой на днях, когда в каталоге было много файлов. Чтобы посчитать это, я побежалls -l /foo/foo2/ | wc -l

Оказывается, в одном каталоге было более 1 миллиона файлов (длинная история - основная причина исправляется).

Мой вопрос: есть ли более быстрый способ сделать подсчет? Какой самый эффективный способ получить счет?

Краткий ответ:

\ls -afq | wc -l

(Это включает .и .., так что вычтите 2.)

Когда вы перечисляете файлы в каталоге, могут произойти три общие вещи:

1. Перечисление имен файлов в каталоге. Это неизбежно: нет способа подсчитать файлы в каталоге, не перечислив их.
2. Сортировка имен файлов. Подстановочные знаки оболочки и lsкоманда делают это.
3. Вызов statдля получения метаданных о каждой записи каталога, например, является ли он каталогом.

№ 3, безусловно, самый дорогой, потому что он требует загрузки индекса для каждого файла. Для сравнения, все имена файлов, необходимые для # 1, компактно хранятся в нескольких блоках. # 2 тратит некоторое процессорное время, но часто это не прерывает сделки.

Если в именах файлов нет новых строк, простой ls -A | wc -lговорит вам, сколько файлов в каталоге. Помните, что если у вас есть псевдоним для ls, это может вызвать вызов stat(например, ls --colorили вам ls -Fнеобходимо знать тип файла, для которого требуется вызов stat), поэтому из командной строки вызывайте command ls -A | wc -lили \ls -A | wc -lизбегайте псевдонима.

Если в имени файла есть новые строки, то будут ли новые строки перечислены или нет, зависит от варианта Unix. GNU coreutils и BusyBox по умолчанию отображают ?новую строку, поэтому они в безопасности.

Вызовите ls -fсписок записей без сортировки их (# 2). Это автоматически включается -a(по крайней мере, в современных системах). -fВариант в POSIX , но с дополнительным статусом; большинство реализаций поддерживают его, но не BusyBox. Опция -qзаменяет непечатаемые символы, включая символы новой строки, на ?; это POSIX, но не поддерживается BusyBox, поэтому пропустите его, если вам нужна поддержка BusyBox за счет перерасчета файлов, имя которых содержит символ перевода строки.

Если в каталоге нет подкаталогов, то большинство версий findне будут вызывать statего записи (листовая оптимизация каталога: каталог с числом ссылок 2 не может иметь подкаталоги, поэтому findне нужно искать метаданные записей, если только состояние такое как -typeтребует). Таким образом find . | wc -l, это переносимый и быстрый способ подсчета файлов в каталоге, при условии, что в каталоге нет подкаталогов и что ни одно имя файла не содержит символ новой строки.

Если в каталоге нет подкаталогов, но имена файлов могут содержать символы новой строки, попробуйте один из них (второй должен быть быстрее, если он поддерживается, но может быть не так заметно).

find -print0 | tr -dc \\0 | wc -c
find -printf a | wc -c

С другой стороны, не используйте, findесли в каталоге есть подкаталоги: даже find . -maxdepth 1вызовы statдля каждой записи (по крайней мере, с GNU find и BusyBox find). Вы избегаете сортировки (# 2), но платите цену поиска по индоду (# 3), который снижает производительность.

В оболочке без внешних инструментов вы можете запустить подсчет файлов в текущем каталоге с помощью set -- *; echo $#. Это пропускает точечные файлы (файлы, чье имя начинается с .) и сообщает 1 вместо 0 в пустой директории. Это самый быстрый способ подсчета файлов в небольших каталогах, поскольку он не требует запуска внешней программы, но (за исключением zsh) тратит время на большие каталоги из-за шага сортировки (# 2).

• В bash это надежный способ подсчета файлов в текущем каталоге:

  shopt -s dotglob nullglob
  a=(*)
  echo ${#a[@]}

• В ksh93 это надежный способ подсчета файлов в текущем каталоге:

  FIGNORE='@(.|..)'
  a=(~(N)*)
  echo ${#a[@]}

• В zsh это надежный способ подсчета файлов в текущем каталоге:

  a=(*(DNoN))
  echo $#a

  Если у вас есть mark_dirsнабор опций, убедитесь , чтобы выключить его: a=(*(DNoN^M)).

• В любой оболочке POSIX это надежный способ подсчета файлов в текущем каталоге:

  total=0
  set -- *
  if [ $# -ne 1 ] || [ -e "$1" ] || [ -L "$1" ]; then total=$((total+$#)); fi
  set -- .[!.]*
  if [ $# -ne 1 ] || [ -e "$1" ] || [ -L "$1" ]; then total=$((total+$#)); fi
  set -- ..?*
  if [ $# -ne 1 ] || [ -e "$1" ] || [ -L "$1" ]; then total=$((total+$#)); fi
  echo "$total"

Все эти методы сортируют имена файлов, кроме zsh.

find /foo/foo2/ -maxdepth 1 | wc -l

Это значительно быстрее на моей машине, но локальный .каталог добавляется в счет.

ls -1Uпрежде чем канал должен потратить немного меньше ресурсов, поскольку он не пытается сортировать записи файла, он просто читает их, когда они сортируются в папке на диске. Это также производит меньше продукции, что означает немного меньше работы для wc.

Вы также можете использовать ls -fболее или менее ярлык для ls -1aU.

Я не знаю, есть ли ресурсосберегающий способ сделать это с помощью команды без трубопровода, хотя.

Еще одна точка сравнения. Хотя эта программа на С не является оболочкой-оболочкой, она не делает ничего лишнего. Обратите внимание, что скрытые файлы игнорируются, чтобы соответствовать выводу ls|wc -l( ls -l|wc -lотключен на единицу из-за общего количества блоков в первой строке вывода).

#include <stdio.h>
#include <stdlib.h>
#include <dirent.h>
#include <error.h>
#include <errno.h>

int main(int argc, char *argv[])
{
    int file_count = 0;
    DIR * dirp;
    struct dirent * entry;

    if (argc < 2)
        error(EXIT_FAILURE, 0, "missing argument");

    if(!(dirp = opendir(argv[1])))
        error(EXIT_FAILURE, errno, "could not open '%s'", argv[1]);

    while ((entry = readdir(dirp)) != NULL) {
        if (entry->d_name[0] == '.') { /* ignore hidden files */
            continue;
        }
        file_count++;
    }
    closedir(dirp);

    printf("%d\n", file_count);
}

Вы могли бы попробовать perl -e 'opendir($dh,".");$i=0;while(readdir $dh){$i++};print "$i\n";'

Было бы интересно сравнить время с вашей трубкой.

Из этого ответа я могу думать об этом как о возможном решении.

/*
 * List directories using getdents() because ls, find and Python libraries
 * use readdir() which is slower (but uses getdents() underneath.
 *
 * Compile with 
 * ]$ gcc  getdents.c -o getdents
 */
#define _GNU_SOURCE
#include <dirent.h>     /* Defines DT_* constants */
#include <fcntl.h>
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <sys/stat.h>
#include <sys/syscall.h>

#define handle_error(msg) \
       do { perror(msg); exit(EXIT_FAILURE); } while (0)

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

#define BUF_SIZE 1024*1024*5

int
main(int argc, char *argv[])
{
   int fd, nread;
   char buf[BUF_SIZE];
   struct linux_dirent *d;
   int bpos;
   char d_type;

   fd = open(argc > 1 ? argv[1] : ".", O_RDONLY | O_DIRECTORY);
   if (fd == -1)
       handle_error("open");

   for ( ; ; ) {
       nread = syscall(SYS_getdents, fd, buf, BUF_SIZE);
       if (nread == -1)
           handle_error("getdents");

       if (nread == 0)
           break;

       for (bpos = 0; bpos < nread;) {
           d = (struct linux_dirent *) (buf + bpos);
           d_type = *(buf + bpos + d->d_reclen - 1);
           if( d->d_ino != 0 && d_type == DT_REG ) {
              printf("%s\n", (char *)d->d_name );
           }
           bpos += d->d_reclen;
       }
   }

   exit(EXIT_SUCCESS);
}

Скопируйте вышеуказанную C-программу в каталог, в котором должны быть перечислены файлы. Затем выполните эти команды:

gcc getdents.c -o getdents
./getdents | wc -l

Решение только для bash, не требующее какой-либо внешней программы, но не знаю, насколько оно эффективно:

list=(*)
echo "${#list[@]}"

Вероятно, наиболее ресурсоэффективный способ не предусматривает никаких внешних вызовов процессов. Так что я бы поставил на ...

cglb() ( c=0 ; set --
    tglb() { [ -e "$2" ] || [ -L "$2" ] &&
       c=$(($c+$#-1))
    }
    for glb in '.?*' \*
    do  tglb $1 ${glb##.*} ${glb#\*}
        set -- ..
    done
    echo $c
)

После исправления проблемы из ответа @Joel, где она добавлена .в виде файла:

find /foo/foo2 -maxdepth 1 | tail -n +2 | wc -l

tailпросто удаляет первую строку, то .есть больше не учитывается.

os.listdir () в python может сделать всю работу за вас. Это дает массив содержимого каталога, исключая специальный '.' и '..' файлы. Кроме того, нет необходимости беспокоиться о файлах abt со специальными символами, такими как '\ n' в имени.

python -c 'import os;print len(os.listdir("."))'

Ниже приведено время, затрачиваемое приведенной выше командой python по сравнению с командой 'ls -Af'.

~ / test $ time ls -Af | wc -l
399144

реальный 0m0.300s
пользователь 0m0.104s
sys 0m0.240s
~ / test $ time python -c 'import os; print len ​​(os.listdir ("."))'
399142

реальный 0m0.249s
пользователь 0m0.064s
sys 0m0.180s

ls -1 | wc -lсразу приходит в голову. Является ли ls -1Uэто быстрее, чем ls -1чисто академический - разница должна быть незначительной, но для очень больших каталогов.

Чтобы исключить подкаталоги из подсчета, вот вариант принятого ответа от Жиля:

echo $(( $( \ls -afq target | wc -l ) - $( \ls -od target | cut -f2 -d' ') ))

Внешнее $(( ))арифметическое расширение вычитает выход второй $( )подоболочки из первого $( ). Первый $( )- это как раз Жиль сверху. Второй $( )выводит количество каталогов, «связывающих» с целью. Это происходит из ls -od(замените ls -ldпри желании), где столбец, который перечисляет количество жестких ссылок, имеет это как особое значение для каталогов. «Ссылка» включает в себя подсчет ., ..и любые подкаталоги.

Я не тестировал производительность, но, похоже, это похоже. Он добавляет статистику целевого каталога и некоторые накладные расходы для добавленных подоболочек и конвейера.

Я думаю, что echo * будет более эффективным, чем любая команда 'ls':

echo * | wc -w