विंडोज पर बड़ी संख्या में फ़ाइलों को कैसे हटाएं


22

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

मैंने इसे del/sWindows Explorer का उपयोग करके, और इसे हटाने की कोशिश की है । न तो कार्य पूरा कर सकते हैं। मैंने एक-एक करके कुछ उप-निर्देशिकाओं को हटाने की कोशिश की है, और मुझे दिन लग गए हैं। जो समस्या मुझे मिली वह यह थी कि हर बार, कोई बात नहीं delया एक्सप्लोरर का उपयोग करके , मैं टास्क मैनेजर में देख सकता हूं कि एक्सप्लोरर उदाहरण आकाश-उच्च मेमोरी का उपभोग करता है, और धीरे-धीरे मेरे सिस्टम को क्रैश करने के लिए धक्का देता है।

अभी भी कुछ सौ मिलियन फाइलें डिलीट होनी बाकी हैं। क्या एक (या सिर्फ कुछ) कमांड / कार्यों के साथ हासिल करने की कोई संभावना है?


[संपादित]

मैंने इसे Cygwin के साथ करने की कोशिश की है rm -fr, और उसी परिणाम को प्राप्त किया है। संक्षिप्त रूप में:

  1. DELकमांड प्रॉम्प्ट, या सिग्विन rmकमांड से विंडोज एक्सप्लोरर का उपयोग करने से कोई फर्क नहीं पड़ता , सिस्टम मेमोरी धीरे-धीरे शून्य हो जाती है, और बॉक्स अंततः दुर्घटनाग्रस्त हो जाएगा।

  2. यदि किसी भी बिंदु पर, सिस्टम के विफल होने से पहले, प्रक्रिया बंद हो जाती है (CTRL + C या अन्य के द्वारा), तो बॉक्स सामान्य रूप से काम करना जारी रखेगा। हालाँकि, सभी उपयोग की गई मेमोरी को मुक्त नहीं किया जाएगा। कहो, मैंने प्रक्रिया रोक दी है जबकि सिस्टम मेमोरी 91% तक पहुंच जाती है, टास्क मैनेजर बताता है: कुल में 4 जी रैम, कैश 329 एम है, और 335 एमबी उपलब्ध है। तब तक मेमोरी का उपयोग इस स्तर के आसपास रहेगा जब तक मैं मशीन को रिबूट नहीं करता। अगर मैं टास्क मैनेजर में एक्सप्लोरर उदाहरण को बंद कर देता हूं, तो स्क्रीन हर समय एचडीडी लाइट के साथ खाली जाएगी, और कभी वापस नहीं आई। आम तौर पर, जब मैं टास्क मैनेजर में एक्सप्लोरर उदाहरण को रोक देता हूं, तो मैं इसे विन + ई दबाकर इसे फिर से लागू कर सकता हूं, या इसे स्वचालित रूप से पुनरारंभ किया गया था।

खैर, वास्तव में अच्छा स्मृति प्रबंधन!


[संपादित करें] ऐसा लगता है कि इस्तेमाल की गई कुछ मेमोरी लंबे समय के बाद मुक्त हो गई, लेकिन सभी नहीं। कैश्ड और उपलब्ध स्मृति में से कुछ कार्य प्रबंधक में वापस आ गए। मैंने अब इंतजार नहीं किया है, निश्चित नहीं है कि तब क्या होगा।


तो आपकी मुख्य समस्या यह है कि निर्देशिकाओं और उपनिर्देशिकाओं को हटाया नहीं जा रहा है?
संदीप बंसल

@ जैकी चेउंग: आपके द्वारा उपयोग की जा रही खिड़कियों का कौन सा संस्करण?
शिव चरण

1
आप एक बैच स्क्रिप्ट लिख सकते हैं जो फ़ाइलों को हटाता है, शीर्ष स्तर से शुरू नहीं करता है, लेकिन उदाहरण के लिए फ़ोल्डर संरचना का पांचवां स्तर। यह नौकरी को कई अलग और अनुक्रमिक 'rm

9
मैं वास्तव में, पता करने के लिए, कैसे नरक आप एक खरब फ़ाइलों से मिला है ...
मोआब

2
ट्रिलियन फ़ाइलों के लिए एक फ़ाइल तालिका की आवश्यकता होती है जो 1 PB है। आजकल की सबसे बड़ी हार्ड डिस्क कुछ टीबी है। आपको संभवतः एक विभाजन कैसे मिला जो बड़ा था?
user541686

जवाबों:


10

तकनीकी व्याख्या

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

मान लें कि आपके पास "केवल" 100,000,000 फाइलें हैं, और विंडोज एक सरल संरचना का उपयोग करता है जैसे कि प्रत्येक फ़ाइल को अपने पथ के साथ संग्रहीत करने के लिए (इस तरह आप प्रत्येक निर्देशिका को अलग से संग्रहीत करने से बचते हैं, इस प्रकार कुछ ओवरहेड को बचाते हैं):

struct FILELIST {                   // Total size is 264 to 528 bytes:
  TCHAR         name[MAX_PATH];     // MAX_PATH=260; TCHAR=1 or 2 bytes
  FILELIST*     nextfile;           // Pointers are 4 bytes for 32-bit and 8 for 64-bit
}

इस पर निर्भर करता है कि यह 8-बिट वर्णों या यूनिकोड वर्णों का उपयोग करता है (यह यूनिकोड का उपयोग करता है) और क्या आपका सिस्टम 32-बिट या 64-बिट है, तो सूची को संग्रहीत करने के लिए इसे 25GB और 49GB मेमोरी के बीच की आवश्यकता होगी (और यह बहुत ही महत्वपूर्ण है) सरलीकृत संरचना)।

जिस कारण से Windows फ़ाइलों और फ़ोल्डरों को हटाने से पहले उन्हें हटाने की कोशिश करता है, उसे हटाने के लिए आपके द्वारा उपयोग किए जा रहे तरीके के आधार पर भिन्नता होती है, लेकिन एक्सप्लोरर और कमांड-दुभाषिया दोनों इसे करते हैं (आप कमांड शुरू करने पर देरी देख सकते हैं)। आप डिस्क गतिविधि (HDD LED) फ्लैश भी देख सकते हैं क्योंकि यह ड्राइव से डायरेक्टरी ट्री को पढ़ता है।

समाधान

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

@echo off
if not [%1]==[] cd /d %1
del /q *
for /d %%i in (*) do call %0 "%%i"

यदि कोई तर्क पारित किया गया था, तो यह जांचने के लिए क्या है। यदि ऐसा है, तो यह निर्दिष्ट निर्देशिका में बदल जाता है (आप इसे चालू निर्देशिका में शुरू करने के लिए एक तर्क के बिना चला सकते हैं या एक निर्देशिका निर्दिष्ट कर सकते हैं - यहां तक ​​कि इसे शुरू करने के लिए एक अलग ड्राइव पर भी)।

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

फिर यह वर्तमान निर्देशिका में फ़ोल्डरों की गणना करता है और खुद को कॉल करता है, प्रत्येक फ़ोल्डर को नीचे की ओर फिर से भरने के लिए इसे (स्वयं) पास करता है।

विश्लेषण

इसका कारण यह है कि यह काम करना चाहिए क्योंकि यह पूरे पेड़ में हर एक फाइल और फोल्डर की गणना नहीं करता है । यह किसी भी फाइल को एन्यूमरेट नहीं करता है, और केवल फ़ोल्डर को मौजूदा डायरेक्टरी ( मूल माता-पिता में शेष ) को शामिल करता है। मान लें कि किसी भी फ़ोल्डर में केवल कुछ सौ उप-निर्देशिकाएं हैं, तो यह बहुत बुरा नहीं होना चाहिए, और निश्चित रूप से अन्य तरीकों की तुलना में बहुत कम स्मृति की आवश्यकता होती है जो पूरे पेड़ को घेर लेती है।

आप /r(मैन्युअल) पुनरावर्तन का उपयोग करने के बजाय स्विच का उपयोग करने के बारे में सोच सकते हैं । यह काम नहीं करेगा क्योंकि जब /rस्विच पुनरावृत्ति करता है, तो यह पूरी निर्देशिका ट्री को पूर्व-संधारित करता है जो कि वास्तव में हम बचना चाहते हैं; हम बिना ट्रैक रखे ही हटाना चाहते हैं।

तुलना

इस पद्धति की तुलना पूर्ण-गणना विधि (ओं) से करें।

आपने कहा था कि आपके पास "लाखों निर्देशिकाएं" थीं; मान लीजिए 100 मिलियन। यदि पेड़ लगभग संतुलित है, और प्रति फ़ोल्डर लगभग 100 उप-निर्देशिकाओं का औसत मान रहा है, तो सबसे गहरी नेस्टेड निर्देशिका लगभग चार स्तर नीचे होगी - वास्तव में, पूरे पेड़ में 101,010,100 उप-फ़ोल्डर होंगे। (यह देखते हुए कि कैसे 100M सिर्फ 100 और 4. तक टूट सकता है)

चूंकि हम फ़ाइलों की गणना नहीं कर रहे हैं, हमें केवल 4 × 100 = 400किसी भी समय अधिकतम निर्देशिकाओं के लिए अधिकतम 100 निर्देशिका नामों पर नज़र रखने की आवश्यकता है ।

इसलिए मेमोरी की आवश्यकता ~ 206.25KB होनी चाहिए, जो किसी भी आधुनिक (या अन्यथा) प्रणाली की सीमा के भीतर है।

परीक्षा

दुर्भाग्य से (?) मेरे पास लाखों फ़ोल्डरों में ट्रिलियन फ़ाइलों वाली प्रणाली नहीं है, इसलिए मैं इसका परीक्षण करने में सक्षम नहीं हूं (मुझे विश्वास है कि अंतिम गणना में, मेरे पास लगभग ~ 800K फाइलें थीं), इसलिए किसी और को कोशिश करनी होगी यह।

चेतावनी

बेशक स्मृति केवल सीमा नहीं है। ड्राइव एक बड़ी अड़चन होगी क्योंकि आपके द्वारा डिलीट की जाने वाली हर फाइल और फोल्डर के लिए सिस्टम को इसे मुफ्त में चिह्नित करना होगा। शुक्र है कि इनमें से कई डिस्क ऑपरेशंस को एक साथ (कैश्ड) बंडल किया जाएगा और व्यक्तिगत रूप से (हार्ड-ड्राइव के लिए कम से कम, रिमूवेबल मीडिया के लिए नहीं) के बजाय विखंडू में लिखा जाएगा, लेकिन यह अभी भी काफी जोर देगा क्योंकि सिस्टम पढ़ता है और डेटा लिखता है।


मुझे पूरा यकीन है कि यह काम नहीं करता है। मैंने इसे आजमाया है। समस्या लूप में है। यह निकला कि DEL को सीधे जारी करने के लिए FOR वही समस्या पैदा करेगा।
जैकी चेउंग

1
यह आपके द्वारा उपयोग किए जाने वाले स्विच पर निर्भर करता है। यदि आपने /rस्विच का उपयोग किया है , तो जैसा कि मैंने समझाया, यह सभी फाइलों को एन्यूमरेट करने की कोशिश करेगा। यदि आप /dस्विच का उपयोग करते हैं , तो यह केवल वर्तमान निर्देशिका में फ़ोल्डरों की गणना करता है, इसलिए जब तक कि आपके पास वर्तमान निर्देशिका में एक अरब फ़ोल्डर नहीं है, तब तक यह समस्या नहीं होनी चाहिए।
सिनटेक १ech

7

मैं फ़ाइलों के खरबों से बात नहीं कर सकता, लेकिन मैंने हाल ही में एक पुरानी फ़ाइल साझा की है, जिसमें ~ 1.8M फ़ाइलों का उपयोग किया गया है:

robocopy EmptyTMPFolder FolderToDelete /MIR /MT:16 /ETA /R:30 /W:5

"EmptyTMPFolder" एक खाली स्थानीय निर्देशिका है। / MIR विकल्प लक्ष्य को स्रोत (खाली) की तरह बना देगा।

इस दृष्टिकोण के लिए वास्तविक लाभ रिट्री ऑप्शन (/ R: 30) था। इसने इस प्रक्रिया के दौरान होने वाले किसी भी कनेक्टिविटी मुद्दों को अवशोषित करने का अवसर दिया। स्थानीय डिलीट को इस दृष्टिकोण में लाभ नहीं मिल सकता है।

मेरे पास समय की तुलना करने के लिए विशिष्ट बेंचमार्क नहीं हैं, लेकिन मैं इसे रिट्री / वेट विकल्प के बी / सी में सुझाए गए कुछ अन्य विकल्पों पर पसंद करूंगा। डिलीट तुरन्त पास होने लगे।


मैंने पाया कि बड़े नेटवर्क ड्राइव फ़ोल्डर ट्री पर क्लीनअप चलाते समय यह अब तक की सबसे कारगर विधि है। टिप के लिए धन्यवाद।
टॉनी

5

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

एक अन्य विकल्प शायद एक लाइव सीडी पर कुछ लिनक्स डिस्ट्रो का उपयोग करना है जो एनटीएफएस विभाजन से पढ़ सकता है। मैं व्यक्तिगत अनुभव से जानता हूं जो rm -rf folderName2GB RAM के साथ सिस्टम को क्रैश किए बिना कम से कम 2 दिनों तक चल सकता है। इसमें थोड़ा समय लगेगा, लेकिन कम से कम यह खत्म हो जाएगा।


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

1
आप git bash
रेनड्रॉप

4

एर्म .. मैं यह जानना नहीं चाहता कि आपने इतने सारे कैसे बनाए।

क्या हो रहा है एक्सप्लोरर हर एक फाइल को एन्यूमरेट करने की कोशिश कर रहा है, और डिलीट होने से पहले सूचना को मेमोरी में स्टोर कर सकता है। और वहाँ स्पष्ट रूप से बहुत अधिक है।

क्या आपने कमांड की कोशिश की है rmdir /s? जब तक यह वास्तव में फाइलों को डिलीट कर देता है, क्योंकि वे हर एक को एन्यूमरेट किए जाने की प्रतीक्षा करने के बजाय पाए जाते हैं, यह काम कर सकता है।

उपनिर्देशिका के कितने स्तर हैं? यदि केवल एक, या कुछ अन्य कम संख्या है, तो एक त्वरित बैच फ़ाइल जो मैन्युअल रूप से पुन: काम करती है, काम कर सकती है।

किसी भी विधि में थोड़ा समय लगेगा, हालांकि।


सुधार के सुझाव के अलावा, बेशक। यह तेज़ होगा, लेकिन अगर यह आपकी सिस्टम ड्राइव है तो आपको विंडोज को फिर से इंस्टॉल करना होगा।
बॉब

मुझे पूरा यकीन है कि एन्यूमरेशन होना है, बस प्रोग्राम को पता है कि आगे क्या हटाना है। rmdir फ़ाइलों को हटा नहीं सकते हैं क्योंकि वे पाए जाते हैं, क्योंकि यह ऊपर से शुरू होता है, और किसी तरह से पार करना पड़ता है। एकमात्र सवाल यह है कि यह कितनी अतिरिक्त जानकारी संग्रहीत करता है।
सूंड

@soandos एक्सप्लोरर हर फाइल को गिनता है । मैं कुछ तरीका सोच रहा था जो एन्युमरेशन की एक डीएफएस शैली को लागू करता है: एक शाखा के नीचे जितना संभव हो सके, एक फ़ाइल को हिट करने से पहले हटाने, वापस आने से पहले। दूसरे शब्दों में, पुनरावृत्ति, जो rm -rfकरता है। यह अपेक्षाकृत उथले निर्देशिका संरचनाओं के साथ सबसे अच्छा काम करता है। मुझे यकीन नहीं है कि अगर rmdir /sऐसा होता है। यह होना चाहिए
बॉब

1
@JackeyCheung rmdir /?: /s Removes all directories and files in the specified directory in addition to the directory itself. Used to remove a directory tree.दूसरे शब्दों में, /sध्वज फाइलों को भी हटा देता है। आपने कैसे उपयोग किया del? और हाँ, यह बेहतर होगा कि केवल rm -rfसुझाए गए साबुन का उपयोग करें ।
बॉब

1
@JackeyCheung: आप गलत हैं। यदि आप rmdir / s ध्वज देते हैं, तो यह फ़ाइलों के साथ-साथ निर्देशिकाओं को भी हटा देता है।
हैरी जॉन्सन

4

इस तरह एक समस्या का एक संभावित कारण पतली प्रावधान है, आमतौर पर SAN वातावरण में पाया जाता है। कुछ सॉलिड-स्टेट्स ड्राइव एक ही समस्या प्रदर्शित कर सकते हैं। यदि यह स्थिति है, तो यह कॉन्फ़िगरेशन परिवर्तन आपकी समस्या को हल कर सकता है:

fsutil behavior set DisableDeleteNotify 1

ध्यान दें कि यह परिवर्तन ठोस राज्य ड्राइव पर प्रदर्शन को प्रभावित कर सकता है, और सैन ड्राइव के स्वचालित और / या मैन्युअल पुनर्वितरण को रोक सकता है।


3

Shift+ Deleteरीसायकल बिन को छोड़ देता है, और चीजों को तेजी से बढ़ा सकता है।

यदि वह काम नहीं करता है (चरम मामले), फास्ट फ़ोल्डर इरेज़र और / या मास डायरेक्टरी इरेज़र का प्रयास करें


जब मैंने बड़ी संख्या में चित्र फ़ाइलों को हटाने की कोशिश की, तो हाँ शिफ्ट DEL काफी तेज़ है अगर सामान्य DEL, धन्यवाद के साथ तुलना की जाती है
V-SHY

3

यह शायद आपका एंटीवायरस / एंटीमैलेरवेयर है जो सभी मेमोरी का उपभोग करता है और फिर सिस्टम को क्रैश करता है।

विंडोज़ के पास बड़ी संख्या में फ़ाइलों को हटाने की समस्या नहीं है, हालांकि यह निश्चित रूप से अधिकांश गैर-Microsoft फ़ाइल सिस्टमों पर एक समान ऑपरेशन की तुलना में धीमी है।


अच्छी बात है! ज़रूर देखें।
जैकी चेउंग

मैंने एंटीवायरस को बंद कर दिया है, और मेमोरी अभी भी पहले की तरह खा गई है।
जैकी चेउंग

प्रक्रिया बंद होने के बाद एंटीवायरस को बंद करने से मेमोरी को मुक्त करने में मदद नहीं मिलती है।
जैकी चेउंग

@JackeyCheung: यह कौन सा एंटीवायरस प्रोग्राम है? कुछ वास्तव में पूरी तरह से बंद नहीं ...
बेन Voigt

2

आपके द्वारा चलाए जा रहे एक समस्या यह है कि फ़ाइल / फ़ोल्डर को हटाने पर निर्देशिका संकुचित नहीं होती है, इसलिए यदि आपके पास 1 मिलियन फ़ाइलों वाला फ़ोल्डर है और उनमें से पहला 500k हटा दें। आपकी निर्देशिका की शुरुआत में एक टन ब्लॉक हैं जो सभी इंटेंट रिक्त के लिए हैं।

लेकिन, खोजकर्ता और कमांड प्रॉम्प्ट को अभी भी उन ब्लॉकों से गुजरना पड़ता है, जब वहां कोई फाइल होती है। कुछ ऐसा हो सकता है जो ड्राइव के आधार से पेड़ से नीचे एक फ़ोल्डर को नए फ़ोल्डर में "स्थानांतरित" करने में मदद करता है, फिर उस नए फ़ोल्डर को हटा दें। फ़ोल्डर को स्थानांतरित करना केवल सूचक को फ़ोल्डर में ले जाएगा, इसलिए इसे जल्दी से जाना चाहिए और वास्तव में इसके तहत सभी फाइलों को ड्राइव पर नए स्थान पर नहीं ले जाना चाहिए।

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


2

10 मिलियन से अधिक संलयन लॉग फ़ाइलों को हटाने के लिए विभिन्न तरीकों की कोशिश करते हुए, मैंने देखा कि लगभग 30K फाइलें औसतन 10 मिनट की अवधि में नष्ट की जा सकती हैं। 10 मिलियन फ़ाइलों के लिए लगभग 55 घंटे लगेंगे ...

नीचे दी गई स्क्रिप्ट का उपयोग करके, हटाने की दर ~ 75% बढ़ गई। फ़ाइल सूचियाँ बनाई जाती हैं और समवर्ती प्रक्रियाओं द्वारा डिस्क संचालन को बढ़ाती हैं (लेकिन रैखिक रूप से नहीं।) मैं 4 कांटे दिखा रहा हूं, लेकिन दो बार पर्याप्त होगा।

PowerShell का उपयोग करने का एक विकल्प है जो सूचियों को तैयार करने के लिए आवश्यक समय को काफी कम कर देता है।

BTW, मैंने टकराव की अनुमति देने वाले दो प्रत्यक्ष डेल संचालन का उपयोग करके परीक्षण किया, लेकिन एकल डिली ऑपरेशन की तुलना में समग्र विलोपन समय में कोई उल्लेखनीय कमी नहीं हुई। और जबकि यह हटाने की सूची बनाने के लिए वांछनीय नहीं हो सकता है, बचाया समय इसके लायक था।

@ECHO OFF
SETLOCAL EnableDelayedExpansion

IF /I "%~1"=="timestamp" (
    CALL :ECHOTIMESTAMP
    GOTO END
)

rem directory structure to delete
SET "DELETE=c:\_delete\Content.IE5\???<<<change this>>>???"
rem primary list of discovered files to delete
SET "LIST=delete-list.txt"
rem base path for sub-lists
SET "LISTBASE=.\delete-list"
SET "TITLE=Batch Delete Process"
rem specifies number of batch delete processes to spawn
SET FORKS=4
rem when set to 1, use PowerShell for list building and delete.  Definitely improves time to build fork sublists
SET POWERSHELL=0
rem specifies max files to delete when greater than 0
SET MAXDEL=1000000

rem prompt for confirmatoin
SET /P CONT=About to delete all files and directories from !DELETE!. Continue (Y/N)?
IF /I NOT "!CONT!"=="Y" EXIT /B

CALL :ECHOTIMESTAMP

ECHO Accumulating list of files to delete...
dir /b /s "!DELETE!" > "!LIST!"

FOR /F "delims=" %%c IN ('type "!LIST!" ^| find /C ":"') DO SET "COUNT=%%c"
ECHO Discoverd !COUNT! files and directories to delete.

IF  %MAXDEL% GTR 0 IF !COUNT! GTR %MAXDEL% (
    SET COUNT=%MAXDEL%
    ECHO Limiting files/directories deletion count to  !COUNT!
)

CALL :ECHOTIMESTAMP
ECHO Preparing !FORKS! delete processes...
SET /A LIMIT=!COUNT!/!FORKS!

IF !POWERSHELL! EQU 1 (
    SET SKIP=0
    FOR /L %%n IN (1,1,!FORKS!) DO (
        SET "CURRENT=!LISTBASE!-%%n.txt"
        SET "LIST[%%n]=!CURRENT!"
        DEL /f /q "!CURRENT!" > nul 2>&1
        IF %%n EQU !FORKS! SET /A LIMIT+=!FORKS!
        SET CMD=type \"!LIST!\" ^| select -first !LIMIT! -skip !SKIP!
        powershell -command "& {!CMD!}" > "!CURRENT!"
        SET /A SKIP+=!LIMIT!
    )

) ELSE (
    rem significantly slower but no PowerShell.
    SET L=1
    SET N=!LIMIT!
    SET C=0
    FOR /F %%f  IN (!LIST!) DO (
        IF !C! LSS !COUNT! (
            IF !N! GEQ !LIMIT! (
                SET "CURRENT=!LISTBASE!-!L!.txt"
                SET "LIST[!L!]=!CURRENT!"
                DEL /f /q "!CURRENT!" > nul 2>&1
                SET /A L+=1
                SET /A N=0
            ) ELSE (
                SET /A N+=1
            )
            ECHO %%f >> "!CURRENT!"
        ) ELSE (
            GOTO ENDLIST
        )
        SET /A C+=1
    )
)
:ENDLIST

CALL :ECHOTIMESTAMP
ECHO Forking !FORKS! delete processes...
FOR /L %%t IN (1,1,!FORKS!) DO (

    SET "CURRENT=!LIST[%%t]!"
    IF !POWERSHELL! EQU 1 (
        SET "TAB=        "
        SET BLANK=!TAB!!TAB!!TAB!!TAB!!TAB!!TAB!!TAB!!TAB!
        SET BLANK=!BLANK!!BLANK!!BLANK!!BLANK!
        SET DEL_CMD=del -force -recurse -ea SilentlyContinue -path \"$_\"
        SET $W_CMD=$w=$Host.UI.RawUI.WindowSize.Width
        SET $S_CMD=$s=\"$_\";$i=[math]::max^(0,$s.length-$w^);$s=$s.substring^($i, $s.length-$i^);$s=\"$s !BLANK!\";$s=$s.substring^(0,[math]::min($w,$s.length^)^)
        SET ECHO_CMD=Write-Host \"`r$s\" -NoNewLine
        SET CMD=type \"!CURRENT!\" ^| %% {!DEL_CMD!; !$W_CMD!; !$S_CMD!; !ECHO_CMD!}
        SET CMD=powershell -command "^& {!CMD!}" ^& ECHO\ ^& "%~dpnx0" timestamp
        ECHO CMD !CMD!
    ) ELSE (
        SET LOOP=FOR /F %%%f IN ^(!CURRENT!^) DO
        SET OP=del "%%%f"
        SET CMD=@ECHO OFF ^&^& ^(!LOOP! !OP!  ^> nul 2^>^&1 ^)  ^& "%~dpnx0" timestamp
    )
    rem ECHO !CMD!
    START "!TITLE! %%t" cmd /k  !CMD!
)

GOTO END

:ECHOTIMESTAMP
SETLOCAL
    SET DATESTAMP=!DATE:~10,4!-!DATE:~4,2!-!DATE:~7,2!
    SET TIMESTAMP=!TIME:~0,2!-!TIME:~3,2!-!TIME:~6,2!
    ECHO !DATESTAMP: =0!-!TIMESTAMP: =0!
ENDLOCAL
GOTO :EOF

:END
ENDLOCAL
EXIT /B

2

इसे आज़माएँ, और आवश्यकतानुसार संशोधित करें ..

यह विन्टेक की तकनीकी व्याख्या और विश्लेषण के आधार पर Win2003 पर एक परीक्षित स्क्रिप्ट है 15:22 बजे 15 अक्टूबर को उत्तर दिया गया था

@echo off

rem ### USE FULL PATH AS FIRST ARGUMENT TO SCRIPT, DONT FORGET QUOTES !
rem ### If you move this script, fix script path variable...
SET STATICFULLSCRIPTPATH="D:\scripts\FOLDER"
SET SCRIPTNAME="DeleteFast.bat"

rem ### If CD fails or IF condition has problems,
rem ### and DEL or RMDIR runs, its better to be at safe place.
if not exist "%TEMP%\SAFE" mkdir "%TEMP%\SAFE"
if exist "%TEMP%\SAFE" cd /d "%TEMP%\SAFE"

rem ### Fix quote overflow
set var1="%1"
set var1=%var1:"=%

if not [%1]==[] (
    cd /d "%var1%"

    echo # KILLING F AT : "%var1%"
    rem ### uncomment to do damage! ### 
    rem # del /f/q * > nul

    for /d %%i in (*) do call "%STATICFULLSCRIPTPATH%\%SCRIPTNAME%" "%var1%\%%i"

    rem ## Finish deleting the last dir
    cd /d "%var1%\.."

echo # KILLING  DIR : "%var1%"
rem ## Remove dir.. first try
rmdir /q "%var1%"

if exist "%var1%" (
    rem ## Remove dir.. second try
    rem ## If thousands of files/dirs had permission/ownership problems, then prepare to wait a long time.
    rem ### uncomment to do damage! ### 
    rem #cmd.exe /c takeown /f "%var1%" && icacls "%var1%" /grant SOMEBODY:F

    rem ### uncomment to do damage! ### 
    rem #rmdir /s/q "%var1%"
)
)

cd /d "%STATICFULLSCRIPTPATH%"

Testrun .. इसमें A1 से A4, B1 से B4 और C1 से C4 नेस्टेड अलग-अलग तरह के फोल्डर हैं।

Z:\>"D:\scripts\FOLDER\DeleteFast.bat" "D:\scripts\TESTF\DIRS"
# KILLING F AT : "D:\scripts\TESTF\DIRS"
# KILLING F AT : "D:\scripts\TESTF\DIRS\A1"
# KILLING F AT : "D:\scripts\TESTF\DIRS\A1\B1"
# KILLING F AT : "D:\scripts\TESTF\DIRS\A1\B1\C 1"
# KILLING  DIR : "D:\scripts\TESTF\DIRS\A1\B1\C 1"
# KILLING  DIR : "D:\scripts\TESTF\DIRS\A1\B1"
# KILLING F AT : "D:\scripts\TESTF\DIRS\A1\B2"
# KILLING F AT : "D:\scripts\TESTF\DIRS\A1\B2\C 2"
# KILLING  DIR : "D:\scripts\TESTF\DIRS\A1\B2\C 2"
# KILLING  DIR : "D:\scripts\TESTF\DIRS\A1\B2"
# KILLING  DIR : "D:\scripts\TESTF\DIRS\A1"
# KILLING F AT : "D:\scripts\TESTF\DIRS\A2"
# KILLING F AT : "D:\scripts\TESTF\DIRS\A2\B3"
# KILLING F AT : "D:\scripts\TESTF\DIRS\A2\B3\C 3"
# KILLING  DIR : "D:\scripts\TESTF\DIRS\A2\B3\C 3"
# KILLING  DIR : "D:\scripts\TESTF\DIRS\A2\B3"
# KILLING  DIR : "D:\scripts\TESTF\DIRS\A2"
# KILLING F AT : "D:\scripts\TESTF\DIRS\A3"
# KILLING F AT : "D:\scripts\TESTF\DIRS\A3\B4"
# KILLING F AT : "D:\scripts\TESTF\DIRS\A3\B4\C 4"
# KILLING  DIR : "D:\scripts\TESTF\DIRS\A3\B4\C 4"
# KILLING  DIR : "D:\scripts\TESTF\DIRS\A3\B4"
# KILLING  DIR : "D:\scripts\TESTF\DIRS\A3"
# KILLING F AT : "D:\scripts\TESTF\DIRS\A4"
# KILLING  DIR : "D:\scripts\TESTF\DIRS\A4"
# KILLING  DIR : "D:\scripts\TESTF\DIRS"

D:\scripts\FOLDER>

मैं टिप्पणी नहीं कर सकता (साइट मेरी प्रतिष्ठा के बारे में शिकायत करती है), इसलिए मैं अपनी टिप्पणी यहां जोड़ता हूं ..

बीजेवी का समाधान बेकार अस्थायी फिल्मकारों को बनाता है। और फिर वास्तविक कार्य करने के लिए उन्हें दूसरी बार दोहराता है। /superuser//a/892412/528695

मूल Synetech की स्क्रिप्ट मेरे लिए काम नहीं करती थी। /superuser//a/416469/528695

@echo off
if not [%1]==[] cd /d %1
echo "%1"
for /d %%i in (*) do call %0 "%%i"

परिणाम ..

Z:\>C:\privscripts\TESTF\DeleteFastORIGINAL.bat "C:\privscripts\TESTF\DIRS"
""C:\privscripts\TESTF\DIRS""
""A1""
""B1""
""C1""
The system cannot find the path specified.
""B2""
The system cannot find the path specified.
""A2""
The system cannot find the path specified.
""A3""
The system cannot find the path specified.
""A4""

C:\privscripts\TESTF\DIRS\A1\B1\C1>

मैं यह सत्यापित कर सकता हूं कि @ user4350129 सही है जब वह कहता है कि Synetech की स्क्रिप्ट काम नहीं करती है - मेरे Win7x64 बॉक्स पर भी मेरा यही व्यवहार था।
leinad13

धिक्कार है मेरी स्क्रिप्ट या तो सही नहीं थी, अगर arg गायब और उद्धरण अतिप्रवाह के साथ समस्याएँ टेकऑन anc icacls कमांड को तोड़ती हैं .. तो मैंने केवल फ़ोल्डर्स की जाँच नहीं की फाइलें .. मैंने उन मुद्दों को ठीक किया .. पोस्ट संपादित की गई, लेकिन हमेशा उपयोग करने से पहले परीक्षण करें।
ईओ

2

मैं 10 मिलियन फ़ाइलों के साथ कुछ समय पहले ऐसी ही समस्याएँ उठा रहा था, लेकिन एक सर्वर 2003 में, मैंने उन फ़ाइलों को हटाने के लिए जो मैंने एक ftp सर्वर / क्लाइंट का उपयोग किया था, और फ़ाइलों और फ़ोल्डरों को हटाने वाले क्लाइंट को छोड़ दिया। यह एक धीमा समाधान है लेकिन यह सही काम करता है।

संभवतः आपके पास NTFS में MFT के साथ एक दूसरी समस्या होगी जिसका कोई हल नहीं है, MFT एक ऐसा सरणी है जो जीत 2003 में है (मुझे यकीन नहीं है कि Microsoft के पास 2003 जीतने के बाद कोई समाधान है) सभी फाइलों को एक वृद्धिशील संग्रह में संग्रहीत कर रहा है। ट्रिलियन फ़ाइलों के साथ आकार पागल हो जाएगा, मेरे मामले में एमएफटी के पास 17 मिलियन रिकॉर्ड थे और एमएफटी का आकार लगभग 45 जीबी फाइलों के साथ लगभग 19 जीबी था, मैंने अन्य प्रणालियों में परीक्षण किया और 1 मिलियन रिकॉर्ड एमएफटी के लिए ऐसा लगेगा 1 जीबी के आसपास हो।

आप इस आदेश के साथ MFT की स्थिति देख सकते हैं:

defrag C: /a /v
  • C: - इकाई पत्र
  • /a - विश्लेषण
  • /v - क्रिया

एक और मुश्किल समाधान, चूंकि कोई उपकरण नहीं है जो एमएफटी को छोटा कर सकता है, उपकरण केवल फाइलों और गुणों के नाम के साथ 0 भरते हैं लेकिन अधिक कुछ नहीं, लेकिन आप वीएमवेयर कनवर्टर या किसी अन्य प्रकार के पी 2 वी का उपयोग कर सकते हैं और इसके आधार पर एक वर्चुअल मशीन बना सकते हैं। आपका सर्वर, इस तरह से आप एमएफटी से संबंधित सभी समस्याओं को ठीक कर देंगे, मैंने कभी भी वी 2 पी से रूपांतरण का परीक्षण नहीं किया, अब मैं केवल आभासी वातावरण में काम कर रहा हूं, लेकिन मैंने इंटरनेट पर इसके बारे में कई जानकारी देखी।

2003 की यह जीत पूरी तरह से अब काम कर रही है, एमएफटी का आकार 40 एमबी है और सबकुछ ठीक है, अगर आप चाहें तो मैं आपको लाखों छोटी फाइलों से संबंधित बैकअप, डिफ्रैग या अन्य कार्य के बारे में बता सकता हूं।


1

StackOverflow पर इस उत्तर के अनुसार delऔर के संयोजन का उपयोग करें rmdir:

del /f/s/q foldername > nul
rmdir /s/q foldername

हाँ, मैंने इससे पहले पढ़ा है। वास्तव में यह मेरे मामले में मदद नहीं करता है। चूंकि डेल कमांड निश्चित रूप से क्रैश होता है।
जैकी चेउंग

1

चूंकि सभी फाइलें एक बार में हटाने से बहुत अधिक मेमोरी का उपयोग होता है, इसलिए आपको एक बार में उन्हें हटाने का एक तरीका चाहिए, लेकिन स्वचालित प्रक्रिया के साथ। इस तरह की बात एक यूनिक्स-शैली के खोल में करना बहुत आसान है, इसलिए चलो सिग्विन का उपयोग करें। निम्न आदेश साधारण फ़ाइलों की एक सूची बनाता है, उस सूची को rmआदेशों के अनुक्रम में परिवर्तित करता है , फिर परिणामी स्क्रिप्ट को शेल में फीड करता है।

 find dir \! -type d | sed 's/^/rm /' | sh

स्क्रिप्ट को निष्पादित किया जा रहा है, क्योंकि यह उत्पन्न हो रहा है, और कोई लूप नहीं हैं, इसलिए शेल को कोई बड़ी अस्थायी फ़ाइलों को बनाने की उम्मीद नहीं है। यह निश्चित रूप से थोड़ी देर लगेगा, क्योंकि स्क्रिप्ट लाखों लाइनों लंबी है। आपको rmकमांड को मोड़ना पड़ सकता है (शायद मुझे इस्तेमाल करना चाहिए था-f ? लेकिन आप अपनी फ़ाइलों को मुझसे बेहतर समझते हैं) को ।

अब आपके पास निर्देशिकाओं के अलावा कुछ नहीं बचा है। यहाँ जहाँ चीजें बर्फीली मिलती हैं। हो सकता है कि आपने पर्याप्त फ़ाइलों को हटा दिया हो ताकि आप rm -rfमेमोरी से बाहर चले बिना कर सकें (और यह शायद किसी अन्य स्क्रिप्ट की तुलना में तेज़ होगा)। यदि नहीं, तो हम इस Stackoverflow जवाब को अनुकूलित कर सकते हैं :

 find dir | perl -lne 'print tr:/::, " $_"' | sort -n | cut -d' ' -f2 | sed 's/^/rmdir /' | sh

फिर से, टेंपिंग आवश्यक हो सकता है, इस बार के साथ sort, विशाल अस्थायी फ़ाइलों को बनाने से बचने के लिए।


1

मैं कुछ समय पहले इसी मुद्दे पर भागा था। मैंने एक छोटी सी उपयोगिता लिखी जो ठीक यही करती है: किसी निर्देशिका को पुन: हटा देना। यह फ़ाइलों की गणना नहीं करेगा, और यह n (अधिकतम निर्देशिका गहराई और m = अधिकतम फ़ाइल / निर्देशिका संख्या एक उप-विभाजनों में से एक) के साथ अधिकतम मेमोरी (O (n + m) का उपभोग नहीं करेगा)। यह लंबी फ़ाइलपथ (> 256 वर्ण) को संभाल सकता है। अगर आपको इस बारे में अपनी समस्या हल करनी हो तो मुझे प्रतिक्रिया प्राप्त करना अच्छा लगेगा।

आप इसे यहाँ पा सकते हैं: https://github.com/McNetic/fdeltree (रिलीज़ फ़ोल्डर में निष्पादन योग्य)


1

मैंने पाया कि यह धागा मेरे द्वारा समर्थित सर्वरों में से 3 मिलियन से अधिक फ़ाइलों को हटाने के लिए एक बेहतर तरीका है। ऊपर जटिल IMO का तरीका है इसलिए मैंने विंडोज में "FORFILES" कमांड लाइन टूल का उपयोग करने के अपने ज्ञात तरीके का उपयोग करके समाप्त किया (यह सर्वर 2003 पर था)।

वैसे भी, नीचे फोर्फ़िल्स कमांड है जिसका उपयोग मैंने कमांड लाइन से एक फ़ोल्डर में सभी फ़ाइलों को हटाने के लिए किया था।

forfiles / P "आपका फ़ोल्डर पथ यहाँ (जैसे C: \ Windows \ Temp)" / C "cmd / c प्रतिध्वनि @file और del / f / q @file"

उपरोक्त ECHO की उन फ़ाइलों का नाम भी है जिन्हें स्क्रीन पर हटाया जा रहा है, लेकिन केवल इसलिए कि मैं इसकी कुछ प्रगति वास्तव में कुछ करते हुए देखना चाहता था, यदि आप कुछ ऐसा नहीं गूंजते हैं, जैसे यह लगता है कि DOS बॉक्स लटका हुआ है, तब भी हालांकि यह उम्मीद के मुताबिक काम कर रहा है।

आरंभ करने में थोड़ा समय लगता है, अर्थात ऐसा लगता है कि यह कुछ समय के लिए कुछ नहीं कर रहा है (~ 3million फ़ाइलों के लिए लगभग 30 मी) लेकिन अंततः आपको फ़ाइल नाम दिखाई देना शुरू हो जाते हैं जैसे वे हटाए जाते हैं। यह विधि फ़ाइलों को हटाने के लिए एक लंबा समय भी लेती है (विलोपन का समय हो सकता है) ईको के बिना होने का कम सकता है?), लेकिन यह अंततः मशीन को क्रैश किए बिना काम करता है, मेरे सर्वर पर फॉरेफल्स को हटाने की प्रक्रिया के दौरान ~ 1,850Kb मेमोरी का उपयोग किया गया था। ।

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

वैसे भी, सोचा था कि मैं अपना जवाब साझा करूंगा, शुभकामनाएँ!

हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.