दिलचस्प पोस्ट
एचटीपीएस कनेक्शन एंड्रॉइड एचटीएमएल पेज को लंगर के लिए कैसे स्क्रॉल करें? एक डिवीजन को शेष चौड़ाई भरें HTTP पुनर्निर्देशन: 301 (स्थायी) बनाम 302 (अस्थायी) java.lang.ClassCastException: android.view.ViewGroup $ लेआउटपरारों को एंड्रॉइड के लिए नहीं डाला जा सकता। widget.Gallery $ LayoutParams PHP में ऑब्जेक्ट पर json_encode का उपयोग करना (गुंजाइश की परवाह किए बिना) जावास्क्रिप्ट में ऑब्जेक्ट गुण परिवर्तन के लिए देखें जेएस फ़ाइल को अन्य जेएस फ़ाइल में कैसे शामिल किया जाए? क्या एल्गोरिदम एक बिंदु पर बिंदु A से बी को इंगित करने के लिए निर्देशों की गणना करते हैं? सीएसवी निर्यात करने के लिए jQuery तालिका नोड। जेएसएस के साथ MySQL E.preventDefault () में क्या अंतर है; और झूठी वापसी? सतह के फ्लेक्स के ऑनफ्रेम उपलब्ध () विधि हमेशा बहुत देर तक कहती हैं जावास्क्रिप्ट ऑब्जेक्ट को संदर्भ से नया वैरिएबल नहीं प्रतिलिपि कैसे करें? Memcached के बजाय मुझे मेम्केचे का उपयोग कब करना चाहिए?

आरएम, सीपी, एमवी कमांड्स के लिए तर्क सूची बहुत लंबी त्रुटि है

मेरे यूनिक्स में एक निर्देशिका के अंतर्गत कई सौ पीडीएफ़ हैं पीडीएफ के नाम वास्तव में लंबे हैं (लगभग 60 वर्ण)

जब मैं निम्नलिखित कमांड का उपयोग करके सभी पीडीएफ को एक साथ हटाने की कोशिश करता हूं:

rm -f *.pdf 

मुझे निम्नलिखित त्रुटि मिलती है:

 /bin/rm: cannot execute [Argument list too long] 

इस त्रुटि का समाधान क्या है? क्या mv और cp आज्ञाओं के लिए भी यह त्रुटि होती है? यदि हां, तो इन आदेशों को कैसे हल करें?

वेब के समाधान से एकत्रित समाधान "आरएम, सीपी, एमवी कमांड्स के लिए तर्क सूची बहुत लंबी त्रुटि है"

इसका कारण यह है कि क्योंकि बाश वास्तव में प्रत्येक मिलान फ़ाइल में तारांकन का विस्तार करता है, जो बहुत लंबी कमांड लाइन बनाता है

इसे इस्तेमाल करे:

 find . -name "*.pdf" -print0 | xargs -0 rm 

चेतावनी: यह एक पुनरावर्ती खोज है और उप-निर्देशिकाओं में भी (और हटाना) फ़ाइलें मिल जाएगी आरएफ कमांड के लिए -f पर -f केवल तभी करें जब आप सुनिश्चित हों कि आप पुष्टि नहीं करना चाहते हैं

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

 find . -maxdepth 1 -name "*.pdf" -print0 | xargs -0 rm 

एक और विकल्प है खोजने का उपयोग -delete ध्वज:

 find . -name "*.pdf" -delete 

tl; डॉ

यह कमांड लाइन तर्क के आकार पर एक कर्नेल सीमा है। इसके बजाय एक लूप का उपयोग करें

समस्या की उत्पत्ति

यह एक प्रणाली मुद्दा है, जो execve और ARG_MAX स्थिरांक से संबंधित है इसके बारे में बहुत सारे दस्तावेज हैं (देखें आदमी निष्पादन , डेबियन विकी )।

असल में, यह विस्तार ARG_MAX सीमा से अधिक है जो कमांड (इसके पैरामीटर के साथ) का ARG_MAX है। कर्नेल 2.6.23 , सीमा 128 kB पर सेट की गई थी। यह निरंतर बढ़ गया है और निष्पादित करके आप इसका मूल्य प्राप्त कर सकते हैं:

 getconf ARG_MAX # 2097152 # on 3.5.0-40-generic 

उपाय

लूप के for प्रयोग करें जैसा कि यह बशफाक्यू / 095 पर अनुशंसित है और रैम / मेमोरी स्पेस के अलावा कोई सीमा नहीं है:

 for f in *.pdf; do rm "$f"; done 

इसके अलावा यह पोर्टेबल दृष्टिकोण है क्योंकि ग्लोब के पास गोले ( पॉसिक्स स्पेस का हिस्सा ) के बीच मजबूत और सुसंगत व्यवहार है।

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

 find . -name '*.pdf' -exec rm {} + 

संदर्भ

  • मुझे "तर्क सूची बहुत लंबी" मिल रही है मैं विखंडनों में एक बड़ी सूची कैसे संसाधित कर सकता हूं? @ वूलडेज
  • execve (2) – लिनक्स मैन पेज (ARG_MAX के लिए खोज);
  • त्रुटि: डेबियन विकी @ तर्क सूची बहुत लंबी है ;
  • उद्धृत तर्कों को पारित करते समय मुझे "/ bin / sh: तर्क सूची बहुत अधिक" क्यों मिलती है? @ सुपरयूसर

find में एक क्रियाशील कार्य है:

 find . -maxdepth 1 -name '*.pdf' -delete 

एक और जवाब है कि xargs को बैचों में कमांडों पर कार्रवाई करने के लिए बल देना है। उदाहरण के लिए एक बार में फाइलों को 100 से delete , cd को डायरेक्टरी में डालें और इसे चलाएं:

echo *.pdf | xargs -n 100 rm

या आप कोशिश कर सकते हैं:

 find . -name '*.pdf' -exec rm -f {} \; 

आप एक बाश सरणी का उपयोग कर सकते हैं:

 files=(*.pdf) for((I=0;I<${#files[*]};I+=1000)); do rm -f ${files[@]:I:1000}; done 

इस तरह यह प्रति चरण 1000 फ़ाइलों के बैचों में मिटा देगा।

आप यह कोशिश कर सकते हैं:

 for f in *.pdf do rm $f done 

संपादित करें: थफीमस्टर टिप्पणी ने मुझे सुझाव दिया है कि मैं इस तरह के खतरनाक प्रथा को युवा शेल के जदीस में प्रकट न करें, इसलिए मैं एक और "सुरक्षित" संस्करण जोड़ूंगा (जब किसी को "-आरएफ .. पीडीएफ" फ़ाइल में चीजों को संरक्षित करने के लिए)

 echo "# Whooooo" > /tmp/dummy.sh for f in '*.pdf' do echo "rm -i $f" >> /tmp/dummy.sh done 

उपरोक्त चलाने के बाद, बस अपने fav में /tmp/dummy.sh फ़ाइल खोलें। संपादक और खतरनाक फाइलनामों के लिए हर एक पंक्ति की जांच करें, अगर उन्हें मिले तो टिप्पणी दें।

फिर अपने कार्यशील डमी में डमी.श स्क्रिप्ट कॉपी करें और इसे चलाएं।

यह सभी सुरक्षा कारणों के लिए

आप इस सराहना का उपयोग कर सकते हैं

 find -name "*.pdf" -delete 

गंतव्य स्रोत के लिए प्रपत्र स्रोत निर्देशिका की नकल करते समय मुझे एक ही समस्या का सामना करना पड़ रहा था

स्रोत निर्देशिका में ~ 3 lakcs फाइल थी

मैं विकल्प -आर के साथ सीपी इस्तेमाल किया और यह मेरे लिए काम किया है

सीपी-आर एबीसी / डीईएफ /

यह सभी फ़ाइलों को एबीसी से डीईफ़ की प्रतिलिपि नहीं करेगी, बिना तर्क सूची की चेतावनी को बहुत लंबा

आरएम कमांड में ऐसी फ़ाइलों की एक सीमा होती है, जिन्हें आप एक साथ जोड़ सकते हैं।

एक संभावना है कि आप उन्हें अपने फ़ाइल पैटर्न पर कई बार आरएम कमांड बेस का उपयोग कर निकाल सकते हैं, जैसे:

 rm -f A*.pdf rm -f B*.pdf rm -f C*.pdf ... rm -f *.pdf 

आप उन्हें कमान ढूंढने के आदेश भी निकाल सकते हैं:

 find . -name "*.pdf" -exec rm {} \; 

यदि वे रिक्त स्थान या विशेष वर्णों के साथ फ़ाइल नाम हैं, तो इसका उपयोग करें:

 find -maxdepth 1 -name '*.pdf' -exec rm "{}" \; 

यह वाक्य वर्तमान फाइल में सभी फाइलों को एक्सपोर्ट पीडीएफ (-name '* .pdf') के साथ वर्तमान निर्देशिका (-मेक्सडेप 1) में खोजें, और उसके बाद, प्रत्येक एक को हटाएं (-exec rm "{}")।

अभिव्यक्ति {} फ़ाइल के नाम की जगह लेती है, और, "{}" फ़ाइल नाम को स्ट्रिंग के रूप में सेट करता है, जिसमें रिक्त स्थान या विशेष वर्ण शामिल हैं

मैं इस समस्या में कई बार दौड़ा। समाधान में से कई प्रत्येक फ़ाइल के लिए rm कमांड चलाएंगे, जिन्हें rm होगा। यह बहुत ही अक्षम है:

 find . -name "*.pdf" -print0 | xargs -0 rm -rf 

फ़ाइल नाम में पहले 4 अक्षरों के आधार पर फ़ाइलों को हटाने के लिए मैंने एक अजगर स्क्रिप्ट लिखना समाप्त कर दिया था:

 import os filedir = '/tmp/' #The directory you wish to run rm on filelist = (os.listdir(filedir)) #gets listing of all files in the specified dir newlist = [] #Makes a blank list named newlist for i in filelist: if str((i)[:4]) not in newlist: #This makes sure that the elements are unique for newlist newlist.append((i)[:4]) #This takes only the first 4 charcters of the folder/filename and appends it to newlist for i in newlist: if 'tmp' in i: #If statment to look for tmp in the filename/dirname print ('Running command rm -rf '+str(filedir)+str(i)+'* : File Count: '+str(len(os.listdir(filedir)))) #Prints the command to be run and a total file count os.system('rm -rf '+str(filedir)+str(i)+'*') #Actual shell command print ('DONE') 

यह मेरे लिए बहुत अच्छी तरह से काम किया मैं लगभग 15 मिनट में एक फ़ोल्डर में 2 लाख से अधिक अस्थायी फ़ाइलों को साफ़ करने में सक्षम था। मैंने टार को थोड़ी सी संहिता के बारे में टिप्पणी की, ताकि कोई भी कम से कम कोई अजगर ज्ञान इस कोड को हेरफेर कर सके।

और दूसरा:

 cd /path/to/pdf printf "%s\0" *.[Pp][Dd][Ff] | xargs -0 rm 

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

 ls | grep .pdf > list.txt wc -l list.txt 

wc -l यह है कि count.txt में कितने पंक्ति शामिल हैं जब आपको यह पता चलता है कि यह कब तक है, तो आप इसे आधे, आगे या कुछ में विभाजित करने का फैसला कर सकते हैं Split -l कमांड का उपयोग करना उदाहरण के लिए, इसे प्रत्येक 600 लाइनों में विभाजित करें

 split -l 600 list.txt 

यह xaa, xab, xac नामक कुछ फाइल बनाएगा और इस पर निर्भर करता है कि आप इसे कैसे विभाजित करते हैं अब कमांड आरएम में उन फाइलों में प्रत्येक सूची को "आयात" करने के लिए, इसका उपयोग करें:

 rm $(<xaa) rm $(<xab) rm $(<xac) 

मेरी खराब इंग्लिश के लिए माफ़ कीजिये।

मैंने पाया है कि फ़ाइलों की बहुत बड़ी सूचियों (> 1e6) के लिए, ये उत्तर बहुत धीमा थे अजगर में समानांतर प्रसंस्करण का उपयोग कर एक समाधान है। मुझे पता है, मुझे पता है, यह लिनक्स नहीं है … लेकिन यहाँ कुछ भी काम नहीं किया।

(यह मुझे घंटे बचाया)

 # delete files import os as os import glob import multiprocessing as mp directory = r'your/directory' os.chdir(directory) files_names = [i for i in glob.glob('*.{}'.format('pdf'))] # report errors from pool def callback_error(result): print('error', result) # delete file using system command def delete_files(file_name): os.system('rm -rf ' + file_name) pool = mp.Pool(12) # or use pool = mp.Pool(mp.cpu_count()) if __name__ == '__main__': for file_name in files_names: print(file_name) pool.apply_async(delete_files,[file_name], error_callback=callback_error) 

इसे भी आज़माएं यदि आप 30/90 दिन (+) से ऊपर हटाना चाहते हैं या फिर 30/90 (-) दिनों के नीचे फ़ाइलें / फ़ोल्डर चाहते हैं तो आप नीचे दिए गए पूर्व आदेशों का उपयोग कर सकते हैं

पूर्व: 90 दिन के बाद 90 दिन के बाद फाइलों / फ़ोल्डर्स हटाए जाने के बाद इसमें शामिल नहीं है, इसका अर्थ 91 9 2 …. 100 दिन है

 find <path> -type f -mtime +90 -exec rm -rf {} \; 

पूर्व: केवल नवीनतम 30days फ़ाइलें जो आप हटाना चाहते हैं, तो निम्न कमांड (-) का उपयोग करें

 find <path> -type f -mtime -30 -exec rm -rf {} \; 

यदि आप 2 दिनों से अधिक फाइलों के लिए फाइलों को प्राप्त करना चाहते हैं

 find <path> -type f -mtime +2 -exec gzip {} \; 

यदि आप केवल एक महीने से फाइल / फ़ोल्डर देखना चाहते हैं उदाहरण के लिए:

 find <path> -type f -mtime -30 -exec ls -lrt {} \; 

30days से अधिक के बाद ही फाइल / फ़ोल्डर की सूची Ex:

 find <path> -type f -mtime +30 -exec ls -lrt {} \; find /opt/app/logs -type f -mtime +30 -exec ls -lrt {} \; 

जीएनयू समानांतर ( sudo apt install parallel ) का प्रयोग करना आसान है

यह उस आदेश को चलाता है जिसे '{}' तर्क दिया जाता है

उदाहरण के लिए

ls /tmp/myfiles* | parallel 'rm {}'

मान लीजिए इनपुट डायरेक्टरी नाम इनपुट और आउटपुट डायरेक्टरी नाम है आउटपुट। फिर आप सभी को कॉपी करने के लिए सरल पाश का उपयोग कर सकते हैं

 for f in input/* do cp $f output done 

मेरे पास अस्थायी छवियों से भरा फ़ोल्डर है, जो दिन-दर-दिन बढ़ रहा था और इस कमांड ने मुझे फ़ोल्डर साफ़ करने में मदद की

 find . -name "*.png" -mtime +50 -exec rm {} \; 

अन्य कमांड्स के साथ अंतर एमटाई पैरामीटर है जो केवल एक्स दिनों से पुरानी फाइलें लेगा (उदाहरण में 50 दिन)

उस समय का उपयोग करते हुए, हर निष्पादन को दिन सीमा पर घटाना, मैं सभी अनावश्यक फ़ाइलों को निकाल सकता था

यदि आपके पास grep के साथ समान समस्याएं हैं, तो सबसे आसान उपाय एक डीआईआर वापस ले जा रहा है और पुनरावर्ती खोज करता है।

तो इसके बजाय

 grep "something" * 

आप उपयोग कर सकते हैं:

 cd .. grep "something" -R search_in_this_dir/ 

ध्यान दें कि यह "सर्च_इन_थिस_डीआईआर" निर्देशिका के सबफ़ोल्डर्स को बार-बार खोज करेगा।

Xargs के उपयोग से थोड़ा सुरक्षित संस्करण, पुनरावर्ती भी नहीं: ls -p | grep -v '/$' | grep '\.pdf$' | while read file; do rm "$file"; done ls -p | grep -v '/$' | grep '\.pdf$' | while read file; do rm "$file"; done

हमारी निर्देशिकाओं को फ़िल्टर करना थोड़ा अनावश्यक है क्योंकि 'आरएम' इसे वैसे भी नहीं हटाएगा, और इसे सादगी के लिए हटाया जा सकता है, लेकिन ऐसा क्यों चला जो कुछ निश्चित रूप से त्रुटि वापस करेगा?

नीचे दिए गए विकल्प इस समस्या के लिए सरल लगता है। मुझे कुछ अन्य धागा से यह जानकारी मिली है लेकिन यह मेरी मदद करता है

 for file in /usr/op/data/Software/temp/application/openpages-storage/*; do cp "$file" /opt/sw/op-storage/ done 

बस ऊपर एक आदेश चलाएं और यह कार्य करेगा।