जावा में नल से निपटने का सबसे अच्छा तरीका? [बन्द है]

Question

मेरे पास कुछ कोड है जो NullPointerException के कारण विफल हो रहा है। ऑब्जेक्ट पर एक विधि को बुलाया जा रहा है जहां ऑब्जेक्ट मौजूद नहीं है।

हालांकि, इससे मुझे इसे ठीक करने के सबसे अच्छे तरीके के बारे में सोचना पड़ा। क्या मैं हमेशा nulls के लिए रक्षात्मक रूप से कोड करता हूं ताकि मैं भविष्य में null पॉइंटर अपवादों के लिए प्रमाण कोड बनाऊं, या क्या मुझे null के कारण को ठीक करना चाहिए ताकि यह डाउनस्ट्रीम न हो जाए।

आपके क्या विचार हैं?

Comments

आप "अशक्त के कारण को ठीक क्यों नहीं करेंगे"? क्या आप इसका एक उदाहरण दे सकते हैं कि यह एकमात्र समझदार विकल्प क्यों नहीं है? स्पष्ट रूप से, कुछ आपको स्पष्ट से दूर धकेल रहा होगा। यह क्या है? जड़ को ठीक करने का कारण आपकी पहली पसंद क्यों नहीं है?

— S.Lott

खैर समस्या के "मूल कारण" को ठीक करने से अल्पावधि में मदद मिल सकती है, लेकिन यदि कोड अभी भी रक्षात्मक रूप से नल की जाँच नहीं कर रहा है और किसी अन्य प्रक्रिया द्वारा पुन: उपयोग किया जाता है जो अशक्त हो सकता है, तो मुझे इसे फिर से ठीक करना होगा।

— शॉन एफ

@ शॉन एफ: यदि कोड टूट गया है, तो यह टूट गया है। मुझे नहीं लगता कि अप्रत्याशित नल उत्पन्न करने के लिए कोड के लिए यह कैसे संभव है और तय नहीं हुआ। जाहिर है, कुछ "गूंगा प्रबंधन" या "राजनीतिक" सामान चल रहा है। या ऐसा कुछ जो गलत कोड को किसी तरह स्वीकार्य होने की अनुमति देता है। क्या आप बता सकते हैं कि कैसे गलत कोड तय नहीं हो रहा है? वह राजनीतिक पृष्ठभूमि क्या है जो आपको यह सवाल पूछने के लिए प्रेरित करती है?

— एस.लॉट

"बाद में डेटा निर्माण के लिए कमजोर, जिसमें यह शून्य था" इसका क्या मतलब है? यदि "मैं डेटा निर्माण दिनचर्या को ठीक कर सकता हूं" तो आगे कोई भेद्यता नहीं है। मैं यह समझने में असमर्थ हूं कि यह "बाद में डेटा निर्माण जो इसमें शून्य था" का अर्थ संभवतः हो सकता है? छोटी गाड़ी का सॉफ्टवेयर?

— लोट

@ एस.लॉट, एनकैप्सुलेशन और सिंगल जिम्मेदारी। आपके सभी कोड "नहीं" जानते हैं कि आपके सभी अन्य कोड क्या करते हैं। यदि कोई वर्ग फ्रोबिनएटर को स्वीकार करता है, तो यह संभवतया कुछ धारणाएं बनाता है कि फ्रोबिनेटर किसने और कैसे बनाया। यह "बाहरी" कोड से आता है, या यह कोड आधार के एक अलग हिस्से से आता है। मैं यह नहीं कह रहा हूं कि आपको छोटी गाड़ी का कोड ठीक नहीं करना चाहिए; लेकिन खोज "रक्षात्मक प्रोग्रामिंग" और आप पाएंगे कि ओपी किसका जिक्र कर रहा है।

— पॉल ड्रेपर 15

Answer 1

यदि नल आपकी विधि के लिए एक उचित इनपुट पैरामीटर है, तो विधि को ठीक करें। यदि नहीं, तो कॉलर को ठीक करें। "उचित" एक लचीला शब्द है, इसलिए मैं निम्नलिखित परीक्षण का प्रस्ताव करता हूं: विधि को एक शून्य इनपुट कैसे सौंपना चाहिए? यदि आपको एक से अधिक संभावित उत्तर मिलते हैं, तो अशक्त एक उचित इनपुट नहीं है।

Comments

यह वास्तव में उतना ही सरल है।

— biziclop

अमरूद में कुछ बहुत ही अच्छे हेल्पर के तरीके हैं जो अशक्त जाँच को सरल बनाते हैं Precondition.checkNotNull(...)। देखें stackoverflow.com/questions/3022319/...

मेरा नियम है कि यदि संभव हो तो समझदार चूक के लिए सब कुछ शुरू करना और बाद में अशक्त अपवादों के बारे में चिंता करना।

— davidk01

Thorbjørn: तो यह एक जानबूझकर NullPointerException के साथ एक आकस्मिक NullPointerException को प्रतिस्थापित करता है? कुछ मामलों में, शुरुआती जाँच उपयोगी या आवश्यक हो सकती है; लेकिन मुझे बहुत सारे बेतुके बायलरप्लेट अशक्त जांच से डरते हैं जो थोड़ा मूल्य जोड़ते हैं और बस कार्यक्रम को बड़ा बनाते हैं।

— user281377

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

— ब्रायन

Answer 2

शून्य का उपयोग न करें, वैकल्पिक का उपयोग करें

जैसा कि आपने बताया है, nullजावा में सबसे बड़ी समस्याओं में से एक यह है कि इसका उपयोग हर जगह किया जा सकता है , या कम से कम सभी संदर्भ प्रकारों के लिए।

यह बताना असंभव है कि nullक्या हो सकता है और क्या नहीं।

जावा 8 एक बेहतर पैटर्न पेश करता है Optional:।

और Oracle से उदाहरण:

String version = "UNKNOWN";
if(computer != null) {
  Soundcard soundcard = computer.getSoundcard();
  if(soundcard != null) {
    USB usb = soundcard.getUSB();
    if(usb != null) {
      version = usb.getVersion();
    }
  }
}

यदि इनमें से प्रत्येक एक सफल मान लौटा सकता है या नहीं दे सकता है, तो आप एपीआई को बदल सकते हैं Optional:

String name = computer.flatMap(Computer::getSoundcard)
    .flatMap(Soundcard::getUSB)
    .map(USB::getVersion)
    .orElse("UNKNOWN");

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

यदि आप जावा 8 का उपयोग नहीं कर रहे हैं, तो आप com.google.common.base.OptionalGoogle अमरूद में देख सकते हैं ।

अमरूद टीम द्वारा एक अच्छी व्याख्या: https://github.com/google/guava/wiki/UsingAndAvoidingNullExplained

कई भाषाओं के उदाहरणों के साथ अशक्त करने के लिए नुकसान की एक अधिक सामान्य व्याख्या: https://www.lucidchart.com/techblog/2015/08/31/the-worst-mistake-of-computer-science/

---

@ नोनल, @ न्यूबल

जावा 8 कोड एनोटेशन को पकड़ने में मदद करने के लिए इन एनोटेशन को जोड़ता है जैसे IDEs समस्याओं को पकड़ते हैं। वे अपनी प्रभावशीलता में काफी सीमित हैं।

---

जाँच करें कि यह कब समझ में आता है

अपने कोड की 50% जांच शून्य से न लिखें, खासकर अगर कुछ भी समझदार न हो तो आपका कोड एक nullमूल्य के साथ कर सकता है ।

दूसरी ओर, अगर nullइस्तेमाल किया जा सकता है और इसका मतलब कुछ है, तो इसका उपयोग करना सुनिश्चित करें।

---

अंततः, आप स्पष्ट रूप nullसे जावा से नहीं निकाल सकते । Optionalजब भी संभव हो, मैं दृढ़ता से एब्सट्रैक्ट को प्रतिस्थापित करने की सलाह देता हूं , और nullउन अन्य समय की जांच कर रहा हूं कि आप इसके बारे में कुछ उचित कर सकते हैं।

Comments

आम तौर पर, चार साल पुराने प्रश्नों के उत्तर कम गुणवत्ता के कारण नष्ट हो जाते हैं। जावा 8 (जो तब वापस मौजूद नहीं था) के बारे में बात करने से अच्छा काम समस्या हल कर सकता है।

लेकिन पाठ्यक्रम के मूल प्रश्न के लिए अप्रासंगिक। और क्या कहना है कि तर्क वास्तव में वैकल्पिक है?

— jwenting 8

@jwenting यह मूल प्रश्न के लिए पूरी तरह से प्रासंगिक है। "एक पेचकश के साथ एक नाखून को चलाने का सबसे अच्छा तरीका क्या है" का जवाब है "एक पेचकश के बजाय एक हथौड़ा का उपयोग करें"।

— 14

@jwenting, मुझे लगता है कि मैंने इसे कवर किया, लेकिन स्पष्टता के लिए: क्या यह तर्क वैकल्पिक नहीं है, मैं आमतौर पर अशक्तता की जांच नहीं करता। आपके पास नल की चेकिंग की 100 लाइनें और पदार्थ की 40 लाइनें होंगी। अधिक सार्वजनिक इंटरफेस पर नल की जांच करें, या जब नल वास्तव में समझ में आता है (यानी तर्क वैकल्पिक है)।

— पॉल ड्रेपर

@ J- बॉस, जावा में कैसे, क्या आप अनियंत्रित नहीं होंगे NullPointerException? एक NullPointerExceptionसचमुच हो सकता है हर बार आप जावा में एक उदाहरण विधि कॉल। आप throws NullPointerExceptionलगभग हर एक विधि में कभी भी होंगे।

— पॉल ड्रेपर

Answer 3

इसे संभालने के कई तरीके हैं, अपने कोड को पेप्पिंग करना if (obj != null) {}आदर्श नहीं है, यह गड़बड़ है, यह रखरखाव चक्र के दौरान बाद में कोड पढ़ते समय शोर जोड़ता है और त्रुटि प्रवण होता है, क्योंकि इस बॉयलर प्लेट को रैप करना भूल जाना आसान है।

यह इस बात पर निर्भर करता है कि क्या आप चाहते हैं कि कोड चुपचाप या विफल जारी रहे। है nullकोई त्रुटि या एक उम्मीद हालत।

अशक्त क्या है?

हर रक्षा और मामले में, नल डेटा की पूर्ण कमी का प्रतिनिधित्व करता है। डेटाबेस में नल उस स्तंभ के लिए मान की कमी का प्रतिनिधित्व करते हैं। एक शून्य रिक्त Stringके समान नहीं है String, एक शून्य intसिद्धांत में शून्य के समान नहीं है। व्यवहार में "यह निर्भर करता है"। खाली स्ट्रिंग वर्ग के लिए Stringएक अच्छा Null Objectकार्यान्वयन कर सकता है , क्योंकि Integerयह व्यापार तर्क पर निर्भर करता है।

विकल्प हैं:

1. Null Objectपैटर्न। अपनी वस्तु का एक उदाहरण बनाएं जो nullराज्य का प्रतिनिधित्व करता है, और Nullकार्यान्वयन के संदर्भ में उस प्रकार के सभी संदर्भों को इनिशियलाइज़ करता है। यह साधारण मूल्य प्रकार की वस्तुओं के लिए उपयोगी है जिनके पास अन्य वस्तुओं के लिए बहुत सारे संदर्भ नहीं हैं जो एक वैध राज्य के रूप में भी हो सकते हैं nullऔर होने की उम्मीद है null।

2. एक Null Checkerपहलू के साथ तरीकों को बुनाई के लिए पहलू ओरिएंटेड टूल का उपयोग करें जो मापदंडों को शून्य होने से रोकता है। यह उन मामलों के लिए है जहां nullएक त्रुटि है।

3. कम शोर assert()से ज्यादा बेहतर का उपयोग न करें if (obj != null){}।

4. कॉन्ट्रैक्ट एनफोर्समेंट टूल का इस्तेमाल करें जैसे कॉन्ट्रैक्ट्स फॉर जावा । AspectJ जैसा कुछ लेकिन समान नया के रूप में एक ही उपयोग के मामले और बाहरी विन्यास फाइल के बजाय एनोटेशन का उपयोग करता है। आस्पेक्ट्स और ऐसर्ट्स के दोनों कामों में से सर्वश्रेष्ठ।

1 आदर्श समाधान है जब आने वाले डेटा को जाना जाता है nullऔर इसे कुछ डिफ़ॉल्ट मान के साथ बदलने की आवश्यकता होती है, ताकि अपस्ट्रीम उपभोक्ताओं को सभी शून्य चेक बॉयलरप्लेट कोड से निपटना न पड़े। ज्ञात डिफ़ॉल्ट मानों के खिलाफ जाँच के रूप में अच्छी तरह से अधिक अभिव्यंजक होगा।

2, 3, और 4 केवल सुविधाजनक वैकल्पिक अपवाद जनरेटर हैं NullPointerExceptionजो कुछ अधिक जानकारीपूर्ण के साथ प्रतिस्थापित करते हैं, जो हमेशा और सुधार होता है।

अंततः

nullजावा में लगभग सभी मामलों में एक तर्क त्रुटि है। आपको हमेशा इसके मूल कारण को खत्म करने का प्रयास करना चाहिए NullPointerExceptions। आपको nullव्यावसायिक तर्क के रूप में शर्तों का उपयोग नहीं करने का प्रयास करना चाहिए । if (x == null) { i = someDefault; }बस उस डिफ़ॉल्ट ऑब्जेक्ट उदाहरण के लिए प्रारंभिक वर्गीकरण करें।

Comments

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

— रिचर्ड मिसिन

@ रीचर्ड: जब तक nullयह अप्रत्याशित नहीं है तब तक यह एक सच्ची त्रुटि है, फिर सब कुछ पूरी तरह से रुक जाना चाहिए।

डेटाबेस में और प्रोग्रामिंग कोड में अशक्तता को एक महत्वपूर्ण पहलू में अलग तरह से संभाला जाता है: प्रोग्रामिंग में null == null(यहां तक ​​कि पीएचपी में), लेकिन डेटाबेस में, null != nullक्योंकि डेटाबेस में यह "कुछ नहीं" के बजाय एक अज्ञात मूल्य का प्रतिनिधित्व करता है । दो अज्ञात अनिवार्य रूप से समान नहीं हैं, जबकि दो नोटिंग समान हैं।

— साइमन फोर्सबर्ग

Answer 4

अशक्त चेकों को जोड़ने से परीक्षण समस्याग्रस्त हो सकता है। देखिए यह शानदार व्याख्यान ...

Google टेक वार्ता व्याख्यान देखें: "स्वच्छ कोड वार्ता - चीजों की तलाश न करें!" वह इसके बारे में 24 मिनट के बारे में बात करता है

http://www.youtube.com/watch?v=RlfLCWKxHJ0&list=PL693EFD059797C21E

पैरानॉयड प्रोग्रामिंग में हर जगह अशक्त जांच को शामिल करना शामिल है। पहले एक परीक्षण के नजरिए से एक अच्छे विचार की तरह लगता है, लेकिन इससे निपटने के लिए यह आपके अशक्त प्रकार के परीक्षण को कठिन बना देता है।

इसके अलावा, जब आप किसी वस्तु के अस्तित्व के लिए एक पूर्व शर्त बनाते हैं जैसे कि

class House(Door door){

    .. null check here and throw exception if Door is NULL
    this.door = door
}

यह आपको सदन बनाने से रोकता है क्योंकि आप एक अपवाद फेंक रहे होंगे। मान लें कि आपके परीक्षण मामले डोर के अलावा किसी अन्य चीज के परीक्षण के लिए नकली वस्तुएं बना रहे हैं, ठीक है, आप ऐसा नहीं कर सकते क्योंकि दरवाजा आवश्यक है

मॉक क्रिएशन नर्क से गुजरने वालों को इस प्रकार की झुंझलाहटों के बारे में अच्छी तरह पता होता है।

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

आपको हमेशा ऐसे अनुप्रयोगों को प्राथमिकता देनी चाहिए जो काम करते हैं क्योंकि आपके पास कई परीक्षण हैं जो इसे साबित करते हैं, बल्कि यह काम करता है कि यह सिर्फ इसलिए काम करता है क्योंकि आपके पास सभी जगह पर बिना शर्त के चेक का एक पूरा गुच्छा है

Answer 5

tl; dr - यह अप्रत्याशित nulls के लिए जाँच करने के लिए अच्छा है, लेकिन उन्हें अच्छा बनाने की कोशिश करने के लिए एक आवेदन के लिए BAD।

विवरण

स्पष्ट रूप से, ऐसी परिस्थितियां हैं जहां nullएक विधि के लिए एक वैध इनपुट या आउटपुट है, और अन्य जहां यह नहीं है।

नियम 1:

एक विधि के लिए javadoc जो एक nullपैरामीटर की अनुमति देता है या एक nullमान लौटाता है, उसे स्पष्ट रूप से दस्तावेज करना चाहिए , और nullइसका मतलब क्या होना चाहिए ।

नियम # 2:

nullजब तक ऐसा करने का एक अच्छा कारण नहीं है, तब तक एपीआई पद्धति को स्वीकार या वापसी के रूप में निर्दिष्ट नहीं किया जाना चाहिए ।

किसी विधि के "अनुबंध" के स्पष्ट विवरण को देखते हुए null, यह एक प्रोग्रामिंग त्रुटि है जिसे आपको पास nullनहीं करना चाहिए या वापस नहीं करना चाहिए।

नियम # 3:

एक अनुप्रयोग को "अच्छी" प्रोग्रामिंग त्रुटियों को बनाने का प्रयास नहीं करना चाहिए।

यदि कोई विधि पता लगाती है nullकि उसे वहाँ नहीं होना चाहिए, तो उसे किसी और चीज़ में बदलकर समस्या को ठीक करने का प्रयास नहीं करना चाहिए। यह सिर्फ प्रोग्रामर से समस्या को छुपाता है। इसके बजाय, इसे एनपीई को होने देना चाहिए, और विफलता का कारण बनना चाहिए ताकि प्रोग्रामर यह पता लगा सके कि मूल कारण क्या है और इसे ठीक करें। उम्मीद है कि परीक्षण के दौरान विफलता देखी जाएगी। यदि नहीं, तो यह आपके परीक्षण पद्धति के बारे में कुछ कहता है।

नियम # 4:

जहां संभव हो, प्रोग्रामिंग त्रुटियों का जल्द पता लगाने के लिए अपना कोड लिखें।

यदि आपको अपने कोड में बग्स मिले हैं, जिसके परिणामस्वरूप बहुत सारे NPEs हैं, तो सबसे मुश्किल चीज यह पता लगा सकती है कि nullमूल्य कहां से आए थे। निदान को आसान बनाने का एक तरीका यह nullहै कि आप अपना कोड लिखें ताकि जल्द से जल्द इसका पता चल जाए। अक्सर आप इसे अन्य जांचों के साथ मिलकर कर सकते हैं; जैसे

public setName(String name) {
    // This also detects `null` as an (intended) side-effect
    if (name.length() == 0) {
        throw new IllegalArgumentException("empty name");
    }
}

(स्पष्ट रूप से ऐसे मामले हैं जहां नियम 3 और 4 को वास्तविकता के साथ टेम्पर्ड किया जाना चाहिए। उदाहरण के लिए (नियम 3), कुछ प्रकार के अनुप्रयोगों को संभवतः प्रोग्रामिंग त्रुटियों का पता लगाने के बाद जारी रखने का प्रयास करना चाहिए । और (नियम 4) खराब मापदंडों के लिए बहुत अधिक जाँच हो सकती है। एक प्रदर्शन प्रभाव।)

Answer 6

मैं रक्षात्मक होने के लिए विधि को ठीक करने की सलाह दूंगा। उदाहरण के लिए:

String go(String s){  
    return s.toString();  
}

इस की तर्ज पर अधिक होना चाहिए:

String go(String s){  
    if(s == null){  
       return "";  
    }     
    return s.toString();  
}

मुझे लगता है कि यह बिल्कुल तुच्छ है, लेकिन अगर आक्रमणकारी को उम्मीद है कि एक वस्तु उन्हें एक डिफ़ॉल्ट वस्तु देगी जो कि एक अशक्त होने का कारण नहीं होगी।

Comments

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

— गोरन जोविक

यदि यह जावा है, तो आपको बिल्कुल भी उपयोग नहीं करना चाहिए new String()।

— biziclop

@biziclop वास्तव में यह सबसे अधिक एहसास की तुलना में कहीं अधिक महत्वपूर्ण है।

— वुट 4Moo

मेरी राय में यह तर्क देने के लिए अधिक समझ में आता है और यदि तर्क स्पष्ट रूप से कॉलर की गलती है, तो एक अपवाद को फेंक दें। चुपचाप कॉलर गलतियों को "ठीक" न करें; इसके बजाय, उन्हें उनके बारे में अवगत कराएँ।

— एंड्रेस एफ।

@ Woot4Moo तो अपना खुद का कोड लिखें जो एक अपवाद फेंकता है। महत्वपूर्ण बात यह है कि फोन करने वाले को सूचित करें कि उनके पारित तर्क गलत हैं, और उन्हें जल्द से जल्द बताएं। चुपचाप एन सही nullकरना सबसे खराब संभव विकल्प है, एनपीई फेंकने से भी बदतर।

— एंड्रेस एफ।

Answer 7

अशक्त के बारे में निम्नलिखित सामान्य नियमों ने मुझे अब तक बहुत मदद की है:

1. यदि डेटा आपके नियंत्रण से बाहर आता है, तो व्यवस्थित रूप से नल की जांच करें और उचित रूप से कार्य करें। इसका मतलब है कि या तो एक अपवाद को फेंकना जो फ़ंक्शन के लिए समझ में आता है (जाँच या अनियंत्रित, बस सुनिश्चित करें कि अपवाद का नाम आपको बताता है कि वास्तव में क्या चल रहा है।)। लेकिन कभी भी अपने सिस्टम में एक ऐसे मूल्य को ढीला न करें जो संभावित रूप से आश्चर्यचकित कर सकता है।

2. यदि नल आपके डेटा मॉडल के लिए उपयुक्त मानों के क्षेत्र में है, तो उचित तरीके से उससे निपटें।

3. जब भी मान लौटाते हैं तो जब भी संभव हो नल नहीं लौटाने की कोशिश करते हैं। हमेशा खाली सूची, खाली तार, अशक्त वस्तु पैटर्न पसंद करते हैं। जब यह किसी दिए गए उपयोग के मामले के लिए डेटा का सबसे अच्छा संभव प्रतिनिधित्व है, तो लौटाए गए मानों के रूप में नल रखें।

4. शायद सभी में सबसे महत्वपूर्ण ... परीक्षण, परीक्षण और फिर से परीक्षण। अपने कोड का परीक्षण करते समय इसे कोडर के रूप में परीक्षण न करें और इसे नाजी मनोचिकित्सा डोमेट्रिक्स के रूप में परीक्षण करें और उस कोड से बाहर नरक को यातना देने के सभी प्रकार की कल्पना करने का प्रयास करें।

यह शून्य के बारे में पागल पक्ष पर थोड़ा झुकता है, जो अक्सर बाहरी दुनिया के लिए इंटरफ़ेस सिस्टम और परदे के पीछे ले जाता है और प्रचुर मात्रा में अतिरेक के साथ अंदर में सख्ती से नियंत्रित मूल्यों को नियंत्रित करता है। यहाँ बाहर की दुनिया का मतलब है बहुत ज्यादा सब कुछ जो मैंने खुद को कोड नहीं किया। यह एक लागत रनटाइम सहन करता है, लेकिन अभी तक मुझे शायद ही कभी कोड के "शून्य सुरक्षित अनुभाग" बनाकर इसे अनुकूलित करना पड़ा था। हालांकि मुझे कहना होगा कि मैं स्वास्थ्य देखभाल के लिए ज्यादातर लंबे समय तक चलने वाले सिस्टम का निर्माण करता हूं और आखिरी चीज जो मैं चाहता हूं वह यह है कि एक अनपेक्षित अशक्त सूचक के कारण सीटी स्कैनर क्रैश में आपके आयोडीन एलर्जी को ले जाने वाला इंटरफ़ेस सबसिस्टम है क्योंकि किसी अन्य सिस्टम में किसी अन्य व्यक्ति को कभी भी यह एहसास नहीं हुआ कि नाम हो सकता है एपोस्ट्रोफ या वर्ण जैसे or。 like

वैसे भी .... मेरे 2 सेंट

Answer 8

मैं कार्यात्मक भाषाओं से विकल्प / कुछ / कोई नहीं पैटर्न का उपयोग करने का प्रस्ताव करूंगा। मैं एक जावा विशेषज्ञ नहीं हूं, लेकिन मैं अपने सी # प्रोजेक्ट में इस पैटर्न के अपने कार्यान्वयन का गहनता से उपयोग करता हूं, और मुझे यकीन है कि इसे जावा दुनिया में परिवर्तित किया जा सकता है।

इस पैटर्न के पीछे का विचार यह है: यदि यह तार्किक रूप से ऐसी स्थिति है, जब किसी मूल्य की अनुपस्थिति की संभावना है (उदाहरण के लिए, जब आईडी से डेटाबेस से पुनर्प्रयास करते हुए) आप प्रकार का एक विकल्प प्रदान करते हैं [T], जहां T एक संभावित मान है । यदि श्रेणी का कोई मान ऑब्जेक्ट की अनुपस्थिति का कोई मामला नहीं है [T] लौटाया जाता है, यदि मूल्य का अस्तित्व - कुछ [T] का मान लौटाया जाता है, जिसमें मान होता है।

इस मामले में, आपको मूल्य अनुपस्थिति की संभावना को संभालना चाहिए , और यदि आप कोड समीक्षा करते हैं तो आप आसानी से गलत हैंडलिंग का स्थान पा सकते हैं। C # भाषा कार्यान्वयन से प्रेरणा प्राप्त करने के लिए मेरे बिटबकेट रिपॉजिटरी https://bitbucket.org/mikegirkin/optionsomenone का संदर्भ लें

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

Answer 9

ठीक है, अगर आपकी विधि के संभावित परिणामों में से एक अशक्त मूल्य है, तो आपको उसके लिए रक्षात्मक रूप से कोड करना चाहिए, लेकिन अगर एक विधि को गैर-अशक्त लौटना माना जाता है, लेकिन क्या मैं इसे सुनिश्चित करने के लिए ठीक नहीं करूंगा।

हमेशा की तरह यह मामले पर निर्भर करता है, जैसा कि जीवन में ज्यादातर चीजों के साथ होता है :)

Answer 10

अपाचे कॉमन्स के लैंब लाइब्रेरीज़ अशक्त मूल्यों को संभालने का एक तरीका प्रदान करती हैं

विधि defaultIfNull में क्लास ObjectUtils आपको एक डिफ़ॉल्ट मान वापस करने के लिए सक्षम करता है यदि ऑब्जेक्ट पास हो गया है

Answer 11

1. वैकल्पिक प्रकार का उपयोग न करें, जब तक कि यह वास्तव में वैकल्पिक न हो, अक्सर निकास को अपवाद के रूप में बेहतर तरीके से नियंत्रित किया जाता है, जब तक कि आप वास्तव में विकल्प के रूप में अशक्त होने की उम्मीद नहीं कर रहे थे, और इसलिए नहीं कि आप नियमित रूप से छोटी गाड़ी कोड लिखते हैं।

2. यह समस्या एक प्रकार से शून्य नहीं है क्योंकि इसके उपयोग हैं, जैसा कि Google का लेख बताता है। समस्या यह है कि नल को जांचना और संभालना चाहिए, अक्सर उन्हें इनायत से बाहर निकाला जा सकता है।

3. प्रोग्राम के नियमित संचालन के बाहर के क्षेत्रों में अमान्य स्थितियों का प्रतिनिधित्व करने वाले कई मामले हैं (अमान्य उपयोगकर्ता इनपुट, डेटाबेस समस्याएं, नेटवर्क विफलता, फ़ाइलें गुम होना, भ्रष्ट डेटा), जो कि उन लोगों के लिए जाँच की अपवाद हैं, उन्हें संभालना, यहां तक ​​कि अगर यह सिर्फ इसे लॉग इन करना है।

4. जेवीएम में एक प्रकार के विरोध के रूप में अपवाद संचालन को अलग-अलग परिचालन प्राथमिकताओं और विशेषाधिकारों की अनुमति दी जाती है, जैसे कि वैकल्पिक, जो कि उनकी घटना की असाधारण प्रकृति के लिए समझ में आता है, जिसमें हैंडलर की प्राथमिकता वाले आलसी लोडिंग के लिए प्रारंभिक समर्थन शामिल है, क्योंकि यह याद नहीं है। हर समय इसे लटकाए रखने की आवश्यकता है।

5. आपको सभी जगह अशक्त हैंडलर लिखने की आवश्यकता नहीं है, केवल जहाँ वे होने की संभावना है, कहीं भी आप संभावित अविश्वसनीय डेटा सेवा तक पहुंच रहे हैं, और चूंकि इनमें से अधिकांश कुछ सामान्य पैटर्न में आते हैं जो आसानी से सार हो सकते हैं, जिन्हें आपको वास्तव में केवल आवश्यकता है एक हैंडलर कॉल, दुर्लभ मामलों को छोड़कर।

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