Cách hiệu quả nhất về tài nguyên để đếm có bao nhiêu tệp trong một thư mục?

CentOS 5.9

Tôi đã gặp một vấn đề vào một ngày khác, nơi một thư mục có rất nhiều tập tin. Để đếm nó, tôi chạyls -l /foo/foo2/ | wc -l

Hóa ra là có hơn 1 triệu tệp trong một thư mục (câu chuyện dài - nguyên nhân gốc đang được khắc phục).

Câu hỏi của tôi là: có cách nào nhanh hơn để đếm không? Điều gì sẽ là cách hiệu quả nhất để có được số đếm?

Câu trả lời ngắn:

\ls -afq | wc -l

(Điều này bao gồm .và .., vì vậy trừ 2.)

Khi bạn liệt kê các tệp trong một thư mục, ba điều phổ biến có thể xảy ra:

1. Liệt kê tên tập tin trong thư mục Điều này là không thể bỏ qua: không có cách nào để đếm các tệp trong một thư mục mà không liệt kê chúng.
2. Sắp xếp tên tập tin. Shell wildcards và lslệnh làm điều đó.
3. Gọi statđể lấy siêu dữ liệu về mỗi mục nhập thư mục, chẳng hạn như đó có phải là thư mục không.

# 3 là đắt nhất cho đến nay, bởi vì nó yêu cầu tải một nút cho mỗi tệp. Trong so sánh, tất cả các tên tệp cần thiết cho # 1 được lưu trữ gọn trong một vài khối. # 2 lãng phí một số thời gian CPU nhưng nó thường không phải là một bộ ngắt thỏa thuận.

Nếu không có dòng mới trong tên tệp, một đơn giản ls -A | wc -lcho bạn biết có bao nhiêu tệp trong thư mục. Lưu ý rằng nếu bạn có bí danh ls, điều này có thể kích hoạt một cuộc gọi đến stat(ví dụ ls --colorhoặc ls -Fcần biết loại tệp, yêu cầu gọi đến stat), vì vậy từ dòng lệnh, gọi command ls -A | wc -lhoặc \ls -A | wc -lđể tránh bí danh.

Nếu có dòng mới trong tên tệp, liệu dòng mới có được liệt kê hay không phụ thuộc vào biến thể Unix. GNU coreutils và BusyBox mặc định hiển thị ?cho một dòng mới, vì vậy chúng an toàn.

Gọi ls -fđể liệt kê các mục mà không sắp xếp chúng (# 2). Điều này tự động bật -a(ít nhất là trên các hệ thống hiện đại). Các -ftùy chọn là trong POSIX nhưng với tình trạng bắt buộc; hầu hết các triển khai đều hỗ trợ nó, nhưng BusyBox thì không. Tùy chọn -qthay thế các ký tự không in được, bao gồm cả dòng mới bằng ?; đó là POSIX nhưng không được BusyBox hỗ trợ, vì vậy hãy bỏ qua nếu bạn cần hỗ trợ BusyBox với chi phí vượt qua các tệp có tên chứa ký tự dòng mới.

Nếu thư mục không có thư mục con, thì hầu hết các phiên bản findsẽ không gọi statcác mục của nó (tối ưu hóa thư mục lá: thư mục có số lượng liên kết là 2 không thể có thư mục con, vì vậy findkhông cần phải tìm siêu dữ liệu của các mục trừ khi điều kiện như -typeyêu cầu nó). Vì vậy, find . | wc -lmột cách di động, nhanh chóng để đếm các tệp trong một thư mục với điều kiện thư mục đó không có thư mục con và không có tên tệp nào chứa một dòng mới.

Nếu thư mục không có thư mục con nhưng tên tệp có thể chứa dòng mới, hãy thử một trong những thư mục này (thư mục thứ hai sẽ nhanh hơn nếu được hỗ trợ, nhưng có thể không đáng chú ý như vậy).

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

Mặt khác, không sử dụng findnếu thư mục có thư mục con: thậm chí find . -maxdepth 1gọi stattrên mỗi mục (ít nhất là với GNU find và BusyBox find). Bạn tránh sắp xếp (# 2) nhưng bạn phải trả giá cho việc tra cứu inode (# 3) sẽ giết chết hiệu suất.

Trong shell không có công cụ bên ngoài, bạn có thể chạy đếm các tệp trong thư mục hiện tại với set -- *; echo $#. Điều này bỏ lỡ các tệp chấm (các tệp có tên bắt đầu .) và báo cáo 1 thay vì 0 trong một thư mục trống. Đây là cách nhanh nhất để đếm các tệp trong các thư mục nhỏ vì nó không yêu cầu bắt đầu một chương trình bên ngoài, nhưng (ngoại trừ trong zsh) lãng phí thời gian cho các thư mục lớn hơn do bước sắp xếp (# 2).

• Trong bash, đây là một cách đáng tin cậy để đếm các tệp trong thư mục hiện tại:

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

• Trong ksh93, đây là một cách đáng tin cậy để đếm các tệp trong thư mục hiện tại:

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

• Trong zsh, đây là một cách đáng tin cậy để đếm các tệp trong thư mục hiện tại:

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

  Nếu bạn có mark_dirstùy chọn được đặt, hãy đảm bảo tắt nó : a=(*(DNoN^M)).

• Trong bất kỳ shell POSIX nào, đây là một cách đáng tin cậy để đếm các tệp trong thư mục hiện tại:

  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"

Tất cả các phương thức này sắp xếp tên tệp, ngoại trừ zsh.

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

Là nhanh hơn đáng kể trên máy của tôi nhưng .thư mục địa phương được thêm vào số đếm.

ls -1Utrước khi đường ống chỉ tiêu tốn ít tài nguyên hơn một chút, vì nó không cố gắng sắp xếp các mục nhập tệp, nó chỉ đọc chúng khi chúng được sắp xếp trong thư mục trên đĩa. Nó cũng tạo ra đầu ra ít hơn, có nghĩa là công việc hơi ít wc.

Bạn cũng có thể sử dụng ls -fmột hoặc nhiều hơn một phím tắt cho ls -1aU.

Tôi không biết có cách nào hiệu quả về tài nguyên để thực hiện thông qua lệnh mà không cần đường ống hay không.

Một điểm so sánh khác. Mặc dù không phải là một oneliner vỏ, chương trình C này không làm bất cứ điều gì thừa. Lưu ý rằng các tệp ẩn được bỏ qua để khớp với đầu ra của ls|wc -l( ls -l|wc -lbị tắt bởi một do tổng số khối trong dòng đầu ra đầu tiên).

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

Bạn có thể thử perl -e 'opendir($dh,".");$i=0;while(readdir $dh){$i++};print "$i\n";'

Thật thú vị khi so sánh thời gian với ống vỏ của bạn.

Từ câu trả lời này , tôi có thể nghĩ về điều này như một giải pháp khả thi.

/*
 * 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);
}

Sao chép chương trình C ở trên vào thư mục chứa các tệp cần được liệt kê. Sau đó thực hiện các lệnh sau:

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

Một giải pháp chỉ bash, không yêu cầu bất kỳ chương trình bên ngoài nào, nhưng không biết hiệu quả đến mức nào:

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

Có lẽ cách hiệu quả nhất về tài nguyên sẽ không liên quan đến các yêu cầu bên ngoài. Vì vậy, tôi muốn đánh cuộc ...

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

Sau khi khắc phục sự cố từ câu trả lời của @Joel, nơi nó được thêm .dưới dạng tệp:

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

tailchỉ cần xóa dòng đầu tiên, nghĩa .là không được tính nữa.

os.listdir () trong python có thể làm việc cho bạn. Nó đưa ra một mảng các nội dung của thư mục, không bao gồm '.' và các tập tin '..'. Ngoài ra, không cần phải lo lắng các tệp abt có ký tự đặc biệt như '\ n' trong tên.

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

sau đây là thời gian của lệnh python ở trên so với lệnh 'ls -Af'.

~ / kiểm tra $ thời gian ls -Af | wc -l
399144

0m0.300 thực
người dùng 0m0.104s
sys 0m0.240s
~ / test $ time python -c 'nhập os; in len (os.listdir ("."))'
399142

số 0m0.249 thực
người dùng 0m0.064
sys 0m0.180s

ls -1 | wc -lđến ngay với tâm trí của tôi Cho dù ls -1Ulà nhanh hơn ls -1là hoàn toàn học tập - sự khác biệt nên không đáng kể nhưng đối với các thư mục rất lớn.

Để loại trừ các thư mục con khỏi số đếm, đây là một biến thể của câu trả lời được chấp nhận từ Gilles:

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

Sự $(( ))mở rộng số học bên ngoài trừ đi đầu ra của lớp con thứ hai $( )từ lớp thứ nhất $( ). Đầu tiên $( )là chính xác Gilles 'từ trên cao. Thứ hai $( )xuất ra số lượng thư mục "liên kết" đến mục tiêu. Điều này xuất phát từ ls -od(thay thế ls -ldnếu muốn), trong đó cột liệt kê số lượng liên kết cứng có ý nghĩa đặc biệt cho các thư mục. "Liên kết" đếm bao gồm ., ..và bất kỳ thư mục con.

Tôi đã không kiểm tra hiệu suất, nhưng nó có vẻ tương tự nhau. Nó thêm một chỉ số của thư mục đích và một số chi phí cho đường ống con và đường ống được thêm vào.

Tôi nghĩ rằng echo * sẽ hiệu quả hơn bất kỳ lệnh 'ls' nào:

echo * | wc -w