Який найбільш ресурсно ефективний спосіб підрахувати кількість файлів у каталозі?

CentOS 5.9

Днями я зіткнувся з проблемою, де в каталозі було багато файлів. Щоб порахувати, я побігls -l /foo/foo2/ | wc -l

Виявляється, в одному каталозі було понад 1 мільйон файлів (довга історія - виправлення першопричини).

Моє запитання: чи є більш швидкий спосіб зробити підрахунок? Який був би найефективніший спосіб отримати підрахунок?

Коротка відповідь:

\ls -afq | wc -l

(Сюди входить .і ..віднімаємо 2.)

Коли ви перераховуєте файли в каталозі, можуть трапитися три поширені речі:

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

№3 - найдорожчий на сьогоднішній день, оскільки він вимагає завантаження inode для кожного файлу. Для порівняння, всі назви файлів, необхідні для №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), але ви платите ціну пошуку inode (# 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

Рішення лише для удару, не вимагає жодної зовнішньої програми, але не знаю, наскільки ефективно:

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'.

~ / тест $ time ls -Af | wc -l
399144

реальні 0м0.300с
користувач 0m0.104s
sys 0m0.240s
~ / test $ time python -c 'import os; print len ​​(os.listdir ("."))'
399142

реальні 0м0.249с
користувач 0m0.064s
sys 0m0.180s

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

Щоб виключити підкаталоги з підрахунку, ось варіант прийнятої відповіді від Gilles:

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

Зовнішнє $(( ))арифметичне розширення віднімає вихід другого $( )підшару з першого $( ). Перший $( )- це саме Жил зверху. Друга $( )виводить кількість каталогів, що "пов'язують" ціль. Це походить від ls -od(заміни ls -ldза бажанням), де стовпець, у якому перераховано кількість жорстких посилань, має особливе значення для каталогів. «Посилання» включає в себе підрахунок ., ..і будь-які підкаталоги.

Я не перевіряв продуктивність, але, здавалося б, був подібний. Він додає статтю цільового каталогу та деяку накладну частину для доданого підшару і труби.

Я думаю, що echo * буде ефективнішим за будь-яку команду 'ls':

echo * | wc -w