बनाम बाश में मिल जाए

Question

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

1. एक forलूप का उपयोग करें :

   for f in *; do
       echo "$f"
   done

2. उपयोग find:

   find * -prune | while read f; do 
       echo "$f"
   done

इन दो छोरों को मानने से फाइलों की एक ही सूची मिल जाएगी, उन दो विकल्पों में क्या अंतर हैं जो कि पूर्णता और हैंडलिंग में हैं?

Comments

क्यूं कर? findयह पाया फ़ाइलों को नहीं खोलता है। बड़ी संख्या में फ़ाइलों के संबंध में केवल एक चीज जिसे मैं आपको काटता हुआ देख सकता हूं वह है ARG_MAX ।

— कोजिरो

उन उत्तरों और टिप्पणियों को देखें जो आपको बताती हैं कि read fफ़ाइल नामों को मैंग्ल करेगी क्योंकि यह उन्हें पढ़ता है (उदाहरण के लिए प्रमुख रिक्त स्थान वाले नाम)। यह भी find * -pruneकहने के लिए एक बहुत जटिल तरीका लगता है ls -1हाँ?

— इयान डी। एलन

यह मत समझो कि दो छोरों को फाइलों का एक ही सेट मिलेगा; ज्यादातर मामलों में, वे नहीं करेंगे। इसके अलावा, यह होना चाहिए find ., नहीं find *।

— एलेक्सिस

@terdon हाँ, पार्स ls -lकरना एक बुरा विचार है। लेकिन पार्सिंग ls -1(यह एक 1नहीं है l) पार्सिंग से भी बदतर नहीं है find * -prune। दोनों नामों में नई सुर्खियों वाली फाइलों में असफल हैं।

— इयान डी। एलन

मुझे संदेह है कि हमने प्रत्येक समय इस प्रश्न और प्रतिक्रियाओं को पढ़ने में अधिक समय बिताया है क्योंकि प्रश्न में स्क्रिप्ट के जीवन पर प्रदर्शन में कुल अंतर से अधिक है।

— mpez0

Answer 1

1।

पहले वाला:

for f in *; do
  echo "$f"
done

फाइल के लिए विफल रहता है -n, -eऔर -neneकुछ बैश तैनाती के साथ और वैरिएंट के साथ, बैकलेश युक्त फ़ाइल नाम के साथ।

दूसरा:

find * -prune | while read f; do 
  echo "$f"
done

और भी अधिक मामलों के लिए विफल रहता है (फ़ाइलों कहा जाता है !, -H, -name, (, फ़ाइल नाम है कि शुरू करने या रिक्त स्थान के साथ अंत या नई पंक्ति वर्ण हो ...)

यह वह खोल है जो फैलता है *, findकुछ भी नहीं करता है लेकिन इसे प्राप्त फाइलों को तर्क के रूप में प्रिंट करता है। आप के रूप में अच्छी तरह से इस्तेमाल किया जा सकता है printf '%s\n'जो के रूप printfमें बनाया गया है भी कई संभावित संभावित त्रुटि से बचना होगा ।

2।

के विस्तार *को क्रमबद्ध किया गया है, यदि आप छंटाई की आवश्यकता नहीं है, तो आप इसे थोड़ा तेज़ कर सकते हैं। इन zsh:

for f (*(oN)) printf '%s\n' $f

या केवल:

printf '%s\n' *(oN)

bashजहाँ तक मैं बता सकता हूँ, उसके बराबर नहीं है, इसलिए आपको इसका सहारा लेना होगा find।

3।

find . ! -name . -prune ! -name '.*' -print0 |
  while IFS= read -rd '' f; do
    printf '%s\n' "$f"
  done

(एक GNU / BSD -print0गैर-मानक विस्तार का उपयोग करके ऊपर )।

इसमें अभी भी एक खोज कमांड को शामिल करना और एक धीमी while readलूप का उपयोग करना शामिल है , इसलिए यह संभवतः forलूप का उपयोग करने की तुलना में धीमा होगा जब तक कि फ़ाइलों की सूची विशाल न हो।

4।

इसके अलावा, शेल वाइल्डकार्ड के विस्तार के विपरीत, प्रत्येक फ़ाइल पर findएक lstatसिस्टम कॉल करेगा, इसलिए यह संभव नहीं है कि गैर-छंटाई उस के लिए क्षतिपूर्ति करेगी।

GNU / BSD के साथ find, उनके -maxdepthविस्तार का उपयोग करके इससे बचा जा सकता है जो एक अनुकूलन बचत को ट्रिगर करेगा lstat:

find . -maxdepth 1 ! -name '.*' -print0 |
  while IFS= read -rd '' f; do
    printf '%s\n' "$f"
  done

क्योंकि findजैसे ही उन्हें (stdio आउटपुट बफ़रिंग को छोड़कर) यह फ़ाइल नामों को आउटपुट करना शुरू कर देता है, जहाँ यह तेज़ हो सकता है यदि आप लूप में जो कर रहे हैं वह समय लेने वाला है और फ़ाइल नामों की सूची एक stdio बफर से अधिक है (4) / 8 केबी)। उस स्थिति में, लूप के भीतर प्रसंस्करण शुरू हो जाएगा इससे पहले findकि सभी फाइलों को ढूंढना समाप्त हो जाए। जीएनयू और फ्रीबीएसडी सिस्टम पर, आप इसका उपयोग stdbufजल्द से जल्द (स्टीडियो बफरिंग को अक्षम करने) करने के लिए कर सकते हैं ।

5।

POSIX / मानक / पोर्टेबल तरीका के साथ प्रत्येक फ़ाइल के लिए कमांड चलाने के लिए विधेय findका उपयोग करना -execहै:

find . ! -name . -prune ! -name '.*' -exec some-cmd {} ';'

echoहालांकि, इस मामले में शेल में लूपिंग करने की तुलना में कम कुशल है क्योंकि शेल का एक अंतर्निहित संस्करण होगा , echoजबकि findएक नई प्रक्रिया को स्पॉन करने और /bin/echoप्रत्येक फ़ाइल के लिए इसे निष्पादित करने की आवश्यकता होगी ।

यदि आपको कई कमांड चलाने की आवश्यकता है, तो आप कर सकते हैं:

find . ! -name . -prune ! -name '.*' -exec cmd1 {} ';' -exec cmd2 {} ';'

लेकिन सावधान रहें जो सफल होने पर cmd2ही निष्पादित होता cmd1है।

6।

प्रत्येक फ़ाइल के लिए जटिल कमांड चलाने के लिए एक कैनोनिकल तरीका है -exec ... {} +:

find . ! -name . -prune ! -name '.*' -exec sh -c '
  for f do
    cmd1 "$f"
    cmd2 "$f"
  done' sh {} +

उस समय के बाद से, हम कुशल होने के साथ वापस आ गए हैं echoक्योंकि हम shबिल्टइन का उपयोग कर रहे हैं और -exec +संस्करण shजितना संभव हो उतना कम हो।

7।

में 200.000 फाइलों के साथ एक निर्देशिका पर मेरी परीक्षण ext4 पर कम नामों के साथ, zshएक (अनुच्छेद 2.), अब तक सबसे तेजी से कर रहा है पहले सरल के बाद for i in *पाश (हालांकि हमेशा की तरह, bashएक बहुत कि के लिए अन्य गोले की तुलना में धीमी है)।

Comments

!खोज आदेश में क्या करता है ?

— रूबों

@ rubo77, !नकार के लिए है। ! -name . -prune more...क्या करेंगे -prune(और more...के बाद से -pruneहमेशा सच रिटर्न) हर फ़ाइल लेकिन के लिए .। तो यह more...सभी फाइलों .पर करेगा, लेकिन बाहर .नहीं निकलेगा और उपनिर्देशिकाओं में नहीं उतरेगा .। तो यह जीएनयू का मानक समकक्ष है -mindepth 1 -maxdepth 1।

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

Answer 2

मैंने 2259 प्रविष्टियों के साथ एक निर्देशिका पर यह कोशिश की, और timeकमांड का उपयोग किया ।

का आउटपुट time for f in *; do echo "$f"; done(माइनस द फाइल्स!) है:

real    0m0.062s
user    0m0.036s
sys     0m0.012s

का आउटपुट time find * -prune | while read f; do echo "$f"; done(माइनस द फाइल्स!) है:

real    0m0.131s
user    0m0.056s
sys     0m0.060s

मैंने प्रत्येक कमांड को कई बार चलाया, ताकि कैश मिस को खत्म किया जा सके। यह बात ध्यान में रखते हुए पता चलता है bash(में मैं के लिए ...) का उपयोग कर से ज़्यादा तेज़ है findऔर उत्पादन पाइप (करने के लिए bash)

पूर्णता के लिए, मैंने पाइप को गिरा दिया find, क्योंकि आपके उदाहरण में, यह पूरी तरह से निरर्थक है। बस find * -pruneका उत्पादन है:

real    0m0.053s
user    0m0.016s
sys     0m0.024s

इसके अलावा, time echo *(उत्पादन अलग नहीं है, अलग है):

real    0m0.009s
user    0m0.008s
sys     0m0.000s

इस बिंदु पर, मुझे संदेह है कि इसका कारण echo *यह है कि यह बहुत सी नई लाइनों को आउटपुट नहीं कर रहा है, इसलिए आउटपुट उतना स्क्रॉल नहीं कर रहा है। आइए परीक्षण करते हैं ...

time find * -prune | while read f; do echo "$f"; done > /dev/null

पैदावार:

real    0m0.109s
user    0m0.076s
sys     0m0.032s

जबकि time find * -prune > /dev/nullपैदावार:

real    0m0.027s
user    0m0.008s
sys     0m0.012s

और time for f in *; do echo "$f"; done > /dev/nullपैदावार:

real    0m0.040s
user    0m0.036s
sys     0m0.004s

और अंत में: time echo * > /dev/nullपैदावार:

real    0m0.011s
user    0m0.012s
sys     0m0.000s

भिन्नता के कुछ यादृच्छिक कारकों के कारण हो सकता है, लेकिन यह स्पष्ट लगता है:

• उत्पादन धीमा है
• पाइपिंग में थोड़ा खर्च होता है
• for f in *; do ...की तुलना में धीमी है find * -prune, लेकिन पाइपों को शामिल करने से ऊपर निर्माण के लिए, तेज है।

इसके अलावा, एक तरफ के रूप में, दोनों दृष्टिकोण ठीक ठिकानों के साथ नामों को संभालने के लिए दिखाई देते हैं।

संपादित करें:

find . -maxdepth 1 > /dev/nullबनाम के लिए समय find * -prune > /dev/null:

time find . -maxdepth 1 > /dev/null:

real    0m0.018s
user    0m0.008s
sys     0m0.008s

find * -prune > /dev/null:

real    0m0.031s
user    0m0.020s
sys     0m0.008s

तो, अतिरिक्त निष्कर्ष:

• find * -pruneकी तुलना में धीमी है find . -maxdepth 1- पूर्व में, शेल एक ग्लोब को संसाधित कर रहा है, फिर एक (बड़ी) कमांड लाइन के लिए निर्माण कर रहा है find। NB: find . -pruneबस लौटता है .।

अधिक परीक्षण time find . -maxdepth 1 -exec echo {} \; >/dev/null:

real    0m3.389s
user    0m0.040s
sys     0m0.412s

निष्कर्ष:

• अब तक का सबसे धीमा तरीका। जैसा कि इस दृष्टिकोण के सुझाव के उत्तर के लिए टिप्पणियों में बताया गया था, प्रत्येक तर्क एक खोल देता है।

Comments

कौन सा पाइप बेमानी है? क्या आप पाइप के बिना इस्तेमाल की गई लाइन दिखा सकते हैं?

— रूबों 77

@ rubo77 find * -prune | while read f; do echo "$f"; doneमें निरर्थक पाइप है - जो सभी पाइप कर रहे हैं वह बिल्कुल वही findआउटपुट कर रहा है जो स्वयं आउटपुट करता है। एक पाइप के बिना, यह बस होगा find * -prune । पाइप केवल विशेष रूप से बेमानी है क्योंकि पाइप के दूसरी तरफ की चीज बस स्टड को स्टडआउट (अधिकांश भाग के लिए) की प्रतिलिपि बनाती है। यह महंगा नो-ऑप है। यदि आप खोज के आउटपुट के साथ सामान करना चाहते हैं, तो इसके अलावा सिर्फ इसे फिर से बाहर थूकने के लिए, वह अलग है।

— फिल

हो सकता है कि मुख्य timeconsuming है *। के रूप में BitsOfNix ने कहा: मैं अभी भी दृढ़ता से उपयोग नहीं करने के लिए सुझाव *और .के लिए findके बजाय।

— रबॉउन 7

@ rubo77 ऐसा लगता है। मुझे लगता है कि मैंने उसकी अनदेखी की। मैंने अपने सिस्टम के लिए निष्कर्ष जोड़े हैं। मुझे लगता है find . -pruneकि तेजी से है क्योंकि findएक निर्देशिका प्रविष्टि शब्दशः पढ़ा जाएगा, जबकि शेल इसी तरह, संभवतः ग्लोब के खिलाफ मिलान (के लिए अनुकूलित कर सकते हैं *), तब के लिए बड़ी कमांड लाइन का निर्माण होगा find।

— फिल

find . -prune.मेरे सिस्टम पर ही प्रिंट करता है। यह लगभग कोई काम नहीं करता है। यह बिल्कुल वैसा नहीं है जैसा find * -pruneकि वर्तमान निर्देशिका के सभी नामों को दर्शाता है। एक नंगे read fअग्रणी स्थानों के साथ फ़ाइल नामों को मैंग करेगा।

— इयान डी। एलन

Answer 3

मैं खोजने के साथ निश्चित रूप से जाऊंगा, हालांकि मैं आपके खोज को बस इस में बदल दूंगा:

find . -maxdepth 1 -exec echo {} \;

प्रदर्शन के लिहाज से, findआपकी ज़रूरतों के आधार पर बहुत तेज़ है। आपके पास वर्तमान में forइसके साथ केवल वर्तमान निर्देशिका में फ़ाइलें / निर्देशिकाएं प्रदर्शित होंगी, लेकिन निर्देशिका सामग्री नहीं। यदि आप पाते हैं कि यह उप-निर्देशिका की सामग्री को भी दिखाएगा।

मैं कहता हूँ खोजने के साथ के बाद से बेहतर है अपने पहले विस्तार करना होगा और मुझे डर है कि अगर आप फ़ाइलों की एक बड़ी राशि के साथ एक निर्देशिका है यह त्रुटि दे सकता हूँ तर्क सूची बहुत लंबा । उसी के लिए जाता हैfor*find *

एक उदाहरण के रूप में, उन प्रणालियों में से एक जिसका मैं वर्तमान में उपयोग करता हूं, 2 मिलियन से अधिक फाइलों के साथ निर्देशिकाओं का एक जोड़ा है (<100k प्रत्येक):

find *
-bash: /usr/bin/find: Argument list too long

Comments

मैंने -pruneदो उदाहरणों को और अधिक समान बनाने के लिए जोड़ा । और मैं पाइप को पसंद करता हूं, जबकि लूप में अधिक कमांड लागू करना आसान है

— रुबो 7

आप डेबियन में "बहुत खुली फाइलें"

— '22

हार्ड सीमा को बदलना मेरे POV से एक उचित समाधान है। विशेष रूप से 2+ मिलियन फ़ाइलों के बारे में बात करते समय। प्रश्न से विषयांतर के बिना, सरल मामलों के लिए एक स्तर निर्देशिका के रूप में तेज़ है, लेकिन यदि आप अपनी फ़ाइल / निर्देशिका संरचना को बदलते हैं, तो इसे स्थानांतरित करना कठिन होगा। जबकि खोज के साथ और यह बड़ी मात्रा में विकल्प हैं जिन्हें आप बेहतर तरीके से तैयार कर सकते हैं। फिर भी मैं अभी भी दृढ़ता से * और का उपयोग नहीं करने का सुझाव देता हूं। बजाय खोजने के लिए। यह * की तुलना में अधिक पोर्टेबल होगा जहाँ आप हार्डलिमिट को नियंत्रित करने में सक्षम नहीं हो सकते हैं ...

— BitsOfNix

वह प्रति फ़ाइल एक प्रतिध्वनि प्रक्रिया को स्पॉन करेगा (जबकि लूप के लिए शेल में, यह इको बिल्ड है जो एक अतिरिक्त प्रक्रिया को फोर्क किए बिना उपयोग किया जाएगा), और निर्देशिकाओं में उतर जाएगा, इसलिए यह बहुत धीमा होगा । यह भी ध्यान दें कि इसमें डॉट फाइलें शामिल होंगी।

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

आप सही हैं, मैंने मैक्सडेप 1 को जोड़ा ताकि यह केवल वर्तमान स्तर तक ही चिपके रहे।

— BitsOfNix

Answer 4

find * -prune | while read f; do 
    echo "$f"
done

का एक बेकार उपयोग है find- आप जो कह रहे हैं वह प्रभावी रूप से "निर्देशिका में प्रत्येक फ़ाइल के लिए" है ( *), किसी भी फ़ाइल को न ढूंढें। इसके अलावा, यह कई कारणों से सुरक्षित नहीं है:

• पथ में बैकस्लैश को विशेष रूप से -rविकल्प के बिना व्यवहार किया जाता है read। यह forलूप के साथ कोई समस्या नहीं है ।
• रास्तों में नयापन लूप के अंदर किसी भी गैर-तुच्छ कार्यक्षमता को तोड़ देगा। यह forलूप के साथ कोई समस्या नहीं है ।

किसी भी फ़ाइल नाम findको संभालना मुश्किल है , इसलिए आपको forअकेले जब भी संभव हो , लूप विकल्प का उपयोग करना चाहिए । इसके अलावा, एक बाहरी प्रोग्राम चलाना जैसे findकि आंतरिक लूप कमांड चलाने की तुलना में सामान्य रूप से धीमा होगा for।

Comments

@ I0b0 क्या पाते हैं -path 'के बारे में ।/*' -prune या find -path './। ./* '-prune -print0 | xargs -0 sh -c '...'?

— AsymLabs

न तो findकी -print0है और न ही xargs' -0POSIX संगत हैं, और आप में मनमाने ढंग से आदेशों नहीं डाल सकते sh -c ' ... ', (एकल उद्धरण एकल उद्धरण के भीतर का उपयोग नहीं किया जा सकता है), तो यह काफी इतना आसान नहीं है।

— l0b0

Answer 5

लेकिन हम प्रदर्शन सवालों के लिए चूसने वाले हैं! यह अनुरोध-दर-प्रयोग कम से कम दो धारणाएँ बनाता है जो इसे बहुत वैध नहीं बनाती हैं।

ए। मान लें कि वे एक ही फाइल पाते हैं ...

खैर, वे होगा एक ही फाइल को पहली बार में, क्योंकि वे एक ही ग्लोब पर दोनों बार-बार दोहराना कर रहे हैं, अर्थात् लगता है *। लेकिन find * -prune | while read fकई दोषों से ग्रस्त है जो इसे काफी संभव बनाते हैं यह उन सभी फाइलों को नहीं मिलेगा जो आप उम्मीद करते हैं:

1. POSIX खोज एक से अधिक पथ तर्क को स्वीकार करने की गारंटी नहीं है। अधिकांश findकार्यान्वयन करते हैं, लेकिन फिर भी, आपको उस पर भरोसा नहीं करना चाहिए।
2. find *तोड़ सकते हैं जब आप हिट ARG_MAX। for f in *नहीं बनाया जाएगा, क्योंकि नहीं, ARG_MAXलागू होता है exec।
3. while read fव्हाट्सएप के साथ शुरू और समाप्त होने वाले फाइलनेम से टूट सकता है, जो बंद हो जाएगा। आप while readइसके साथ और इसके डिफ़ॉल्ट पैरामीटर पर काबू पा सकते हैं REPLY, लेकिन फिर भी यह आपकी मदद नहीं करेगा, जब यह उन में नए नाम के साथ फाइल करने के लिए आता है।

बी echo। कोई भी ऐसा नहीं करने जा रहा है, केवल फ़ाइल का नाम गूंजने के लिए। यदि आप चाहते हैं कि, बस इनमें से एक करें:

printf '%s\n' *
find . -mindepth 1 -maxdepth 1 # for dotted names, too

whileयहाँ लूप के लिए पाइप एक अंतर्निहित उप-प्रकार बनाता है जो लूप के समाप्त होने पर बंद हो जाता है, जो कुछ के लिए अनपेक्षित हो सकता है।

प्रश्न का उत्तर देने के लिए, मेरी एक निर्देशिका में परिणाम हैं जिसमें 184 फाइलें और निर्देशिकाएं हैं।

$ time bash -c 'for i in {0..1000}; do find * -prune | while read f; do echo "$f"; done >/dev/null; done'

real    0m7.998s
user    0m5.204s
sys 0m2.996s
$ time bash -c 'for i in {0..1000}; do for f in *; do echo "$f"; done >/dev/null; done'

real    0m2.734s
user    0m2.553s
sys 0m0.181s
$ time bash -c 'for i in {0..1000}; do printf '%s\n' * > /dev/null; done'

real    0m1.468s
user    0m1.401s
sys 0m0.067s

$ time bash -c 'for i in {0..1000}; do find . -mindepth 1 -maxdepth 1 >/dev/null; done '

real    0m1.946s
user    0m0.847s
sys 0m0.933s

Comments

मैं इस कथन से सहमत नहीं हूँ, जबकि लूप एक सब-स्पेल को कम करता है - सबसे खराब स्थिति में, एक नया सूत्र: निम्न पहले और बाद में दिखाने की कोशिश कर रहा है, खराब स्वरूपण के लिए माफी$ ps ax | grep bash 20784 pts/1 Ss 0:00 -bash 20811 pts/1 R+ 0:00 grep bash $ while true; do while true; do while true; do while true; do while true; do sleep 100; done; done; done; done; done ^Z [1]+ Stopped sleep 100 $ bg [1]+ sleep 100 & $ ps ax | grep bash 20784 pts/1 Ss 0:00 -bash 20924 pts/1 S+ 0:00 grep bash

— फिल

तकनीकी रूप से मुझे याद आती है: पाइप अंतर्निहित उपशमन का कारण बनता है, जबकि लूप नहीं। मैं संपादित करूँगा।

— कोजीरो

Answer 6

find *यदि *पथ के बजाय विधेय की तरह दिखने वाले टोकन का उत्पादन किया जाए तो यह सही काम नहीं करेगा ।

आप इसे --ठीक करने के लिए सामान्य तर्क का उपयोग नहीं कर सकते क्योंकि --विकल्पों के अंत को इंगित करता है, और खोजने के विकल्प रास्तों से पहले आते हैं।

इस समस्या को ठीक करने के लिए आप find ./*इसके बजाय उपयोग कर सकते हैं । लेकिन तब यह बिल्कुल वैसा ही उत्पादन नहीं कर रहा है जैसा कि तार for x in *।

ध्यान दें कि find ./* -prune | while read f ..वास्तव में स्कैनिंग कार्यक्षमता का उपयोग नहीं करता है find। यह ग्लोबिंग सिंटैक्स है ./*जो वास्तव में डायरेक्टरी का पता लगाता है और नाम उत्पन्न करता है। फिर findप्रोग्राम को statउन नामों में से प्रत्येक पर कम से कम एक चेक करना होगा। आपके पास प्रोग्राम लॉन्च करने और इसे इन फ़ाइलों तक पहुंचने का ओवरहेड है, और फिर इसका आउटपुट पढ़ने के लिए I / O कर रहा है।

यह कल्पना करना कठिन है कि यह कुछ भी हो सकता है लेकिन इससे कम कुशल for x in ./* ...।

Answer 7

शुरुआत के लिए अच्छी तरह forसे एक खोल कीवर्ड है, जो बैश में बनाया गया है, जबकि findएक अलग निष्पादन योग्य है।

$ type -a for
for is a shell keyword

$ type -a find
find is /usr/bin/find

forजब वह फैलता पाश केवल globstar चरित्र से फाइल मिल जाएगा, यह यह पाता है किसी भी निर्देशिका में recurse नहीं होंगे।

दूसरे पर खोजें ग्लोबस्टार द्वारा विस्तारित एक सूची भी दी जाएगी, लेकिन यह इस विस्तारित सूची के नीचे सभी फाइलों और निर्देशिकाओं को पुन: खोजेगा और प्रत्येक को whileलूप के माध्यम से पाइप करेगा ।

इन दोनों दृष्टिकोणों को इस अर्थ में खतरनाक माना जा सकता है कि वे उन रास्तों या फ़ाइलनामों को नहीं संभालते हैं जिनमें रिक्त स्थान होते हैं।

इस बारे में मैं इन 2 दृष्टिकोणों पर टिप्पणी करने के लायक सोच सकता हूं।

Comments

मैंने -आदेश को कमांड को जोड़ा, इसलिए वे एक जैसे हैं।

— रूबो77 7

Answer 8

यदि सभी फाइलें ढूंढकर लौटी हैं, तो उन्हें एक ही कमांड द्वारा संसाधित किया जा सकता है (स्पष्ट रूप से ऊपर आपके इको उदाहरण पर लागू नहीं होता है), आप xgs का उपयोग कर सकते हैं:

find * |xargs some-command

Answer 9

वर्षों से मैं इसका उपयोग कर रहा हूं: -

find . -name 'filename'|xargs grep 'pattern'|more

कुछ फ़ाइलों (जैसे * .txt) को देखने के लिए जिसमें एक ऐसा पैटर्न होता है जिसे grep देख सकते हैं और इसे अधिक पाइप कर सकते हैं ताकि यह स्क्रीन को स्क्रॉल न करे। कभी-कभी मैं किसी अन्य फ़ाइल को परिणाम लिखने के लिए >> पाइप का उपयोग करता हूं जिसे मैं बाद में देख सकता हूं।

यहाँ परिणाम का एक नमूना है: -

./Documents/Organ_docos/Rodgerstrio321A/rodgersmylist/2008-August.txt:Message-ID: <[e-mail]>
./Documents/Organ_docos/Rodgerstrio321A/rodgersmylist/2008-August.txt:In-Reply-To: <[e-mail]>
./Documents/Organ_docos/Rodgerstrio321A/rodgersmylist/2008-August.txt:  <[e-mail]>
./Documents/Organ_docos/Rodgerstrio321A/rodgersmylist/2008-August.txt:  <[e-mail]>
./Documents/Organ_docos/Rodgerstrio321A/rodgersmylist/2008-August.txt:Message-ID: <448E53556A3F442ABC58203D6281923E@hypermax>
./Documents/Organ_docos/Rodgerstrio321A/rodgersmylist/2011-April.txt:URL: http://mylist.net/private/rodgersorganusers/attachments/20110420/3f