जावा में, किसी फ़ंक्शन के शीर्ष पर चर घोषित किया जाना चाहिए, या जैसा कि उनकी आवश्यकता है?

Question

मैं किसी ऐसे व्यक्ति के लिए जावा कोड साफ़ कर रहा हूं जो सभी चरों को शीर्ष पर घोषित करके अपने कार्यों को शुरू करता है, और उन्हें बाद में घोषित करने के विपरीत उन्हें शून्य/0/जो भी हो, उन्हें बाद में जरूरी है।

इसके लिए विशिष्ट दिशानिर्देश क्या हैं? क्या एक तरफ या दूसरे के लिए अनुकूलन कारण हैं, या सिर्फ एक अच्छा तरीका है? क्या ऐसे कोई मामले हैं जहां इसे करने का उचित तरीका से विचलित होना स्वीकार्य है?

Answer 1

पहले स्थान के करीब के रूप में वेरिएबल्स घोषित करें जिन्हें आप संभवतः उपयोग करते हैं। यह वास्तव में दक्षता के साथ कुछ भी नहीं है, लेकिन आपके कोड को और अधिक पठनीय बनाता है। एक चर के करीब घोषित किया जाता है जहां इसका उपयोग किया जाता है, बाद में कोड पढ़ने के दौरान आपको कम स्क्रॉलिंग/खोज करना पड़ता है। उनके द्वारा उपयोग किए जाने वाले पहले स्थान के करीब चर घोषित करने से स्वाभाविक रूप से उनके scope को संकीर्ण कर दिया जाएगा।

Answer 2

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

यदि आपका फ़ंक्शन एक आरामदायक समझने योग्य आकार है, तो "सभी सामने" और "बस आवश्यक" के बीच कोई अंतर नहीं है।

एकमात्र गैर-फ्रंट-फ्रंट चर for कथन के शरीर में होगा।

for(Iterator i= someObject.iterator(); i.hasNext();) 

Answer 3

मुझे पता चला है कि शुरुआत में उन्हें घोषित करने की तुलना में उन्हें कम गलतियों में आवश्यक परिणाम घोषित करना है। मैंने यह भी पाया है कि गलतियों को रोकने के लिए उन्हें न्यूनतम दायरे में घोषित करना संभव है।

जब मैंने कुछ साल पहले घोषणा के स्थान से उत्पन्न बाइट-कोड देखा, तो मैंने पाया कि वे कम या समान थे। जब उन्हें सौंपा गया था, तो उस पर निर्भर करता था। यहां तक ​​कि कुछ इस तरह:

for(Object o : list) { 
    Object temp = ...; //was not "redeclared" every loop iteration 
} 

बनाम

Object temp; 
for(Object o : list) { 
    temp = ...; //nearly identical bytecoode, if not exactly identical. 
} 

कम या ज्यादा समान

Answer 4

इसकी पठनीयता और बजाय व्यक्तिगत पसंद प्रदर्शन की बात बाहर आया था। कंपाइलर परवाह नहीं करता है और वैसे भी वही कोड उत्पन्न करेगा।

Answer 5

मैंने लोगों को शीर्ष पर और कार्यों के निचले हिस्से में घोषित किया है। मैं शीर्ष पसंद करता हूं, जहां मैं उन्हें जल्दी देख सकता हूं। यह पसंद और वरीयता का मामला है।

Answer 6

Java Code Conventions से

, Chapter 6 on Declarations: केवल ब्लॉक की शुरुआत पर

6,3 प्लेसमेंट

रखें घोषणाओं। (एक ब्लॉक घुमावदार ब्रेसिज़ "{" और "}" से घिरा हुआ कोई कोड है।) चरम को उनके पहले उपयोग तक घोषित करने की प्रतीक्षा न करें; यह को अनचाहे प्रोग्रामर और बाधा कोड दायरे के भीतर पोर्टेबिलिटी को भ्रमित कर सकता है।

for (int i = 0; i < maxLoops; i++) { ... } 

स्थानीय घोषणाओं कि उच्च स्तर पर घोषणाओं को छिपाने से बचें:

void myMethod() { 
    int int1 = 0;   // beginning of method block 

    if (condition) { 
     int int2 = 0;  // beginning of "if" block 
     ... 
    } 
} 

एक अपवाद नियम के छोरों के लिए की अनुक्रमित है, जो जावा में बयान के लिए में घोषित किया जा सकता है। उदाहरण के लिए, एक आंतरिक ब्लॉक में एक ही चर नाम की घोषणा नहीं है:

int count; 
... 
myMethod() { 
    if (condition) { 
     int count = 0;  // AVOID! 
     ... 
    } 
    ... 
} 

Answer 7

उचित तरीके से जब वे पहली बार उपयोग किया जाता है वास्तव में चर घोषित करने और कोड को आसान बनाने के क्रम में उनके दायरे को कम करना है समझने के लिए।

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

कुछ लोग इस बात का दावा करके अभ्यास की रक्षा करने का प्रयास कर सकते हैं कि यह "neater" है, लेकिन किसी विधि के भीतर कोड को "व्यवस्थित" करने की आवश्यकता आमतौर पर एक मजबूत संकेत है कि विधि बस बहुत लंबी है।

Answer 8

मैं इस समय एक ही चीज़ कर रहा हूं। कोड में सभी चर जो मैं पुनर्विक्रय कर रहा हूं, फ़ंक्शन के शीर्ष पर घोषित किए गए हैं। मैंने देखा है कि मैं इस बात को देख रहा हूं कि कई चर घोषित किए गए हैं लेकिन कभी भी उपयोग नहीं किए जाते हैं या उन्हें घोषित किया जाता है और उनके साथ संचालन किए जा रहे हैं (यानी String को पार्स करना और फिर Calendar ऑब्जेक्ट को दिनांक/समय मानों के साथ सेट करना स्ट्रिंग) लेकिन फिर परिणामस्वरूप Calendar ऑब्जेक्ट का उपयोग कभी नहीं किया जाता है।

मैं शीर्ष से घोषणाएं लेकर उन्हें फ़ंक्शन में नीचे ले जा रहा हूं और इसे उस स्थान पर स्थानांतरित कर रहा हूं जहां इसका उपयोग किया जाता है।

Answer 9

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

इसी प्रकार आपको सचमुच शाब्दिक अर्थों में चर से बचने की कोशिश करनी चाहिए। सभी चीजों को एक बार असाइन करने का प्रयास करें, और उन्हें अंतिम घोषित करें ताकि यह पाठक को ज्ञात हो। ट्रैक रखने के लिए नहीं है कि कुछ बदलता है या वास्तव में संज्ञानात्मक भार में कटौती नहीं करता है।

Answer 10

मुझे लगता है कि यह वास्तव में निष्पक्ष रूप से साबित होता है कि घोषणा-पर-शीर्ष शैली अधिक त्रुटि-प्रवण है।

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

मुझे नहीं लगता कि घोषित करने के लिए शीर्ष पर कोई समान लाभ है जो व्यक्तिगत वरीयता पर नहीं आ जाता है।

तो मान लें कि आप विश्वसनीय कोड लिखना चाहते हैं, केवल समय-समय पर घोषणा करना पसंद करना सीखें।

Answer 11

Google Java Style Guide से:

4.8.2.2 जब जरूरत

स्थानीय चर आदतन उनके धारक ब्लॉक या ब्लॉक की तरह निर्माण के शुरू में घोषित नहीं कर रहे हैं घोषित। इसके बजाए, स्थानीय चर उस बिंदु के करीब घोषित किए गए हैं जिसका उपयोग पहले (कारण के भीतर) किया गया था, उनके दायरे को कम करें। स्थानीय परिवर्तनीय घोषणाओं में आमतौर पर प्रारंभकर्ता होते हैं, या घोषणा के तुरंत बाद प्रारंभ किए जाते हैं।

ठीक है, मैं का पालन करना होगा गूगल, क्या करता है एक सतही स्तर यह लग सकता है कि विधि के शीर्ष पर सभी चर घोषित/समारोह "neater" होगा पर, यह काफी स्पष्ट है कि यह फायदेमंद होगा आवश्यकतानुसार चर घोषित करने के लिए। हालांकि यह व्यक्तिपरक है, जो भी आपको सहज महसूस करता है।

Answer 12

सिद्धांत: स्थानीय वैरिएबल घोषणाओं को जितना संभव हो सके अपने पहले उपयोग के करीब रखें, और केवल एक विधि के शीर्ष पर नहीं। इस उदाहरण पर विचार:

/** Return true iff s is a blah or a blub. */ 
public boolean checkB(String s) { 
    // Return true if s is a blah 
    ... code to return true if s is a blah ... 

    // Return true if s is a blub. */ 
    int helpblub= s.length() + 1; 
    ... rest of code to return true is s is a blah. 

    return false; 
} 

इधर, स्थानीय चर helpblub जहां यह आवश्यक है रखा गया है, कोड में परीक्षण करने के लिए है कि क्या एक blub है। यह कोड का हिस्सा है जो लागू करता है "वापसी सच है एक ब्लब है"। यह विधि के पहले कथन के रूप में helpblub की घोषणा करने के लिए बिल्कुल कोई तार्किक अर्थ नहीं बनाता है। गरीब पाठक आश्चर्यचकित होंगे, वह चर क्यों है? ये किसके लिये है?