एक निर्देशिका में कितनी फाइलें गिनने के लिए सबसे अधिक संसाधन कुशल तरीका है?

Question

सेंटोस 5.9

मैं उस दिन एक मुद्दे पर आया था जहां एक निर्देशिका में बहुत सारी फाइलें थीं। इसे गिनने के लिए मैं दौड़ाls -l /foo/foo2/ | wc -l

एक ही निर्देशिका में 1 मिलियन से अधिक फाइलें थीं (लंबी कहानी - मूल कारण निश्चित हो रहा है)।

मेरा सवाल है: क्या गिनती करने का एक तेज़ तरीका है? गिनती प्राप्त करने का सबसे कुशल तरीका क्या होगा?

Comments

ls -l|wc -lls -lउत्पादन की पहली पंक्ति में कुल ब्लॉकों के कारण एक-एक करके बंद हो जाएगा

— थॉमस न्यूमैन

@ThomasNyman यह वास्तव में डॉट और डॉटडीड छद्म प्रविष्टियों के कारण कई लोगों द्वारा बंद किया जाएगा, लेकिन -Aझंडे का उपयोग करके उन्हें टाला जा सकता है । -lविस्तारित फ़ाइल स्वरूप को उत्पन्न करने के लिए रीडिंग फ़ाइल मेटा डेटा के कारण भी समस्याग्रस्त है। -lउपयोग करके मजबूर नहीं \lsकरना एक बेहतर विकल्प है ( -1यह माना जाता है कि आउटपुट करते समय पाइपिंग।) यहां सबसे अच्छे समाधान के लिए गाइल्स का जवाब देखें ।

— कालेब

@Caleb ls -lनहीं उत्पादन किसी भी छिपी हुई फ़ाइलें और न ही .और ..प्रविष्टियों। ls -aउत्पादन छिपी हुई फ़ाइलें, शामिल सहित . और ..जबकि ls -Aउत्पादन छिपी हुई फ़ाइलें शामिल छोड़कर . और ..। में गाइल्स के जवाब बैश dotglob खोल विकल्प छिपा फ़ाइलों को शामिल करने विस्तार का कारण बनता है को छोड़कर . और ..।

— थॉमस निमन

Answer 1

संक्षिप्त जवाब:

\ls -afq | wc -l

(इसमें शामिल है .और ..इसलिए, घटाना 2.)

---

जब आप फ़ाइलों को किसी निर्देशिका में सूचीबद्ध करते हैं, तो तीन सामान्य चीजें हो सकती हैं:

1. निर्देशिका में फ़ाइल नामों की गणना। यह अपरिहार्य है: फ़ाइलों को किसी निर्देशिका में गणना किए बिना उन्हें गिनने का कोई तरीका नहीं है।
2. फ़ाइल नामों को छाँटना। शैल वाइल्डकार्ड और lsकमांड ऐसा करते हैं।
3. statप्रत्येक निर्देशिका प्रविष्टि के बारे में मेटाडेटा प्राप्त करने के लिए कॉल करना, जैसे कि यह एक निर्देशिका है।

# 3 अब तक का सबसे महंगा है, क्योंकि इसमें प्रत्येक फ़ाइल के लिए एक इनलोड लोड करने की आवश्यकता होती है। तुलना में # 1 के लिए आवश्यक सभी फ़ाइल नाम कॉम्पैक्ट रूप से कुछ ब्लॉकों में संग्रहीत किए जाते हैं। # 2 कुछ CPU समय बर्बाद करता है लेकिन यह अक्सर एक सौदा ब्रेकर नहीं होता है।

यदि फ़ाइल नामों में कोई नई सूची नहीं है, तो एक साधारण ls -A | wc -lआपको बताता है कि निर्देशिका में कितनी फाइलें हैं। सावधान रहें कि यदि आप के लिए एक उपनाम है ls, इस के लिए एक कॉल गति प्रदान कर सकते statहैं (जैसे ls --colorया ls -Fफ़ाइल प्रकार है, जो करने के लिए एक फोन की आवश्यकता है पता करने की जरूरत statहै, तो कमांड लाइन से,) फोन command ls -A | wc -lया \ls -A | wc -lकिसी अन्य नाम से बचने के लिए।

यदि फ़ाइल के नाम में नई सूचियाँ हैं, तो नई सूचियाँ सूचीबद्ध हैं या नहीं, यह यूनिक्स संस्करण पर निर्भर करता है। GNU कोरयूटिल्स और बिजीबॉक्स डिफॉल्ट ?नई लाइन के लिए डिफॉल्ट करते हैं, इसलिए वे सुरक्षित हैं।

ls -fउन्हें (# 2) सॉर्ट किए बिना प्रविष्टियों को सूचीबद्ध करने के लिए कॉल करें। यह स्वचालित रूप से -a(कम से कम आधुनिक प्रणालियों पर) चालू होता है। -fविकल्प POSIX में लेकिन वैकल्पिक स्थिति के साथ है, अधिकांश कार्यान्वयन इसका समर्थन करते हैं, लेकिन व्यस्त बॉक्स नहीं। यह विकल्प -qगैर-मुद्रण योग्य वर्णों को प्रतिस्थापित करता है ?, जिनमें नई लिस्ट शामिल हैं ; यह पॉसिक्स है, लेकिन बिजीबॉक्स द्वारा समर्थित नहीं है, इसलिए इसे छोड़ दें यदि आपको उन फ़ाइलों को ओवरकाउंट करने की कीमत पर बिजीबॉक्स समर्थन की आवश्यकता है जिनके नाम में एक नई लाइन वर्ण है।

यदि निर्देशिका में कोई उपनिर्देशिका नहीं है, तो इसके प्रविष्टियों पर अधिकांश संस्करण 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(कम से कम जीएनयू ढूंढें और बिजीबॉक्स ढूंढें)। आप (# 2) सॉर्ट करने से बचते हैं लेकिन आप इनकोड लुकअप (# 3) की कीमत चुकाते हैं जो प्रदर्शन को मारता है।

बाहरी उपकरणों के बिना शेल में, आप वर्तमान निर्देशिका में फ़ाइलों को गिन सकते हैं set -- *; echo $#। यह डॉट फाइलें (जिनके नाम से शुरू होती है .) फाइलें और खाली निर्देशिका में 0 के बजाय 1 रिपोर्ट करता है। यह छोटी निर्देशिकाओं में फ़ाइलों को गिनने का सबसे तेज़ तरीका है, क्योंकि इसके लिए बाहरी कार्यक्रम शुरू करने की आवश्यकता नहीं है, लेकिन (zsh को छोड़कर) सॉर्टिंग चरण (# 2) के कारण बड़ी निर्देशिकाओं के लिए समय बर्बाद करता है।

• बैश में, यह वर्तमान निर्देशिका में फ़ाइलों को गिनने का एक विश्वसनीय तरीका है:

  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 को छोड़कर।

Comments

> 1 मिलियन फाइलों पर मेरा अनुभवजन्य परीक्षण यह दिखाता है कि जब तक आप एक घोषणा की तरह कुछ भी नहीं जोड़ते हैं, तब तक find -maxdepth 1आसानी से तालमेल बनाये रखता है । क्या आपको यकीन है कि जीएनयू वास्तव में कॉल करता है ? यहां तक ​​कि अगर आप इसे रिटर्न फाइल विवरण बनाते हैं, तो बोग्स की तुलना में मंदी कुछ भी नहीं है । दूसरी ओर स्पष्ट गति विजेता गैर छांटने वाले ग्लोब का उपयोग कर रहा है। (सॉर्ट किए गए ग्लब्स 2x की तुलना में धीमे होते हैं जबकि नॉन-सॉर्टिंग 2 गुना तेजी से होता है)। मुझे आश्चर्य है कि अगर फ़ाइल सिस्टम प्रकार इन परिणामों को महत्वपूर्ण रूप से प्रभावित करेंगे। \ls -U-typestatfind -typels -lzshls

— कालेब

@ कालेब मैं भागा strace। यह तभी सही है जब निर्देशिका में उपनिर्देशिकाएँ हों: अन्यथा findपत्ती निर्देशिका अनुकूलन (बिना भी -maxdepth 1) में किक करता है , मुझे इसका उल्लेख करना चाहिए। बहुत सी चीजें परिणाम को प्रभावित कर सकती हैं, जिसमें फाइलसिस्टम प्रकार (कॉलिंग statसिस्टम पर बहुत अधिक महंगा है, जो निर्देशिकाओं को फाइल सिस्टम की तुलना में रैखिक सूचियों का प्रतिनिधित्व करते हैं जो पेड़ों के रूप में निर्देशिकाओं का प्रतिनिधित्व करते हैं), क्या इनोड्स सभी एक साथ बनाए गए थे और इस तरह से पास हैं डिस्क पर, ठंडा या गर्म कैश, आदि

— गिल्स एसओ- बुराई को रोकना '

ऐतिहासिक रूप से, ls -fकॉलिंग को रोकने का विश्वसनीय तरीका है stat- इसे अक्सर आज के रूप में वर्णित किया जाता है क्योंकि "आउटपुट सॉर्ट नहीं किया जाता है" (जो यह भी कारण बनता है), और इसमें शामिल है .और ..। -Aऔर -Uमानक विकल्प नहीं हैं।

— रैंडम 832

यदि आप विशेष रूप से एक सामान्य एक्सटेंशन (या अन्य स्ट्रिंग) के साथ फाइल को गिनना चाहते हैं, तो यह कहते हुए कि कमांड में अतिरिक्त 2 को समाप्त करता है। यहाँ एक उदाहरण है:\ls -afq *[0-9].pdb | wc -l

— स्टीवन सी। हॉवेल

FYI करें, version sh (AT&T Research) 93u+ 2012-08-01मेरे डेबियन-आधारित सिस्टम पर ksh93 के साथ , FIGNOREकाम नहीं करता है। .और ..प्रविष्टियों जिसके परिणामस्वरूप सरणी में शामिल किए गए हैं

— सर्गी Kolodyazhnyy

Answer 2

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

मेरी मशीन पर काफी तेज है लेकिन स्थानीय .निर्देशिका को गिनती में जोड़ा जाता है।

Comments

धन्यवाद। मैं हालांकि एक मूर्खतापूर्ण सवाल पूछने के लिए मजबूर हूँ: यह तेज़ क्यों है? क्योंकि यह फ़ाइल विशेषताओं को देखने के लिए परेशान नहीं है?

— माइक बी।

हां, यही मेरी समझ है। जब तक आपके -typeपैरामीटर का उपयोग नहीं कर रहा है, findतब तक तेज होना चाहिएls

— जोएल टेलर

हम्मम .... अगर मैं अच्छी तरह से खोजने के प्रलेखन को समझ रहा हूं , तो यह वास्तव में मेरे उत्तर से बेहतर होना चाहिए। अधिक अनुभव वाला कोई भी व्यक्ति सत्यापन कर सकता है?

— लुइस माचूका

-mindepth 1निर्देशिका को स्वयं छोड़ने के लिए a जोड़ें ।

— स्टीफन चेज़लस

Answer 3

ls -1Uइससे पहले कि पाइप को बस थोड़ा कम संसाधन खर्च करना चाहिए, क्योंकि यह फ़ाइल प्रविष्टियों को सॉर्ट करने का कोई प्रयास नहीं करता है, यह सिर्फ उन्हें पढ़ता है जैसे कि वे डिस्क पर फ़ोल्डर में क्रमबद्ध होते हैं। यह कम आउटपुट भी पैदा करता है, जिसका अर्थ है कम काम करना wc।

आप यह भी इस्तेमाल कर सकते हैं ls -fजो कमोबेश शॉर्टकट है ls -1aU।

मैं नहीं जानता कि क्या बिना पाइपिंग के एक कमांड के माध्यम से इसे करने के लिए एक संसाधन-कुशल तरीका है।

Comments

Btw, -1 निहित है, जब आउटपुट एक पाइप में जाता है

— enzotib

@enzotib - यह है? वाह ... एक हर दिन कुछ नया सीखता है!

— लुइस माचूका

Answer 4

तुलना का एक और बिंदु। शेल ऑनलाइनर नहीं होने के बावजूद, यह सी प्रोग्राम कुछ भी शानदार नहीं करता है। ध्यान दें कि छिपी हुई फ़ाइलों को आउटपुट के पहली पंक्ति में कुल ब्लॉक के कारण 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);
}

Comments

readdir()Stdio API का उपयोग करने से कुछ ओवरहेड जुड़ जाता है और आपको अंतर्निहित सिस्टम कॉल ( getdentsलिनक्स पर) को दिए गए बफर के आकार पर नियंत्रण नहीं देता है

— स्टीफन चेज़लस

Answer 5

तुम कोशिश कर सकते हो perl -e 'opendir($dh,".");$i=0;while(readdir $dh){$i++};print "$i\n";'

अपने शेल पाइप के साथ समय की तुलना करना दिलचस्प होगा।

Comments

मेरी परीक्षण पर, यह तीन अन्य सबसे तेजी से समाधान (जैसा कि काफी ठीक उसी गति रहती है find -maxdepth 1 | wc -l, \ls -AU | wc -lऔर zshआधारित गैर छंटाई ग्लोब और सरणी गिनती)। दूसरे शब्दों में यह विभिन्न असंगतताओं जैसे विकल्पों को छांटने या बाहरी फ़ाइल गुणों को पढ़ने से रोकता है। मैं यह कहने के लिए उद्यम करूंगा क्योंकि यह आपको कुछ भी अर्जित नहीं करता है, यह एक सरल समाधान का उपयोग करने के लायक नहीं है जब तक कि आप पहले से ही पर्ल में न हों :)

— कालेब

ध्यान दें कि यह शामिल होंगे .और ..ताकि आप फ़ाइलों को (और उप निर्देशिकाओं) की वास्तविक संख्या प्राप्त करने के लिए दो घटाना करने की जरूरत है, गिनती में निर्देशिका प्रविष्टियों। आधुनिक पर्ल में, perl -E 'opendir $dh, "."; $i++ while readdir $dh; say $i - 2'यह करना होगा।

— इल्मरी करोनें

Answer 6

से इस जवाब , मैं एक संभव समाधान के रूप में यह एक के बारे में सोच सकते हैं।

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

सी प्रोग्राम को उपरोक्त निर्देशिका में कॉपी करें जिसमें फाइलों को सूचीबद्ध करने की आवश्यकता है। फिर इन आदेशों पर अमल करें:

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

Comments

कुछ चीजें: 1) यदि आप इसके लिए एक कस्टम प्रोग्राम का उपयोग करने के लिए तैयार हैं, तो आप बस फाइलों को गिन सकते हैं और गिनती प्रिंट कर सकते हैं; 2) के साथ तुलना करने के लिए ls -f, बिल्कुल भी फ़िल्टर न d_typeकरें d->d_ino != 0; 3) के लिए 2 घटाना .और ..।

— माटी डेविड

एक टाइमिंग उदाहरण के लिए जुड़ा हुआ उत्तर देखें जहां यह स्वीकृत की तुलना में 40 गुना तेज है ls -f।

— मतेई डेविड

Answer 7

एक बैश-केवल समाधान, किसी भी बाहरी कार्यक्रम की आवश्यकता नहीं है, लेकिन यह नहीं जानते कि कितना कुशल है:

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

Comments

ग्लोब विस्तार ऐसा करने के लिए सबसे अधिक संसाधन कुशल तरीका आवश्यक नहीं है। अधिकांश गोले के अलावा उन वस्तुओं की संख्या के लिए एक ऊपरी सीमा होती है जो वे भी संसाधित करेंगे ताकि यह संभवतः एक मिलियन से अधिक वस्तुओं के साथ काम करते समय बम होगा, यह आउटपुट को भी सॉर्ट करता है। बिना हल के विकल्पों को खोजने या एलएस से जुड़े समाधान तेज होंगे।

— कालेब

@ कालेब, केवल ksh के पुराने संस्करणों में ऐसी सीमाएँ थीं (और उस वाक्यविन्यास का समर्थन नहीं किया) AFAIK। अन्य सभी गोले में, सीमा केवल उपलब्ध स्मृति है। आपको एक बिंदु मिला है कि यह बहुत ही अकुशल होने वाला है, विशेष रूप से बैश में।

— स्टीफन चेजलस

Answer 8

संभवतः सबसे संसाधन कुशल तरीका कोई बाहरी प्रक्रिया चालान शामिल नहीं करेगा। इसलिए मैं दांव पर लगाऊंगा ...

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

Comments

रिश्तेदार नंबर मिला? कितनी फाइलों के लिए?

— स्माइली

Answer 9

@Joel के उत्तर से समस्या को हल करने के बाद, जहाँ इसे .एक फ़ाइल के रूप में जोड़ा गया है:

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

tailबस पहली पंक्ति को हटा देता है, जिसका अर्थ है कि .अब और नहीं गिना जाता है।

Comments

wcइनपुट की एक पंक्ति को छोड़ने के लिए पाइप की एक जोड़ी को जोड़ना बहुत कुशल नहीं है क्योंकि इनपुट आकार के संबंध में ओवरहेड रैखिक रूप से बढ़ता है । इस मामले में, क्यों नहीं अंतिम क्षति की भरपाई करने के लिए इसे एक-एक करके बंद कर दिया जाए, जो एक निरंतर समय ऑपरेशन है:echo $(( $(find /foo/foo2 -maxdepth 1 | wc -l) - 1))

— थॉमस निमन

किसी अन्य प्रक्रिया के माध्यम से उस डेटा को फीड करने के बजाय, संभवतः अंतिम आउटपुट पर कुछ गणित करना बेहतर होगा। let count = $(find /foo/foo2 -maxdepth 1 | wc -l) - 2

— कालेब

Answer 10

अजगर में os.listdir () आपके लिए काम कर सकता है। यह विशेष को छोड़कर, निर्देशिका की सामग्री का एक सरणी देता है। ' और '..' फाइलें। इसके अलावा, नाम में '\ n' जैसे विशेष वर्ण वाली abt फ़ाइलों को चिंता करने की कोई आवश्यकता नहीं है।

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

निम्नलिखित समय एलियन कमांड के साथ तुलना में उपरोक्त पायथन कमांड द्वारा लिया गया समय है।

~ / परीक्षण $ समय ls -Af | wc -l
399,144

असली 0m0.300s
उपयोगकर्ता 0m0.104s
sys 0m0.240s
~ / परीक्षण $ समय अजगर -c 'आयात os; प्रिंट लेन (os.listdir ("।"))
399,142

वास्तविक 0m0.249s
उपयोगकर्ता 0m0.064s
sys 0m0.180s

Answer 11

ls -1 | wc -lमेरे दिमाग में तुरंत आता है। चाहे विशुद्ध रूप से अकादमिक ls -1Uसे तेज हो ls -1- अंतर नगण्य होना चाहिए लेकिन बहुत बड़ी निर्देशिकाओं के लिए।

Answer 12

गिनती से उपनिर्देशिका को बाहर करने के लिए , यहां गिले से स्वीकार किए गए उत्तर पर भिन्नता है:

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

बाहरी $(( ))अंकगणितीय विस्तार $( )पहले से दूसरे उपधारा के उत्पादन को घटाता है $( )। पहला $( )ऊपर से 'गिल्स' है। दूसरा $( )निर्देशिकाओं की गिनती को "लक्ष्य से जोड़ने" के लिए आउटपुट करता है। यह आता है ls -od( ls -ldयदि वांछित है तो स्थानापन्न ), जहां हार्ड लिंक की गिनती को सूचीबद्ध करने वाले कॉलम में निर्देशिकाओं के लिए एक विशेष अर्थ है। "लिंक" गिनती भी शामिल है ., ..और किसी भी उपनिर्देशिका।

मैंने प्रदर्शन का परीक्षण नहीं किया, लेकिन यह समान प्रतीत होगा। यह लक्ष्य निर्देशिका की एक प्रति जोड़ता है, और अतिरिक्त उपधारा और पाइप के लिए कुछ ओवरहेड।

Answer 13

मुझे लगता है कि गूंज * किसी भी 'ls' कमांड की तुलना में अधिक कुशल होगी:

echo * | wc -w

Comments

उनके नाम की जगह वाली फाइलों के बारे में क्या? echo 'Hello World'|wc -wपैदा करता है 2।

— जोसेफ आर।

@JosephR। कैविट

— एम्प्टर