ฉันกำลังพยายามหาวิธีที่ดีที่สุดในการค้นหาจำนวนไฟล์ในไดเร็กทอรีหนึ่ง ๆ เมื่อมีไฟล์จำนวนมาก (มากกว่า 100,000 ไฟล์)

เมื่อมีไฟล์จำนวนมากการดำเนินการls | wc -lใช้เวลาค่อนข้างนานในการดำเนินการ ฉันเชื่อว่านี่เป็นเพราะมันส่งคืนชื่อของไฟล์ทั้งหมด ฉันพยายามใช้ดิสก์ I / O ให้น้อยที่สุด

ฉันได้ทดลองกับเชลล์และสคริปต์ Perl บางส่วนแล้วก็ไม่มีประโยชน์ ฉันจะทำมันได้อย่างไร?

โดยค่าเริ่มต้นจะlsเรียงลำดับชื่อซึ่งอาจใช้เวลาสักครู่หากมีจำนวนมาก นอกจากนี้จะไม่มีเอาต์พุตจนกว่าจะอ่านและเรียงลำดับชื่อทั้งหมด ใช้ls -fตัวเลือกเพื่อปิดการเรียงลำดับ

ls -f | wc -l

ทราบว่านี้ยังจะช่วยให้-aเพื่อให้., ..และไฟล์อื่น ๆ ที่เริ่มต้นด้วย.จะถูกนับ

วิธีที่เร็วที่สุดคือโปรแกรมที่สร้างขึ้นโดยเฉพาะเช่นนี้:

#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;
}

จากการทดสอบของฉันโดยไม่คำนึงถึงแคชฉันรันแต่ละรายการประมาณ 50 ครั้งต่อไดเรกทอรีเดียวกันซ้ำแล้วซ้ำเล่าเพื่อหลีกเลี่ยงการบิดเบือนข้อมูลที่อิงกับแคชและฉันได้รับตัวเลขประสิทธิภาพโดยประมาณต่อไปนี้ (ตามเวลานาฬิกาจริง):

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

สุดท้ายdircntคือโปรแกรมที่รวบรวมจากแหล่งข้อมูลข้างต้น

แก้ไข 26-09-2016

เนื่องจากความต้องการที่ได้รับความนิยมฉันจึงเขียนโปรแกรมนี้ขึ้นมาใหม่เพื่อให้เรียกซ้ำดังนั้นโปรแกรมจะลดลงในไดเรกทอรีย่อยและนับไฟล์และไดเรกทอรีแยกกัน

เนื่องจากเห็นได้ชัดว่าบางคนต้องการทราบวิธีการทั้งหมดนี้ฉันจึงมีความคิดเห็นมากมายในโค้ดเพื่อพยายามทำให้ชัดเจนว่าเกิดอะไรขึ้น ฉันเขียนสิ่งนี้และทดสอบบน Linux 64 บิต แต่ควรทำงานได้กับระบบที่รองรับ POSIX รวมถึง Microsoft Windows ยินดีต้อนรับรายงานข้อผิดพลาด ฉันยินดีที่จะอัปเดตสิ่งนี้หากคุณไม่สามารถทำงานบน AIX หรือ OS / 400 หรืออะไรก็ได้

ที่คุณสามารถดูมันมากความซับซ้อนมากขึ้นกว่าเดิมและจำเป็นต้องให้: อย่างน้อยหนึ่งฟังก์ชั่นจะต้องมีอยู่จะเรียกว่าซ้ำถ้าคุณต้องการรหัสที่จะกลายเป็นความซับซ้อนมาก (เช่นการจัดการกองไดเรกทอรีย่อยและการประมวลผลที่ในวงเดียว) เนื่องจากเราต้องตรวจสอบประเภทไฟล์ความแตกต่างระหว่าง OS ต่างๆไลบรารีมาตรฐาน ฯลฯ จึงเข้ามามีบทบาทดังนั้นฉันจึงเขียนโปรแกรมที่พยายามจะใช้งานได้กับระบบใด ๆ

มีการตรวจสอบข้อผิดพลาดน้อยมากและcountตัวฟังก์ชันเองก็ไม่ได้รายงานข้อผิดพลาดจริงๆ การโทรเท่านั้นที่สามารถล้มเหลวได้คือopendirและstat(หากคุณไม่โชคดีและมีระบบที่direntมีประเภทไฟล์อยู่แล้ว) ฉันไม่ paranoid เกี่ยวกับการตรวจสอบความยาวรวมของ pathnames subdir แต่ในทางทฤษฎีระบบไม่ควรอนุญาตให้ชื่อเส้นทางใด ๆ PATH_MAXที่มีความยาวเกินกว่า หากมีข้อกังวลฉันสามารถแก้ไขได้ แต่เป็นเพียงโค้ดเพิ่มเติมที่ต้องอธิบายให้คนที่เรียนรู้ที่จะเขียน C โปรแกรมนี้มีจุดมุ่งหมายเพื่อเป็นตัวอย่างของการดำน้ำในไดเรกทอรีย่อยแบบวนซ้ำ

#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;
}

แก้ไข 2017-01-17

ฉันได้รวมการเปลี่ยนแปลงสองอย่างที่แนะนำโดย @FlyingCodeMonkey:

1. ใช้lstatแทนstat. สิ่งนี้จะเปลี่ยนลักษณะการทำงานของโปรแกรมหากคุณมีไดเร็กทอรี symlinked ในไดเร็กทอรีที่คุณกำลังสแกน พฤติกรรมก่อนหน้านี้คือไดเร็กทอรีย่อย (ที่เชื่อมโยง) จะมีการเพิ่มจำนวนไฟล์ลงในจำนวนโดยรวม ลักษณะการทำงานใหม่คือไดเร็กทอรีที่เชื่อมโยงจะนับเป็นไฟล์เดียวและเนื้อหาจะไม่ถูกนับ
2. หากเส้นทางของไฟล์ยาวเกินไปข้อความแสดงข้อผิดพลาดจะปรากฏขึ้นและโปรแกรมจะหยุดทำงาน

แก้ไข 2017-06-29

ด้วยความโชคดีนี่จะเป็นการแก้ไขครั้งสุดท้ายของคำตอบนี้ :)

ฉันได้คัดลอกโค้ดนี้ลงในที่เก็บ GitHubเพื่อให้ง่ายต่อการรับโค้ด (แทนที่จะคัดลอก / วางคุณสามารถดาวน์โหลดซอร์สได้ ) แถมยังช่วยให้ทุกคนแนะนำการแก้ไขได้ง่ายขึ้นโดยการส่งการดึง - ขอจาก GitHub

แหล่งที่มามีอยู่ใน Apache License 2.0 แพทช์^* ยินดีต้อนรับ!

• "ปะ" คือสิ่งที่คนแก่อย่างฉันเรียกว่า "pull request"

ใช้หา ตัวอย่างเช่น:

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

find , lsและperl ที่ทดสอบกับไฟล์ 40,000 ไฟล์มีความเร็วเท่ากัน (แม้ว่าฉันไม่ได้พยายามล้างแคช):

[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

และด้วยopendirและreaddirของ Perl ในเวลาเดียวกัน:

[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

หมายเหตุ: ฉันใช้ / bin / ls -f เพื่อให้แน่ใจว่าได้ข้ามตัวเลือกนามแฝงซึ่งอาจทำให้ช้าลงเล็กน้อยและ-fเพื่อหลีกเลี่ยงการเรียงลำดับไฟล์ lsโดยไม่-fช้ากว่าfind/ สองเท่าperl ยกเว้นถ้าlsใช้กับ-fดูเหมือนว่าจะเป็นเวลาเดียวกัน:

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

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

ฉันยังต้องการมีสคริปต์เพื่อถามระบบไฟล์โดยตรงโดยไม่มีข้อมูลที่ไม่จำเป็นทั้งหมด

_{การทดสอบจะขึ้นอยู่กับคำตอบของปีเตอร์แวนเดอร์ Heijden , เกล็น Jackmanและmark4o}

น่าแปลกสำหรับฉันการค้นพบกระดูกที่เปลือยเปล่านั้นเทียบได้กับ ls -f

> time ls -f my_dir | wc -l
17626

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

เทียบกับ

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

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

แน่นอนว่าค่าของทศนิยมตำแหน่งที่สามจะเปลี่ยนไปรอบ ๆ เล็กน้อยทุกครั้งที่คุณเรียกใช้สิ่งเหล่านี้ดังนั้นค่าเหล่านี้จึงเหมือนกันโดยทั่วไป อย่างไรก็ตามโปรดสังเกตว่าfindจะส่งคืนหน่วยพิเศษหนึ่งหน่วยเนื่องจากจะนับไดเร็กทอรีจริงเอง (และตามที่กล่าวไว้ก่อนหน้านี้ls -fจะส่งคืนหน่วยพิเศษสองหน่วยเนื่องจากจะนับด้วยและ .. )

คุณสามารถเปลี่ยนผลลัพธ์ตามความต้องการของคุณได้ แต่นี่คือ Bash one-liner ที่ฉันเขียนเพื่อนับซ้ำและรายงานจำนวนไฟล์ในชุดของไดเร็กทอรีที่มีชื่อเป็นตัวเลข

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

สิ่งนี้มีลักษณะวนซ้ำสำหรับไฟล์ทั้งหมด (ไม่ใช่ไดเร็กทอรี) ในไดเร็กทอรีที่กำหนดและส่งคืนผลลัพธ์ในรูปแบบคล้ายแฮช การปรับแต่งคำสั่ง find อย่างง่ายๆสามารถทำให้ไฟล์ประเภทใดที่คุณต้องการนับเฉพาะเจาะจงมากขึ้นเป็นต้น

ผลลัพธ์จะเป็นดังนี้:

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

จำนวนไฟล์ Linux ที่รวดเร็ว

จำนวนไฟล์ Linux ที่เร็วที่สุดที่ฉันรู้คือ

locate -c -r '/home'

นอกจากนี้ยังไม่มีความจำเป็นที่จะเรียกgrep ! แต่ดังที่กล่าวไว้คุณควรมีฐานข้อมูลใหม่ (อัปเดตทุกวันโดยงาน cron หรือด้วยตนเองsudo updatedb)

จากมนุษย์ค้นหา

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

นอกจากนี้คุณควรทราบว่ามันยังนับไดเรกทอรีเป็นไฟล์!

BTW:หากคุณต้องการภาพรวมของไฟล์และไดเร็กทอรีของคุณในประเภทระบบของคุณ

locate -S

แสดงจำนวนไดเร็กทอรีไฟล์และอื่น ๆ

คุณสามารถรับจำนวนไฟล์และไดเร็กทอรีด้วยโปรแกรมต้นไม้

เรียกใช้คำสั่งtree | tail -n 1เพื่อรับบรรทัดสุดท้ายซึ่งจะบอกว่า "763 ไดเร็กทอรี, 9290 ไฟล์" ซึ่งจะนับไฟล์และโฟลเดอร์แบบวนซ้ำโดยไม่รวมไฟล์ที่ซ่อนอยู่ซึ่งสามารถเพิ่มได้ด้วยแฟล็-aก สำหรับการอ้างอิงคอมพิวเตอร์ของฉันใช้เวลา 4.8 วินาทีในการนับ Tree เพื่อนับโฮมไดเร็กทอรีทั้งหมดของฉันซึ่งเป็น 24,777 ไดเร็กทอรี 238,680 ไฟล์ find -type f | wc -lใช้เวลา 5.3 วินาทีครึ่งวินาทีนานขึ้นดังนั้นฉันคิดว่าต้นไม้ค่อนข้างฉลาดในการแข่งขัน

ตราบเท่าที่คุณไม่มีโฟลเดอร์ย่อยต้นไม้เป็นวิธีที่ง่ายและรวดเร็วในการนับไฟล์

นอกจากนี้และหมดจดเพื่อความสนุกสนานของมันคุณสามารถใช้tree | grep '^├'เพื่อแสดงเฉพาะไฟล์ / โฟลเดอร์ในไดเรกทอรีปัจจุบัน - lsนี้เป็นพื้นรุ่นช้าลงมาก

คำตอบนี้เร็วกว่าเกือบทุกอย่างในหน้านี้สำหรับไดเรกทอรีที่มีขนาดใหญ่มากและซ้อนกันมาก:

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

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

คุณสามารถลองถ้าใช้opendir()และreaddir()ในPerlเร็วกว่า สำหรับตัวอย่างของฟังก์ชั่นเหล่านั้นให้ดูที่นี่

ฉันมาที่นี่เมื่อพยายามนับไฟล์ในชุดข้อมูลประมาณ 10,000 โฟลเดอร์โดยมีไฟล์ประมาณ 10,000 ไฟล์ ปัญหาของหลาย ๆ วิธีคือโดยปริยายสถิติ 100 ล้านไฟล์ซึ่งใช้เวลานาน

ฉันใช้เสรีภาพในการขยายแนวทางของ Christopher Schultzดังนั้นจึงสนับสนุนการส่งผ่านไดเรกทอรีผ่านอาร์กิวเมนต์ (วิธีการเรียกซ้ำของเขาใช้สถิติเช่นกัน)

ใส่สิ่งต่อไปนี้ลงในไฟล์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;
}

หลังจากนั้นgcc -o dircnt_args dircnt_args.cคุณสามารถเรียกมันได้ดังนี้:

dircnt_args /your/directory/*

ใน 100 ล้านไฟล์ใน 10,000 โฟลเดอร์ข้างต้นจะเสร็จสิ้นอย่างรวดเร็ว (ประมาณ 5 นาทีสำหรับการรันครั้งแรกและการติดตามแคช: ประมาณ 23 วินาที)

วิธีเดียวที่อื่น ๆ ที่ดำเนินการเสร็จสิ้นในเวลาน้อยกว่าหนึ่งชั่วโมงก็lsมีประมาณ 1 ls -f /your/directory/* | wc -lนาทีในแคช: จำนวนถูกปิดโดยบรรทัดใหม่สองสามรายการต่อไดเรกทอรีแม้ว่า ...

นอกเหนือจากที่คาดไว้ไม่มีความพยายามใด ๆ ของฉันที่findส่งคืนภายในหนึ่งชั่วโมง: - /

วิธีที่เร็วที่สุดบน Linux (คำถามถูกแท็กเป็น Linux) คือการใช้การเรียกระบบโดยตรง นี่คือโปรแกรมเล็ก ๆ ที่นับไฟล์ (เท่านั้นไม่มีไดเร็กทอรี) ในไดเร็กทอรี คุณสามารถนับล้านของไฟล์และมันก็เป็นประมาณ 2.5 เท่าเร็วกว่า ls "-f" และรอบ 1.3-1.5 ครั้งเร็วกว่าคำตอบที่คริสชูลทซ์ของ

#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: ไม่ใช่การเรียกซ้ำ แต่คุณสามารถแก้ไขเพื่อให้บรรลุสิ่งนั้นได้

lsใช้เวลามากขึ้นในการเรียงลำดับชื่อไฟล์ ใช้-fเพื่อปิดการจัดเรียงจะช่วยประหยัดเวลา:

ls -f | wc -l

หรือคุณสามารถใช้find:

find . -type f | wc -l

คุณควรใช้ "getdents" แทน ls / find

นี่เป็นบทความที่ดีมากบทความหนึ่งซึ่งอธิบายถึงแนวทางการรับ

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

นี่คือสารสกัด:

lsและวิธีอื่น ๆ ในการแสดงรายการไดเร็กทอรี (รวมถึงos.listdirของ Python และfind .) อาศัย libc readdir () อย่างไรก็ตาม readdir () อ่านรายการไดเร็กทอรี 32K ต่อครั้งเท่านั้นซึ่งหมายความว่าหากคุณมีไฟล์จำนวนมากในไดเร็กทอรีเดียวกัน (เช่น 500 ล้านรายการไดเร็กทอรี) จะต้องใช้เวลานานพอสมควรในการอ่านทั้งหมด รายการไดเรกทอรีโดยเฉพาะบนดิสก์ช้า สำหรับไดเรกทอรีที่มีไฟล์จำนวนมากคุณจะต้องเจาะลึกกว่าเครื่องมือที่ใช้ readdir () คุณจะต้องใช้ getdents () สายระบบโดยตรงมากกว่าวิธีการช่วยเหลือจากห้องสมุดมาตรฐาน C

เราสามารถค้นหารหัส C เพื่อแสดงรายการไฟล์โดยใช้ getdents () ได้จากที่นี่ :

มีการปรับเปลี่ยนสองอย่างที่คุณต้องทำเพื่อให้แสดงรายการไฟล์ทั้งหมดในไดเร็กทอรีได้อย่างรวดเร็ว

ขั้นแรกให้เพิ่มขนาดบัฟเฟอร์จาก X เป็น 5 เมกะไบต์

#define BUF_SIZE 1024*1024*5

จากนั้นแก้ไขลูปหลักที่มันพิมพ์ข้อมูลเกี่ยวกับแต่ละไฟล์ในไดเร็กทอรีเพื่อข้ามรายการด้วย inode == 0 ฉันทำได้โดยการเพิ่ม

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

ในกรณีของฉันฉันดูแลเฉพาะชื่อไฟล์ในไดเร็กทอรีดังนั้นฉันจึงเขียนคำสั่ง printf () ใหม่เพื่อพิมพ์เฉพาะชื่อไฟล์

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

คอมไพล์ (ไม่จำเป็นต้องมีไลบรารีภายนอกดังนั้นจึงทำได้ง่ายมาก)

gcc listdir.c -o listdir

ตอนนี้เพียงแค่เรียกใช้

./listdir [directory with an insane number of files]

ฉันตระหนักว่าการไม่ใช้ในการประมวลผลหน่วยความจำเมื่อคุณมีข้อมูลจำนวนมากนั้นเร็วกว่าคำสั่ง "ไพพ์" ดังนั้นฉันจึงบันทึกผลลัพธ์ลงในไฟล์และวิเคราะห์ในภายหลัง:

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

ไดเร็กทอรี 10 รายการแรกที่มีจำนวนไฟล์มากที่สุด

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

ฉันชอบคำสั่งต่อไปนี้เพื่อติดตามการเปลี่ยนแปลงของจำนวนไฟล์ในไดเร็กทอรี

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

คำสั่งจะเปิดหน้าต่างไว้เพื่อติดตามจำนวนไฟล์ที่อยู่ในไดเร็กทอรีด้วยอัตราการรีเฟรช 0.1 วินาที