मैंने कई बार रूबी कोड में बेजोड़ File.openकॉल्स देखीं
क्या आप एक उदाहरण दे सकते हैं? मैं केवल कभी-कभी यह देखता हूं कि न्यूबॉय द्वारा लिखे गए कोड में "अधिकांश प्रोग्रामिंग भाषाओं में सामान्य ज्ञान की कमी है जो फाइलों के साथ काम करने के लिए प्रवाह खुला-उपयोग-बंद है"।
अनुभवी रूबिस्ट या तो स्पष्ट रूप से अपनी फ़ाइलों को बंद कर देते हैं, या, अधिक मुहावरेदार रूप से File.open, ब्लॉक रूप का उपयोग करते हैं , जो आपके लिए फ़ाइल को स्वचालित रूप से बंद कर देता है। इसका कार्यान्वयन मूल रूप से कुछ इस तरह दिखता है:
def File.open(*args, &block)
return open_with_block(*args, &block) if block_given?
open_without_block(*args)
end
def File.open_without_block(*args)
# do whatever ...
end
def File.open_with_block(*args)
yield f = open_without_block(*args)
ensure
f.close
end
अनुलेख एक विशेष मामला है। लिपियों में आम तौर पर इतने कम भाग होते हैं, और कुछ फ़ाइल विवरणों का उपयोग करते हैं कि यह बस उन्हें बंद करने के लिए समझ में नहीं आता है, क्योंकि ऑपरेटिंग सिस्टम स्क्रिप्ट बंद होने पर उन्हें वैसे भी बंद कर देगा।
क्या हमें स्पष्ट रूप से बंद होने की आवश्यकता है?
हाँ।
यदि हाँ, तो जीसी ऑटोक्लोसे क्यों करता है?
क्योंकि इसके द्वारा ऑब्जेक्ट को एकत्रित करने के बाद, आपके पास अब फ़ाइल को बंद करने का कोई रास्ता नहीं है, और इस प्रकार आप फ़ाइल डिस्क्रिप्टर को लीक कर देंगे।
ध्यान दें कि यह कचरा संग्रहकर्ता नहीं है जो फाइलों को बंद कर देता है। कचरा संग्रहकर्ता किसी वस्तु को इकट्ठा करने से पहले उसे अंतिम रूप से क्रियान्वित करता है। यह सिर्फ इतना होता है कि Fileवर्ग एक फाइनल को परिभाषित करता है जो फ़ाइल को बंद कर देता है।
यदि नहीं तो विकल्प क्यों?
क्योंकि व्यर्थ स्मृति सस्ता है, लेकिन बर्बाद फ़ाइल विवरणकर्ता नहीं हैं। इसलिए, यह किसी फ़ाइल डिस्क्रिप्टर के जीवनकाल को कुछ समय के लिए याद रखने के लिए समझ में नहीं आता है।
आप बस अनुमान नहीं लगा सकते जब कचरा कलेक्टर चलेंगे। तुम भी अनुमान नहीं लगा सकते , तो यह चलेंगे सब पर : यदि आप कभी नहीं स्मृति से बाहर चलाने, कचरा कलेक्टर कभी नहीं चलेंगे, इसलिए finalizer चलाने कभी नहीं होगा, इसलिए फ़ाइल को बंद किया जा कभी नहीं होगा।