क्विक एलएस कमांड

Question

मुझे एक निर्देशिका सूची प्राप्त करना है जिसमें लगभग 2 मिलियन फाइलें हैं, लेकिन जब मैं ls कमांड करता हूं तो कुछ भी वापस नहीं आता है। मैंने 3 घंटे इंतजार किया है। मैंने ls | tee directory.txt की कोशिश की है, लेकिन ऐसा लगता है कि हमेशा के लिए लटका हुआ है।

मुझे लगता है कि सर्वर बहुत सारे इनोड सॉर्टिंग कर रहा है। क्या फ़ाइल नामों की निर्देशिका सूची प्राप्त करने के लिए ls कमांड को गति देने का कोई तरीका है? मुझे इस समय आकार, तिथियां, अनुमति या इस तरह की परवाह नहीं है।

Answer 1

कैसे find ./ -type f (जो वर्तमान में निर्देशिका में सभी फाइलें पायेगा)? सब कुछ खोजने के लिए -type f हटाएं।

Answer 2

उपयोग करके देखें:

find . -type f -maxdepth 1 

यह केवल निर्देशिका में फ़ाइलों को सूची जाएगा, बाहर छोड़ -type f तर्क यदि आप फ़ाइलों और निर्देशिकाओं सूचीबद्ध करना चाहते हैं।

Answer 3

इन्हें आज़माएं:

चेक ls एलियास नहीं है?

alias ls 

शायद इसके बजाय खोजने का प्रयास करें?

find . \(-type d -name . -prune \) -o \(-type f -print \) 

उम्मीद है कि इससे मदद मिलती है।

Answer 4

आप आउटपुट को रीडायरेक्ट कर सकते हैं और पृष्ठभूमि में एलएस प्रक्रिया चला सकते हैं।

ls > myls.txt & 

इससे आपको चलते समय अपने व्यवसाय के बारे में जानकारी मिल जाएगी। यह आपके खोल को बंद नहीं करेगा।

एलएस चलाने और कम डेटा वापस पाने के लिए कौन से विकल्प हैं, इस बारे में निश्चित नहीं है। आप जांचने के लिए हमेशा man ls चला सकते हैं।

Answer 5

मुझे लगता है कि आप जीएनयू एलएस का उपयोग कर रहे हैं? कोशिश

\ls 

यह हमेशा की तरह ls (ls --color = ऑटो) unalias होगा।

Answer 6

ls -U 

सॉर्ट किए बिना एलएस करेगा।

Answer 7

आप किस विभाजन प्रकार का उपयोग कर रहे हैं?

एक निर्देशिका में लाखों छोटी फाइलें होने के कारण जेएफएस या रीइज़रएफएस का उपयोग करना एक अच्छा विचार हो सकता है, जिसमें कई छोटी आकार की फाइलों के साथ बेहतर प्रदर्शन होता है।

Answer 8

आपको ऑपरेटिंग सिस्टम और आपके द्वारा उपयोग किए जा रहे फाइल सिस्टम के प्रकार के बारे में जानकारी प्रदान करनी चाहिए। यूनिक्स और कुछ फाइल सिस्टम के कुछ स्वादों पर आप विकल्प के रूप में ff और ncheck आदेशों का उपयोग करने में सक्षम हो सकते हैं।

Answer 9

यदि कोई प्रक्रिया "वापस नहीं आती" है, तो मैं ऑपरेटिंग सिस्टम के साथ एक प्रक्रिया के साथ कैसे बातचीत कर रहा है इसका विश्लेषण करने के लिए strace की अनुशंसा करता हूं।

ls के मामले में:

$strace ls 

आपने देखा है कि यह सब निर्देशिका प्रविष्टियों (getdents(2)) पढ़ता है इससे पहले कि यह वास्तव में कुछ भी आउटपुट होगा। यहाँ (छँटाई ... के रूप में यह पहले से ही यहाँ उल्लेख किया गया था)

Answer 10

अन्य अच्छे समाधान के बहुत सारे हैं, लेकिन पूर्णता के हित में:

echo * 

Answer 11

तुम भी xargs का उपयोग कर सकते। बस एलएस के आउटपुट xargs के आउटपुट को पाइप करें।

ls | xargs 

कि काम नहीं करता है और ऊपर दिए गए उदाहरणों से काम नहीं कर रहे हैं, के रूप में यह स्मृति के उपयोग कि अपनी समस्याओं का कारण हो सकता मदद कर सकते हैं उन्हें xargs लिए पाइप का प्रयास करें।

Answer 12

कुछ अनुवर्ती: आप यह नहीं बताते कि आप किस ओएस पर चल रहे हैं, जिससे आप यह निर्धारित करने में मदद करेंगे कि आप किस संस्करण का उपयोग कर रहे हैं। यह शायद एक 'bash' सवाल नहीं है जितना एक सवाल है। मेरा अनुमान है कि आप जीएनयू एलएस का उपयोग कर रहे हैं, जिसमें कुछ विशेषताएं हैं जो कुछ संदर्भों में उपयोगी हैं, लेकिन बड़ी निर्देशिकाओं पर आपको मार डालती हैं।

जीएनयू एलएस कॉलम की सुंदर व्यवस्था करने की कोशिश कर रहा है। जीएनयू एलएस सभी फाइलनामों की एक स्मार्ट व्यवस्था करने की कोशिश करता है। एक विशाल निर्देशिका में, इसमें कुछ समय और स्मृति लगेगी।

'फिक्स' इस के लिए, आप की कोशिश कर सकते हैं:

ls -1 # सभी

में कोई कॉलम बीएसडी ls किसी ऐसे स्थान पर, http://www.freebsd.org/cgi/cvsweb.cgi/src/bin/ls/ खोजने के लिए और का उपयोग करें कि अपने बड़े निर्देशिकाओं पर।

अन्य उपकरणों,

Answer 13

लगता है जैसे यह शायद एक मददगार जवाब नहीं है, लेकिन अगर आप की जरूरत नहीं है find आप के साथ tar

$ tar cvf /dev/null . 

मुझे बताया गया है ऐसा करने में सक्षम हो सकता है का उपयोग करें मेरे से बड़े लोगों द्वारा, "दिन में वापस", एकल उपयोगकर्ता और वसूली वातावरण आजकल की तुलना में बहुत सीमित थे। यही वह जगह है जहां से यह चाल आती है।

Answer 14

यह सबसे तेज़ विकल्प AFAIK होगा: ls -1 -f।

• -1 (कोई कॉलम)
• -f (कोई छंटाई)

Answer 15

ऐसे कई तरीके है फ़ाइलों की एक सूची प्राप्त करने के लिए कर रहे हैं: छँटाई के बिना एक सूची प्राप्त करने

इस आदेश का उपयोग करें:

ls -U 

या फाइलों की सूची को आपके द्वारा फाइल में भेजें गाना:

ls /Folder/path > ~/Desktop/List.txt 

Answer 16

का उपयोग

ls -1 -f 

के बारे में 10 गुना तेजी से है और यह करने के लिए आसान है (मैं 1 लाख फाइलों के साथ परीक्षण किया गया है, लेकिन अपने मूल समस्या 6 800 000 000 फ़ाइलें था)

लेकिन मेरे मामले में मुझे यह जांचने की आवश्यकता है कि कुछ विशिष्ट निर्देशिका में 10 000 से अधिक फ़ाइलें हैं या नहीं। अगर 10 000 से अधिक फाइलें थीं, तो मुझे अब दिलचस्पी नहीं है कि कितनी फाइलें हैं। मैंने प्रोग्राम को छोड़ दिया ताकि वह तेजी से दौड़ सके और बाकी को एक-एक करके पढ़ने की कोशिश न करें। यदि 10 000 से कम हैं, तो मैं सही राशि प्रिंट करूंगा। मेरे प्रोग्राम की गति ls -1 -f के समान है यदि आप फ़ाइलों की मात्रा से पैरामीटर के लिए बड़ा मान निर्दिष्ट करते हैं।

आप टाइप करके मौजूदा निर्देशिका में मेरा कार्यक्रम find_if_more.pl उपयोग कर सकते हैं:

find_if_more.pl 999999999 

तुम सिर्फ अगर वहाँ n फ़ाइलों की तुलना में अधिक कर रहे हैं, स्क्रिप्ट बहुत साथ ls की तुलना में तेजी खत्म हो जाएगा -1 -f रुचि रखते हैं बड़ी मात्रा में फाइलें।

#!/usr/bin/perl 
    use warnings; 
    my ($maxcount) = @ARGV; 
    my $dir = '.'; 
    $filecount = 0; 
    if (not defined $maxcount) { 
     die "Need maxcount\n"; 
    } 
    opendir(DIR, $dir) or die $!; 
    while (my $file = readdir(DIR)) { 
     $filecount = $filecount + 1; 
     last if $filecount> $maxcount 
    } 
    print $filecount; 
    closedir(DIR); 
    exit 0; 

Answer 17

यह प्रश्न दिलचस्प लगता है और मैं पोस्ट किए गए कई उत्तरों के माध्यम से जा रहा था। पोस्ट किए गए उत्तरों की दक्षता को समझने के लिए, मैंने उन्हें 2 मिलियन फाइलों पर निष्पादित किया है और परिणाम नीचे दिए गए हैं।

$ time tar cvf /dev/null . &> /tmp/file-count 

real 37m16.553s 
user 0m11.525s 
sys  0m41.291s 

------------------------------------------------------ 

$ time echo ./* &> /tmp/file-count 

real 0m50.808s 
user 0m49.291s 
sys  0m1.404s 

------------------------------------------------------ 

$ time ls &> /tmp/file-count 

real 0m42.167s 
user 0m40.323s 
sys  0m1.648s 

------------------------------------------------------ 

$ time find . &> /tmp/file-count 

real 0m2.738s 
user 0m1.044s 
sys  0m1.684s 

------------------------------------------------------ 

$ time ls -U &> /tmp/file-count 

real 0m2.494s 
user 0m0.848s 
sys  0m1.452s 


------------------------------------------------------ 

$ time ls -f &> /tmp/file-count 

real 0m2.313s 
user 0m0.856s 
sys  0m1.448s 

------------------------------------------------------ 

परिणाम

1. ls -f आदेश ls -U से थोड़ा तेजी से भाग गया संक्षेप में प्रस्तुत करना। रंग को अक्षम करने से इस सुधार का कारण हो सकता है।
2. find आदेश 2.738 सेकंड की औसत गति के साथ तीसरे भाग गया।
3. केवल ls चलने से 42.16 सेकंड लगे। यहां मेरे सिस्टम में lsls --color=auto
4. echo ./* के साथ खोल विस्तार सुविधा का उपयोग 50.80 सेकेंड के लिए चलाया गया है।
5. और tar आधारित समाधान में लगभग 37 मीलियां थीं।

सिस्टम निष्क्रिय स्थिति में होने पर सभी परीक्षण अलग-अलग किए गए थे।

यहां ध्यान देने योग्य एक महत्वपूर्ण बात यह है कि फ़ाइल सूचियों को टर्मिनल में मुद्रित नहीं किया गया है बल्कि उन्हें फ़ाइल में रीडायरेक्ट किया गया था और फ़ाइल गणना की गणना बाद में wc कमांड के साथ की गई थी। स्क्रीन पर मुद्रित आउटपुट के दौरान कमांड बहुत धीमी गति से भाग गया।

कोई विचार क्यों ऐसा होता है?

Answer 18

मैं था

ls -1U