क्या मुझे अपने तरीकों में खाली संग्रह स्वीकार करना चाहिए जो उन पर पुनरावृति करता है?

Question

मेरे पास एक विधि है जहां सभी तर्क एक फॉरेस्ट लूप के अंदर किए जाते हैं जो विधि के पैरामीटर से अधिक होता है:

public IEnumerable<TransformedNode> TransformNodes(IEnumerable<Node> nodes)
{
    foreach(var node in nodes)
    {
        // yadda yadda yadda
        yield return transformedNode;
    }
}

इस मामले में, एक खाली संग्रह में भेजने के परिणामस्वरूप एक खाली संग्रह होता है, लेकिन मैं सोच रहा हूं कि क्या यह नासमझ है।

यहाँ मेरा तर्क यह है कि यदि कोई इस पद्धति को कॉल कर रहा है, तो वे डेटा को पास करने का इरादा रखते हैं, और केवल विषम परिस्थितियों में मेरे तरीके के लिए एक खाली संग्रह पारित करेंगे।

क्या मुझे इस व्यवहार को पकड़ना चाहिए और इसके लिए एक अपवाद फेंकना चाहिए, या खाली संग्रह को वापस करने के लिए सबसे अच्छा अभ्यास है?

Comments

क्या आपको यकीन है कि आपकी धारणा "यदि कोई इस पद्धति को बुला रहा है, तो वे डेटा को पास करने का इरादा रखते हैं" सही है? हो सकता है कि वे परिणाम के साथ काम करने के लिए बस वही कर रहे हों जो उन्हें मिला था।

— स्पेसट्रूकर

BTW: आपकी "ट्रांसफ़ॉर्मिंग" विधि को आमतौर पर "मैप" कहा जाता है, हालाँकि .NET (और एसक्यूएल में, जहाँ .NET को नाम मिला है), इसे आमतौर पर "सिलेक्ट" कहा जाता है। "ट्रांसफॉर्म" वह है जो C ++ इसे कहता है, लेकिन यह एक सामान्य नाम नहीं है जिसे कोई भी पहचान सकता है।

— जोर्ग डब्ल्यू मित्तग

अगर संग्रह nullखाली है तो मैं फेंक दूँगा ।

— कोडइन्चोस

@NickUdell - मैं हर समय अपने कोड में खाली संग्रह पास करता हूं। कोड के लिए यह आसान है कि आप उन मामलों के लिए विशेष ब्रांचिंग लॉजिक लिखें, जहां मैं इसके साथ आगे बढ़ने से पहले अपने संग्रह में कुछ भी नहीं जोड़ सका।

— TheMayer

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

— रेयान

Answer 1

उपयोगिता विधियों को खाली संग्रह पर नहीं फेंकना चाहिए। आपके API क्लाइंट इसके लिए आपसे घृणा करेंगे।

एक संग्रह खाली हो सकता है; एक "संग्रह-कि-नहीं-होना-खाली" वैचारिक रूप से साथ काम करने के लिए एक बहुत अधिक कठिन बात है।

खाली संग्रह को बदलना एक स्पष्ट परिणाम है: खाली संग्रह। (आप पैरामीटर को वापस करके भी कुछ कचरा बचा सकते हैं।)

ऐसी कई परिस्थितियाँ हैं जिनमें एक मॉड्यूल सामान की सूची रखता है जो पहले से ही कुछ से भरा हो सकता है या नहीं हो सकता है। प्रत्येक कॉल से पहले खालीपन की जाँच transformकरना कष्टप्रद है और एक सरल, सुरुचिपूर्ण एल्गोरिथ्म को बदसूरत गड़बड़ में बदलने की क्षमता रखता है।

उपयोगिता विधियों को हमेशा अपने इनपुट में उदारवादी और अपने आउटपुट में रूढ़िवादी होने का प्रयास करना चाहिए।

इन सभी कारणों से, परमेश्वर के लिए, खाली संग्रह को सही ढंग से संभालें। हेल्पर मॉड्यूल की तुलना में कुछ भी अधिक अतिरंजित नहीं है जो सोचता है कि यह जानता है कि आप जो चाहते हैं उससे बेहतर है।

Comments

+1 - (अधिक अगर मैं कर सकता था)। मैं इतनी दूर तक भी जा सकता हूं nullकि खाली संग्रह में भी सहवास कर सकूं । अंतर्निहित सीमाओं के साथ कार्य एक दर्द है।

— तेलस्टिन

"नहीं, आपको नहीं" ... उन्हें स्वीकार नहीं करना चाहिए या एक अपवाद नहीं फेंकना चाहिए?

— बेन आरोनसन

@Andy - उन उपयोगिता विधियों हालांकि नहीं होगा । वे व्यवसाय के तरीके या कुछ इसी तरह के ठोस व्यवहार होंगे।

— तेलस्टिन

मुझे नहीं लगता कि एक वापसी के लिए खाली संग्रह को पुनर्चक्रित करना एक अच्छा विचार है। आप केवल एक छोटी सी मेमोरी बचा रहे हैं; और यह कॉलर में अप्रत्याशित व्यवहार कर सकता है। थोड़ा-बहुत विरोधाभासी उदाहरण: Populate1(input); output1 = TransformNodes(input); Populate2(input); output2 = TransformNodes(input); यदि Populate1 ने संग्रह को खाली छोड़ दिया और आपने इसे पहले TransformNodes कॉल के लिए वापस कर दिया, तो आउटपुट 1 और इनपुट समान संग्रह होगा, और जब Populaten2 को कॉल किया गया तो यह संग्रह में नोड्स को आपके दूसरे के साथ समाप्त कर देगा। आउटपुट 2 में इनपुट का सेट।

— डैन नीली

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

— एंड्रीज डोयले

Answer 2

मुझे दो महत्वपूर्ण प्रश्न दिखाई देते हैं जो इसका उत्तर निर्धारित करते हैं:

1. खाली संग्रह ( शून्य सहित ) पारित होने पर क्या आपका कार्य सार्थक और तार्किक हो सकता है ?
2. इस एप्लीकेशनटन / लाइब्रेरी / टीम में सामान्य प्रोग्रामिंग शैली क्या है? (विशेष रूप से, आप कैसे एफपी हैं?)

1. सार्थक वापसी

अनिवार्य रूप से, यदि आप कुछ सार्थक लौटा सकते हैं, तो एक अपवाद न फेंकें। कॉलर को परिणाम के साथ सौदा करने दें। इसलिए यदि आपका कार्य ...

• संग्रह में तत्वों की संख्या गिनता है, 0. लौटें। यह आसान था।
• ऐसे तत्वों की खोज जो विशेष मानदंडों से मेल खाते हैं, एक खाली संग्रह लौटाते हैं। कृपया कुछ भी मत फेंको। कॉलर के पास संग्रह का एक बड़ा संग्रह हो सकता है, जिनमें से कुछ खाली हैं, कुछ नहीं। कॉलर किसी भी संग्रह में किसी भी मिलान तत्वों को चाहता है। अपवाद केवल कॉलर के जीवन को कठिन बनाते हैं।
• सूची में सबसे बड़े / सबसे छोटे / सबसे फिट-टू-द-मापदंड की तलाश में है। उफ़। शैली के प्रश्न के आधार पर, आप एक अपवाद यहां फेंक सकते हैं या आप अशक्त लौट सकते हैं । मैं अशक्त (बहुत अधिक एफपी व्यक्ति) से नफरत करता हूं, लेकिन यह यकीनन यहां अधिक सार्थक है और यह आपको अपने कोड के भीतर अप्रत्याशित त्रुटियों के लिए अपवादों को आरक्षित करने देता है। यदि कॉलर अशक्त के लिए जाँच नहीं करता है, एक काफी स्पष्ट अपवाद वैसे भी परिणाम देगा। लेकिन आप उन्हें छोड़ दें।
• संग्रह में nth आइटम या पहले / अंतिम n आइटम के लिए पूछता है। यह एक अपवाद के लिए सबसे अच्छा मामला है और जो कम से कम कॉल करने वाले के लिए भ्रम और कठिनाई का कारण है। यदि आप और आपकी टीम पिछले बिंदु में दिए गए सभी कारणों के लिए जाँच करने के लिए उपयोग किए जाते हैं, तब भी अशक्त होने के लिए एक मामला बनाया जा सकता है , लेकिन यह ड्यूड यू नो यसहोल्डचेक TheSeffirst अपवाद को फेंकने के लिए अभी तक का सबसे वैध मामला है। यदि आपकी शैली अधिक कार्यात्मक है, तो मेरी शैली उत्तर पर या तो अशक्त या पढ़ें ।

सामान्य तौर पर, मेरे एफपी पूर्वाग्रह मुझे कुछ अर्थपूर्ण बताते हैं और इस मामले में शून्य का वैध अर्थ हो सकता है।

2. शैली

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

F # वह जगह है जहाँ सभी शांत .Net बच्चे इस तरह की चीज़ करते हैं लेकिन C # इस शैली का समर्थन करता है।

tl; डॉ

अपने स्वयं के कोड पथ में अप्रत्याशित त्रुटियों के अपवाद रखें, किसी और व्यक्ति से पूरी तरह से देखने योग्य (और कानूनी) इनपुट नहीं।

Comments

"सबसे अच्छा फिट" आदि। आपके पास एक ऐसी विधि हो सकती है जो संग्रह में सबसे अच्छी फिट वस्तु को ढूंढती है जो कुछ मानदंड से मेल खाती है। उस पद्धति में गैर-खाली संग्रह के लिए समान समस्या होगी, क्योंकि कुछ भी मानदंड फिट नहीं हो सकता है, इसलिए खाली चयनों के बारे में चिंता करने की आवश्यकता नहीं है।

— gnasher729

नहीं, यही कारण है कि मैंने कहा ¨best fit that और ¨matches¨ नहीं; वाक्यांश का तात्पर्य निकटतम सन्निकटन है, सटीक मिलान नहीं। सबसे बड़ा / सबसे छोटा विकल्प एक सुराग होना चाहिए था। यदि केवल anybest fit¨ के लिए कहा गया है, तो 1 या अधिक सदस्यों वाले किसी भी संग्रह को एक सदस्य को वापस करने में सक्षम होना चाहिए। यदि केवल एक सदस्य है, तो वह सबसे अच्छा है।

— itsbruce

अधिकांश मामलों में "अशक्त" लौटें तो अपवाद फेंक दिया जाता है। हालाँकि एक खाली संग्रह लौटना सार्थक है।

— इयान

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

— itsbruce

खाली इनपुट से आपके किसी भी उदाहरण का कोई लेना देना नहीं है। वे उन स्थितियों के केवल विशेष मामले हैं जहां उत्तर "कुछ भी नहीं" हो सकता है। जो बदले में ओपी के सवाल का जवाब देना चाहिए कि खाली संग्रह को "कैसे" संभालना है।

— djechlin

Answer 3

हमेशा की तरह, यह निर्भर करता है।

क्या फर्क पड़ता है कि संग्रह खाली है?
अधिकांश संग्रह-हैंडलिंग कोड शायद "नहीं" कहेंगे; संग्रह में शून्य सहित कोई भी आइटम हो सकता है।

अब, यदि आपके पास किसी प्रकार का संग्रह है, जहां "अमान्य" है, तो इसमें कोई आइटम नहीं है, तो यह एक नई आवश्यकता है और आपको यह तय करना होगा कि इसके बारे में क्या करना है।

डेटाबेस दुनिया से कुछ परीक्षण तर्क उधार लें: शून्य आइटम, एक आइटम और दो आइटम के लिए परीक्षण करें । यह सबसे महत्वपूर्ण मामलों को पूरा करता है (किसी भी बुरी तरह से गठित आंतरिक या कार्टेशियन स्थितियों में शामिल होना)।

Comments

और अगर किसी संग्रह में कोई आइटम नहीं रखना अमान्य है, तो आदर्श रूप से तर्क एक नहीं होगा java.util.Collection, लेकिन एक कस्टम com.foo.util.NonEmptyCollectionवर्ग, जो लगातार इस आक्रमण को संरक्षित कर सकता है, और आपको शुरू करने के लिए अमान्य स्थिति में आने से रोकता है।

— आंद्रेज डोयले

इस प्रश्न को टैग किया गया है [c #]

— Nick Udell

@NickUdell C # ऑब्जेक्ट ओरिएंटेड प्रोग्रामिंग या नेस्टेड नेमस्पेस की अवधारणा का समर्थन नहीं करता है? टीआईएल।

— जॉन ड्वोरक

ऐसा होता है। मेरी टिप्पणी एक स्पष्टीकरण थी क्योंकि एन्द्रेज को भ्रम हुआ होगा (किसी अन्य भाषा के नाम निर्दिष्ट करने के प्रयास के लिए वे इस प्रश्न का संदर्भ क्यों नहीं देते?)।

— निक उदेल

-1 पर जोर देने के लिए "यह निर्भर करता है" "लगभग निश्चित रूप से हाँ" से अधिक। कोई मजाक नहीं - गलत चीज़ का संचार करने से यहाँ नुकसान होता है।

— djechlin

Answer 4

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

इस मामले में, यह उम्मीद की जानी चाहिए कि एक खाली संग्रह प्रस्तुत किया जाएगा, और आपके कोड को इसे संभालने की आवश्यकता है (जो यह पहले से ही करता है)। यह उन सभी का उल्लंघन होगा जो आपके कोड ने यहां अपवाद फेंक दिया तो अच्छा है। यह गणित में 0 को 0 से गुणा करने के समान होगा। यह बेमानी है, लेकिन इसके लिए यह आवश्यक है कि यह जिस तरह से काम करता है।

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

Comments

आपका बोल्ड बयान पूरी व्यापकता में बेहद खराब सलाह है। मुझे लगता है कि यह यहाँ सच है, लेकिन आपको यह समझाने की ज़रूरत है कि इस परिस्थिति में क्या खास है। (यह सामान्य रूप से बुरी सलाह है क्योंकि यह मौन विफलताओं को बढ़ावा देता है।)

— डीजेक्विलिन

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

— TheMayer

लेकिन यह आपका पहला वाक्य है और केवल एक ही हाइलाइट किया गया है ... कोई भी यह नहीं समझता है कि आप अभी तक क्या कह रहे हैं। (मैं यहां बहुत आक्रामक होने की कोशिश नहीं कर रहा हूं, बस एक चीज जो हम यहां कर रहे हैं वह लिखना और संवाद करना सीखता है और मैं बात करता हूं कि एक महत्वपूर्ण बिंदु में परिशुद्धता का नुकसान हानिकारक है।)

— djechlin

Answer 5

सही समाधान यह देखने के लिए बहुत कठिन है कि आप अलगाव में अपने कार्य को कब देख रहे हैं। एक बड़ी समस्या के एक भाग के रूप में अपने कार्य पर विचार करें । उस उदाहरण का एक संभावित समाधान इस तरह दिखता है (स्काला में):

input.split("\\D")
.filterNot (_.isEmpty)
.map (_.toInt)
.filter (x => x >= 1000 && x <= 9999)

सबसे पहले, आप स्ट्रिंग को गैर-अंकों से विभाजित करते हैं, खाली तारों को फ़िल्टर करते हैं, स्ट्रिंग को पूर्णांक में बदलते हैं, फिर केवल चार अंकों की संख्या रखने के लिए फ़िल्टर करते हैं। आपका कार्य map (_.toInt)पाइपलाइन में हो सकता है ।

यह कोड काफी सीधा है क्योंकि पाइपलाइन में प्रत्येक चरण एक खाली स्ट्रिंग या एक खाली संग्रह को संभालता है। यदि आप प्रारंभ में एक खाली स्ट्रिंग रखते हैं, तो आपको अंत में एक खाली सूची मिलती है। आपको nullहर कॉल के बाद रोकना या जांचना नहीं है ।

बेशक, यह माना जाता है कि एक खाली आउटपुट सूची में एक से अधिक अर्थ नहीं हैं। यदि आपको खाली इनपुट के कारण होने वाले एक खाली आउटपुट और स्वयं के ट्रांसफ़ॉर्मेशन के कारण अंतर करने की आवश्यकता है, तो यह पूरी तरह से चीजों को बदल देता है।

Comments

अत्यंत प्रभावी उदाहरण के लिए +1 (अन्य अच्छे उत्तरों में कमी)।

— djechlin

Answer 6

यह सवाल वास्तव में अपवादों के बारे में है। यदि आप इसे इस तरह से देखते हैं और कार्यान्वयन विवरण के रूप में खाली संग्रह को अनदेखा करते हैं, तो इसका उत्तर सीधा है:

1) एक विधि को एक अपवाद को फेंक देना चाहिए जब यह आगे नहीं बढ़ सकता है: या तो निर्दिष्ट कार्य करने में असमर्थ है, या उचित मूल्य वापस कर सकता है।

2) एक विधि को एक अपवाद को पकड़ना चाहिए जब यह विफलता के बावजूद आगे बढ़ने में सक्षम हो।

तो, आपकी सहायक विधि "सहायक" नहीं होनी चाहिए और जब तक यह खाली संग्रह के साथ काम करने में असमर्थ नहीं हो , तब तक एक अपवाद न फेंकें । कॉलर को यह निर्धारित करने दें कि क्या परिणाम संभाला जा सकता है।

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

Answer 7

विधि का नाम है TransformNodes। इनपुट के रूप में एक खाली संग्रह के मामले में, एक खाली संग्रह प्राप्त करना स्वाभाविक और सहज है, और प्रीफेक्ट गणितीय अर्थ बनाता है।

यदि विधि को नामित Maxकिया गया था और अधिकतम तत्व वापस करने के लिए डिज़ाइन किया गया था , तो NoSuchElementExceptionएक खाली संग्रह पर फेंकना स्वाभाविक होगा , क्योंकि अधिकतम कुछ भी गणितीय अर्थ नहीं बनाता है।

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

Comments

Maxकुछ भी नहीं अक्सर नकारात्मक अनंत है।

— djechlin

Answer 8

आइए पीछे हटें और एक अलग उदाहरण का उपयोग करें जो मानों की एक सरणी के अंकगणितीय माध्य की गणना करता है।

यदि इनपुट ऐरे खाली है (या अशक्त), तो क्या आप कॉलर के अनुरोध को यथोचित रूप से पूरा कर सकते हैं? नहीं, आपके पास क्या विकल्प हैं? खैर, आप कर सकते हैं:

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

मैं कहता हूं कि उन्हें त्रुटि दें यदि उन्होंने आपको अमान्य इनपुट दिया है और अनुरोध पूरा नहीं किया जा सकता है। मेरा मतलब है कि पहले दिन से एक कठिन त्रुटि है, ताकि वे आपके कार्यक्रम की आवश्यकताओं को समझें। आखिरकार, आपका कार्य प्रतिक्रिया देने की स्थिति में नहीं है। यदि ऑपरेशन विफल हो सकता है (उदाहरण के लिए फ़ाइल कॉपी करें), तो आपके एपीआई को उन्हें एक त्रुटि देनी चाहिए जिससे वे निपट सकते हैं।

तो यह परिभाषित कर सकता है कि आपका पुस्तकालय विकृत अनुरोधों और अनुरोधों को कैसे संभालता है जो विफल हो सकते हैं।

यह आपके कोड के अनुरूप होना बहुत महत्वपूर्ण है कि यह त्रुटियों के इन वर्गों को कैसे संभालता है।

अगली श्रेणी यह ​​तय करना है कि आपकी लाइब्रेरी कैसे बकवास अनुरोधों को संभालती है। आपके जैसे एक उदाहरण पर वापस जाना - चलो एक फ़ंक्शन का उपयोग करता है जो यह निर्धारित करता है कि क्या फ़ाइल किसी पथ पर मौजूद है bool FileExistsAtPath(String):। यदि क्लाइंट खाली स्ट्रिंग पास करता है, तो आप इस परिदृश्य को कैसे संभालेंगे? कैसे एक खाली या अशक्त सरणी के बारे में पारित किया void SaveDocuments(Array<Document>)? अपने पुस्तकालय / कोडबेस के लिए निर्णय लें, और सुसंगत रहें। मैं इन मामलों की त्रुटियों पर विचार करने के लिए होता हूं, और ग्राहकों को त्रुटियों के रूप में (एक जोर के माध्यम से) झंडी दिखाकर बकवास अनुरोध करने से मना करता हूं। कुछ लोग उस विचार / कार्रवाई का दृढ़ता से विरोध करेंगे। मुझे यह त्रुटि पता लगाने में बहुत मददगार लगी। कार्यक्रमों में मुद्दों का पता लगाने के लिए यह बहुत अच्छा है - आक्रामक कार्यक्रम के लिए अच्छे इलाके के साथ। कार्यक्रम बहुत स्पष्ट और सही हैं (अपने कोडबेस के विकास पर विचार करें), और उन कार्यों के भीतर चक्र न जलाएं जो कुछ भी नहीं करते हैं। कोड का छोटा / क्लीनर इस तरह से होता है, और चेक को आमतौर पर उन स्थानों पर धकेल दिया जाता है जहां समस्या पेश की जा सकती है।

Comments

आपके अंतिम उदाहरण के लिए, यह निर्धारित करना कार्य नहीं है कि क्या बकवास है। इसलिए, एक खाली स्ट्रिंग को गलत लौटना चाहिए। वास्तव में, यह सटीक दृष्टिकोण File.Exists लेता है।

— theMayer

@ rmayer06 यह इसका काम है। संदर्भित फ़ंक्शन अनुमति देता है अशक्त, खाली स्ट्रिंग, स्ट्रिंग में अमान्य वर्णों के लिए जाँच, स्ट्रिंग ट्रंकेशन करता है, फ़ाइल सिस्टम कॉल करने की आवश्यकता हो सकती है, पर्यावरण को क्वेरी करने की आवश्यकता हो सकती है, आदि जो अक्सर-निरर्थक-इन-निष्पादन या "उपयुक्तता" है उच्च लागत, और वे निश्चित रूप से शुद्धता की रेखाओं (IMO) को धुंधला करते हैं। मैंने बहुत सारे if (!FileExists(path)) { ...create it!!!... }कीड़े देखे हैं - जिनमें से कई को प्रतिबद्ध होने से पहले पकड़ा जाएगा, क्या शुद्धता की रेखाएं धुंधली नहीं थीं।

— जस्टिन

अगर फ़ंक्शन का नाम File.ThrowExceptionIfPathIsInvalid था, तो मैं आपसे सहमत हूं, लेकिन उनके सही दिमाग में कौन इस तरह के फ़ंक्शन को कॉल करेगा?

— theMayer

औसत 0 आइटम पहले से ही NaN को वापस करने जा रहा है या फंक्शन को परिभाषित करने के तरीके से विभाजित-शून्य-शून्य अपवाद को फेंक रहा है। एक नाम के साथ एक फ़ाइल जो संभवतः मौजूद नहीं हो सकती है, या तो मौजूद नहीं होगी या पहले से ही एक त्रुटि को ट्रिगर करेगी। इन मामलों को विशेष रूप से संभालने के लिए कोई सम्मोहक कारण नहीं है।

— cHao

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

— cHao

Answer 9

अंगूठे के एक नियम के रूप में, एक मानक फ़ंक्शन इनपुट की व्यापक सूची को स्वीकार करने और उस पर प्रतिक्रिया देने में सक्षम होना चाहिए, ऐसे कई उदाहरण हैं जहां प्रोग्रामर उन तरीकों का उपयोग करते हैं जो डिजाइनर ने योजना नहीं बनाई थी, इस बात को ध्यान में रखते हुए, मुझे विश्वास है कि फ़ंक्शन न केवल खाली संग्रह को स्वीकार करने में सक्षम होना चाहिए, बल्कि इनपुट प्रकारों की एक विस्तृत श्रृंखला और शान से वापसी प्रतिक्रिया भी हो सकती है, इनपुट पर जो भी ऑपरेशन किया गया था, उससे यह एक त्रुटि वस्तु भी है ...

Comments

डिजाइनर के लिए यह मानना ​​बिल्कुल गलत है कि एक संग्रह हमेशा पारित हो जाएगा और सीधे उक्त संग्रह पर पुनरावृत्ति करने के लिए जाएगा, यह सुनिश्चित करने के लिए एक चेक किया जाना चाहिए कि प्राप्त तर्क अपेक्षित डेटाटाइप के अनुरूप है ...

— क्लेमेंट मार्क-आबा

"इनपुट प्रकारों की विस्तृत श्रृंखला" यहाँ अप्रासंगिक लगती है। प्रश्न को # , एक जोरदार टाइप की गई भाषा में टैग किया गया है । यही है, संकलक गारंटी देता है कि इनपुट एक संग्रह है

— gnat

कृपालु गूगल "अंगूठे का नियम", मेरा जवाब एक सामान्य सावधानी थी कि एक प्रोग्रामर के रूप में आप अप्रत्याशित या गलत घटनाओं के लिए जगह बनाते हैं, इनमें से एक गलत तरीके से पारित किए गए फ़ंक्शन तर्क हो सकते हैं ...

— क्लेमेंट मार्क-एएबी

यह या तो गलत है या तनातनी। writePaycheckToEmployeeएक नकारात्मक संख्या को इनपुट के रूप में स्वीकार नहीं करना चाहिए ... लेकिन अगर "प्रतिक्रिया" का अर्थ "कुछ भी होता है जो आगे हो सकता है," तो हाँ हर फ़ंक्शन ऐसा कुछ करेगा जो वह आगे करता है।

— djechlin