जैसा कि उल्लेख किया गया है, इस पर विचार के दो स्कूल हैं।
1) वर्ष 1987 है क्योंकि कार्यों के शीर्ष पर सब कुछ घोषित करें।
2) पहले उपयोग के लिए निकटतम और संभव सबसे छोटे दायरे में घोषित करें।
मेरा जवाब है यह दोनों है! मुझे समझाने दो:
लंबे कार्यों के लिए, 1) रिफैक्टरिंग को बहुत कठिन बनाता है। यदि आप एक ऐसे कोडबेस में काम करते हैं जहाँ डेवलपर्स सबरूटीन्स के विचार के खिलाफ हैं, तो आपके पास फंक्शन की शुरुआत में 50 परिवर्तनीय घोषणाएँ होंगी और उनमें से कुछ सिर्फ फॉर-लूप के लिए "i" हो सकती हैं समारोह के नीचे।
इसलिए मैंने इससे घोषित-ए-टॉप-पीटीएसडी विकसित किया और धार्मिक रूप से विकल्प 2) करने की कोशिश की।
मैं एक चीज के कारण विकल्प के आसपास वापस आया: छोटे कार्य। यदि आपके कार्य काफी कम हैं, तो आपके पास कुछ स्थानीय चर होंगे और चूंकि फ़ंक्शन कम है, यदि आप उन्हें फ़ंक्शन के शीर्ष पर रखते हैं, तो वे अभी भी पहले उपयोग के करीब होंगे।
इसके अलावा, जब आप शीर्ष पर घोषित करना चाहते हैं, तो "एनएलआर को घोषित और सेट करें" का विरोधी पैटर्न, लेकिन आपने गणना के लिए आवश्यक कुछ गणनाओं को हल नहीं किया है क्योंकि आपको जिन चीजों को शुरू करने की आवश्यकता है उन्हें तर्क के रूप में प्राप्त किया जाएगा।
तो अब मेरी सोच यह है कि आपको पहले उपयोग के लिए फ़ंक्शन के शीर्ष पर और जितना संभव हो उतना निकट घोषित करना चाहिए। इसलिए दोनों! और ऐसा करने का तरीका अच्छी तरह से विभाजित सबरूटीन के साथ है।
लेकिन अगर आप एक लंबे कार्य पर काम कर रहे हैं, तो पहले उपयोग के लिए चीजों को निकटतम रखें क्योंकि इस तरह से तरीकों को निकालना आसान होगा।
मेरी रेसिपी यही है। सभी स्थानीय चर के लिए, चर लें और इसे नीचे की ओर घोषणा घोषित करें, संकलन करें, फिर संकलन त्रुटि से ठीक पहले घोषणा को स्थानांतरित करें। वह पहला उपयोग है। सभी स्थानीय चर के लिए ऐसा करें।
int foo = 0;
<code that uses foo>
int bar = 1;
<code that uses bar>
<code that uses foo>
अब, एक गुंजाइश ब्लॉक को परिभाषित करें जो घोषणा से पहले शुरू होता है और कार्यक्रम के संकलन तक अंत को स्थानांतरित करता है
{
int foo = 0;
<code that uses foo>
}
int bar = 1;
<code that uses bar>
>>> First compilation error here
<code that uses foo>
यह संकलित नहीं करता है क्योंकि कुछ और कोड है जो फू का उपयोग करता है। हम देख सकते हैं कि संकलक कोड का उपयोग करने में सक्षम था जो बार का उपयोग करता है क्योंकि यह फू का उपयोग नहीं करता है। इस बिंदु पर, दो विकल्प हैं। मैकेनिकल को बस "}" को नीचे की ओर ले जाना है जब तक कि वह संकलित न हो जाए, और दूसरी पसंद कोड का निरीक्षण करना और यह निर्धारित करना है कि क्या ऑर्डर को इसमें बदला जा सकता है:
{
int foo = 0;
<code that uses foo>
}
<code that uses foo>
int bar = 1;
<code that uses bar>
यदि आदेश को स्विच किया जा सकता है, तो शायद यही आप चाहते हैं क्योंकि यह अस्थायी मूल्यों के जीवनकाल को छोटा करता है।
ध्यान देने वाली एक और बात, क्या कोड के ब्लॉक के बीच फू के मूल्य को संरक्षित करने की आवश्यकता है जो इसका उपयोग करते हैं, या यह दोनों में अलग-अलग फू हो सकता है। उदाहरण के लिए
int i;
for(i = 0; i < 8; ++i){
...
}
<some stuff>
for(i = 3; i < 32; ++i){
...
}
इन परिस्थितियों को मेरी प्रक्रिया से ज्यादा जरूरत है। डेवलपर को यह निर्धारित करने के लिए कोड का विश्लेषण करना होगा कि क्या करना है।
लेकिन पहला कदम पहला उपयोग मिल रहा है। आप इसे नेत्रहीन रूप से कर सकते हैं लेकिन कभी-कभी, घोषणा को हटाना आसान है, संकलन करने का प्रयास करें और इसे पहले उपयोग के ऊपर वापस रखें। यदि वह पहला उपयोग किसी इफ स्टेटमेंट के अंदर है, तो उसे वहां रखें और जांच करें कि क्या वह कंपाइल करता है। कंपाइलर फिर अन्य उपयोगों की पहचान करेगा। एक स्कोप ब्लॉक बनाने की कोशिश करें जिसमें दोनों उपयोग शामिल हों।
इसके बाद मैकेनिकल पार्ट किया जाता है, फिर डेटा कहां है, इसका विश्लेषण करना आसान हो जाता है। यदि किसी बड़े स्कोप ब्लॉक में वैरिएबल का उपयोग किया जाता है, तो स्थिति का विश्लेषण करें और देखें कि क्या आप एक ही वैरिएबल का उपयोग दो अलग-अलग चीजों के लिए कर रहे हैं (जैसे कि "i" जो दो छोरों के लिए उपयोग किया जाता है)। यदि उपयोग असंबंधित हैं, तो इन असंबंधित उपयोगों में से प्रत्येक के लिए नए चर बनाएं।