कितना शून्य जांच पर्याप्त है?

के लिए कोई नुक्कड़ जांचने के लिए आवश्यक कुछ दिशानिर्देश क्या हैं?कितना शून्य जांच पर्याप्त है?

देर से जारी किए गए बहुत से विरासत कोड में नल-चेक विज्ञापन मतली है। छोटे कार्यों पर शून्य जांच, एपीआई कॉल पर शून्य जांच जो गैर-शून्य रिटर्न इत्यादि। कुछ मामलों में, नल-चेक उचित हैं, लेकिन कई जगहों पर एक शून्य उचित उम्मीद नहीं है।

मैंने "अन्य कोड पर भरोसा नहीं कर सकते" से "कई कार्यक्रमों पर भरोसा नहीं कर सकते" से लेकर कई तर्क सुना है, जब तक कि भाषा मुझे एक गैर-शून्य मूल्य की गारंटी न दे, मैं हमेशा जांच कर रहा हूं। " मैं निश्चित रूप से उन सिद्धांतों में से कई बिंदुओं से सहमत हूं, लेकिन मुझे लगता है कि अत्यधिक नल-जांच अन्य समस्याओं का कारण बनती है जो आम तौर पर उन सिद्धांतों का उल्लंघन करती हैं। क्या दृढ़ शून्य जांच वास्तव में इसके लायक है?

अक्सर, मैंने उच्च गुणवत्ता वाले नहीं, वास्तव में गरीब गुणवत्ता के लिए अत्यधिक शून्य जांच के साथ कोड देखे हैं। अधिकांश कोड नल-चेक पर इतना ध्यान केंद्रित करते हैं कि डेवलपर ने अन्य महत्वपूर्ण गुणों जैसे कि पठनीयता, शुद्धता, या अपवाद हैंडलिंग की दृष्टि खो दी है। विशेष रूप से, मुझे लगता है कि बहुत सारे कोड std :: bad_alloc अपवाद को अनदेखा करते हैं, लेकिन new पर एक नल-चेक करें।

सी ++ में, मैं इसे कुछ हद तक समझता हूं क्योंकि एक शून्य सूचक को अपरिवर्तनीय व्यवहार के अप्रत्याशित व्यवहार के कारण; जावा, सी #, पायथन इत्यादि में शून्य ड्रेफरेंस को अधिक सुन्दर तरीके से संभाला जाता है। क्या मैंने अभी सतर्क नल-जांच के खराब उदाहरण देखे हैं या क्या वास्तव में कुछ ऐसा है?

यह प्रश्न भाषा अज्ञेयवादी होने का इरादा है, हालांकि मैं मुख्य रूप से सी ++, जावा और सी # में रूचि रखता हूं। होने के लिए निम्नलिखित अत्यधिक शामिल लगते हैं कि

अशक्त-चेकिंग के कुछ उदाहरणों में मैंने देखा है:

यह उदाहरण सी ++ कल्पना के रूप में गैर मानक compilers के लिए लेखांकन किया जा रहा है एक असफल नया अपवाद फेंकता है। जब तक आप स्पष्ट रूप से गैर-अनुपालन वाले कंपाइलर्स का समर्थन नहीं कर रहे हैं, तो क्या यह समझ में आता है? क्या यह जावा या सी # (या यहां तक कि सी ++/सीएलआर) जैसी प्रबंधित भाषा में कोई समझ बनाता है?

try { 
    MyObject* obj = new MyObject(); 
    if(obj!=NULL) { 
     //do something 
    } else { 
     //??? most code I see has log-it and move on 
     //or it repeats what's in the exception handler 
    } 
} catch(std::bad_alloc) { 
    //Do something? normally--this code is wrong as it allocates 
    //more memory and will likely fail, such as writing to a log file. 
}

एक अन्य उदाहरण है जब आंतरिक कोड पर काम कर रहा है। विशेष रूप से, यदि यह एक छोटी सी टीम है जो अपने स्वयं के विकास प्रथाओं को परिभाषित कर सकती है, तो यह अनावश्यक लगता है। कुछ परियोजनाओं या विरासत कोड पर, भरोसेमंद दस्तावेज उचित नहीं हो सकते हैं ... लेकिन नए कोड के लिए जो आप या आपकी टीम नियंत्रण करते हैं, क्या यह वास्तव में आवश्यक है?

यदि कोई तरीका है, जिसे आप देख सकते हैं और अपडेट कर सकते हैं (या डेवलपर जो चिंतित हो सकता है) में अनुबंध हो सकता है, क्या अभी भी नल की जांच करना आवश्यक है?

//X is non-negative. 
//Returns an object or throws exception. 
MyObject* create(int x) { 
    if(x<0) throw; 
    return new MyObject(); 
} 

try { 
    MyObject* x = create(unknownVar); 
    if(x!=null) { 
     //is this null check really necessary? 
    } 
} catch { 
    //do something 
}

एक निजी या अन्यथा आंतरिक समारोह के विकास, यह वास्तव में स्पष्ट रूप से एक अशक्त को संभालने के लिए जरूरी है कि जब अनुबंध गैर शून्य मान केवल आवश्यकता होने पर? एक नल-चेक एक जोर देने के लिए बेहतर क्यों होगा?

(जाहिर है, अपने सार्वजनिक एपीआई पर, अशक्त-जांच करता है महत्वपूर्ण के रूप में इसे गलत तरीके से एपीआई का उपयोग करने के लिए अपने उपयोगकर्ताओं पर चिल्लाना असभ्य माना जाता है कर रहे हैं)

//Internal use only--non-public, not part of public API 
//input must be non-null. 
//returns non-negative value, or -1 if failed 
int ParseType(String input) { 
    if(input==null) return -1; 
    //do something magic 
    return value; 
}

की तुलना में:

//Internal use only--non-public, not part of public API 
//input must be non-null. 
//returns non-negative value 
int ParseType(String input) { 
    assert(input!=null : "Input must be non-null."); 
    //do something magic 
    return value; 
}

कितना शून्य जांच पर्याप्त है?

उत्तर

संबंधित मुद्दे