डेवलपर जोर देता है कि अगर बयानों में नकारात्मक स्थिति नहीं होनी चाहिए, और हमेशा एक और ब्लॉक होना चाहिए


169

मेरा एक परिचित है, मुझसे ज्यादा अनुभवी डेवलपर है। हम प्रोग्रामिंग प्रथाओं के बारे में बात कर रहे थे और मुझे 'अगर' बयानों पर उनके दृष्टिकोण से घृणा थी। वह कुछ प्रथाओं पर जोर देता है, अगर उन बयानों के बारे में जो मुझे अजीब लगते हैं।

सबसे पहले , यदि एक कथन को दूसरे कथन का पालन किया जाना चाहिए, चाहे उसमें कुछ डाला जाए या नहीं। इस तरह कोड की ओर जाता है:

if(condition) 
{
    doStuff();
    return whatever;
}
else
{
}

दूसरे , झूठे के बजाय सच्चे मूल्यों के लिए परीक्षण करना बेहतर है। इसका मतलब है कि 'डोरऑप्ड' वेरिएबल के बजाय 'डोर क्लोज्ड' वेरिएबल का परीक्षण करना बेहतर है

उनका तर्क है कि यह स्पष्ट करता है कि कोड क्या कर रहा है।

जो मुझे काफी भ्रमित करता है, क्योंकि उन दो नियमों के संयोजन से उसे इस तरह का कोड लिखने के लिए प्रेरित किया जा सकता है यदि वह शर्त पूरी नहीं होने पर कुछ करना चाहता है।

if(condition)
{
}
else
{
    doStuff();
    return whatever;
}

इस बारे में मेरी भावना यह है कि यह वास्तव में बहुत बदसूरत और / या है कि गुणवत्ता में सुधार, अगर कोई है, तो नगण्य है। लेकिन एक जूनियर के रूप में, मुझे अपनी वृत्ति पर संदेह है।

तो मेरे सवाल हैं: क्या यह एक अच्छा / बुरा / "कोई फर्क नहीं पड़ता" अभ्यास है? क्या यह आम बात है?



57
क्या यह संभव है कि आपका सहकर्मी एक पृष्ठभूमि से आता है जहां जीवन और अंग दांव पर हो सकता है? मेरा मानना ​​है कि मैंने सिस्टम में इस तरह की चीज़ों के बारे में कुछ उल्लेख किया है जहाँ कोड और परीक्षण का स्वत: विश्लेषण कोड पर किया जाता है और जहाँ गलत हो जाना शाब्दिक रूप से किसी के जीवन का खर्च हो सकता है।
jpmc26

11
आपकी कंपनी कोड शैली मार्गदर्शिका क्या कहती है?
Thorbjørn रेवन एंडरसन

4
आपके "दूसरे" प्रश्न पर आंशिक प्रतिक्रिया। यदि क्रिया ब्लॉक में से एक लंबा है और दूसरा छोटा है, तो एक शर्त का परीक्षण करें, जो पहले छोटे ब्लॉक को रखता है, ताकि कोड को पढ़ते समय छूटने की संभावना कम हो। यह शर्त एक नकारात्मकता हो सकती है, या इसका नाम बदलकर इसे सच बनाने की परीक्षा हो सकती है।
एथन बोल्कर

9
Resharper को अपने दोस्त को बताने के लिए कुछ होगा, "आपका कोड अनावश्यक और बेकार है, क्या आप चाहते हैं कि मैं इसे हटा / वापस कर दूं?"
BgrWorker

जवाबों:


184

स्पष्ट elseब्लॉक

पहला नियम सिर्फ कोड को प्रदूषित करता है और इसे न तो अधिक पठनीय बनाता है, न ही कम त्रुटि वाला। आपके सहकर्मी का लक्ष्य - मुझे लगता है - स्पष्ट होना है, यह दिखाते हुए कि डेवलपर को पूरी तरह से पता था कि स्थिति का मूल्यांकन किया जा सकता है falseजबकि स्पष्ट होना एक अच्छी बात है, ऐसे खोजकर्ता को कोड की तीन अतिरिक्त लाइनों की कीमत पर नहीं आना चाहिए

मैंने इस तथ्य का भी उल्लेख नहीं किया है कि एक ifबयान का पालन जरूरी नहीं है कि या तो elseकुछ भी नहीं है: यह एक या एक से अधिक के बाद भी हो सकता elifहै।

returnबयान की उपस्थिति चीजों को बदतर बनाती है। यहां तक ​​कि अगर आपके पास वास्तव में elseब्लॉक के भीतर निष्पादित करने के लिए कोड था , तो इसे इस तरह से करना अधिक पठनीय होगा:

if (something)
{
    doStuff();
    return whatever;
}

doOtherThings();
return somethingElse;

इससे कोड दो लाइनें कम लेता है, और elseब्लॉक को एक करता है। गार्ड क्लॉस सब के बारे में हैं।

सूचना, हालांकि, कि आपके सहयोगी की तकनीक आंशिक रूप से बिना किसी स्थान के ढेर वाले सशर्त ब्लॉकों के बहुत खराब पैटर्न को हल कर सकती है:

if (something)
{
}
if (other)
{
}
else
{
}

पिछले कोड में, पहले ifब्लॉक के बाद एक सेंस लाइन ब्रेक की कमी से कोड की गलत व्याख्या करना बहुत आसान हो जाता है। हालाँकि, आपके सहयोगी के नियम से कोड को गलत तरीके से फैलाना अधिक कठिन हो जाता है, लेकिन एक आसान समाधान यह होगा कि आप केवल एक नई पंक्ति जोड़ें।

के लिए टेस्ट true, के लिए नहींfalse

दूसरा नियम कुछ समझ में आ सकता है, लेकिन अपने मौजूदा स्वरूप में नहीं।

यह गलत नहीं है कि एक बंद दरवाजे के लिए परीक्षण गैर-खुले दरवाजे के लिए परीक्षण की तुलना में अधिक सहज है । नकारात्मकता और विशेष रूप से नेस्टेड नकारात्मक, आमतौर पर समझने में मुश्किल होती है:

if (!this.IsMaster || (!this.Ready && !this.CanWrite))

इसे हल करने के लिए, खाली ब्लॉकों को जोड़ने के बजाय , प्रासंगिक या स्थानीय चर बनाते समय अतिरिक्त गुण बनाएं

उपरोक्त शर्त को आसानी से पढ़ने योग्य बनाया जा सकता है:

if (this.IsSlave || (this.Synchronizing && this.ReadOnly))

169
खाली ब्लॉक हमेशा मुझे गलतियां लगते हैं। यह तुरंत मेरा ध्यान आकर्षित करेगा और मैं पूछूँगा 'यह यहाँ क्यों है?'
नेल्सन

50
@ नील की स्थिति की उपेक्षा करने के लिए किसी अतिरिक्त सीपीयू समय की आवश्यकता नहीं है। सी 86 को संकलित बस कूद अनुदेश से स्वैप कर सकता है JZके लिए (यदि शून्य कूद) if (foo)को JNZ(कूद अगर नहीं शून्य) के लिए if (!foo)
8bittree

71
" स्पष्ट नामों के साथ अतिरिक्त गुण बनाएँ ": जब तक आपके पास डोमेन का गहन विश्लेषण नहीं होता है, यह एक स्थानीय समस्या (एक विशिष्ट व्यापार नियम के आवेदन) को हल करने के लिए वैश्विक गुंजाइश (मूल वर्ग) को बदल सकता है। एक चीज जो यहां की जा सकती है, वह वांछित राज्य के साथ स्थानीय बूलियन बनाने के लिए है, जैसे कि "var isSlave =! !.IsMaster" और कई अन्य गुणों को बनाने के बजाय स्थानीय बूलियंस के साथ अपना आवेदन करें। इसलिए, नमक के एक दाने के साथ सलाह लें और नए गुण बनाने से पहले डोमेन का विश्लेषण करने के लिए कुछ समय लें।
माचाडो

82
यह "कोड की तीन पंक्तियों" के बारे में नहीं है, यह उपयुक्त दर्शकों (किसी को कम से कम प्रोग्रामिंग की एक मूल समझ) के लिए लिखने के बारे में है। एक ifहै पहले से ही इस तथ्य के बारे में स्पष्ट है कि हालत झूठी हो सकता है, या आप इसे के लिए परीक्षण नहीं किया जाएगा। एक खाली ब्लॉक चीजों को कम स्पष्ट करता है, अधिक नहीं, क्योंकि कोई भी पाठक इसकी उम्मीद नहीं करता है, और अब उन्हें रोकना होगा और सोचना होगा कि यह कैसे हो सकता है।
जुबान

15
@Mark if (!commonCase) { handle the uncommon case },हालांकि कम स्पष्ट है, हालांकि टिप्पणी के साथ, हालांकि।
पॉल

62

पहले नियम के बारे में, यह बेकार टाइपिंग का एक उदाहरण है। न केवल इसे टाइप करने में अधिक समय लगता है, इससे कोड पढ़ने वाले किसी भी व्यक्ति को बड़ी मात्रा में भ्रम होगा। यदि कोड की आवश्यकता नहीं है, तो इसे न लिखें। यह elseआपके मामले में आबादी नहीं होने का भी विस्तार करेगा क्योंकि कोड ifब्लॉक से लौटता है :

if(condition) 
{
    doStuff();
    return whatever;
}

doSomethingElse(); // no else needed
return somethingelse;

दूसरे बिंदु के बारे में, यह बूलियन नाम से बचने के लिए अच्छा है जिसमें एक नकारात्मक होता है:

bool doorNotOpen = false; // a double negative is hard to reason
bool doorClosed = false; // this is much clearer

हालाँकि, इसे फिर से एक नकारात्मक के लिए परीक्षण नहीं करने के लिए विस्तारित करना, जैसा कि आप बताते हैं, अधिक बेकार टाइपिंग की ओर जाता है। खाली ifब्लॉक होने की तुलना में निम्नलिखित स्पष्ट है :

if(!condition)
{
    doStuff();
    return whatever;
}

120
तो ... आप कह सकते हैं कि डबल नकारात्मक एक नहीं है? ;)
पाटसन

6
@Patsuan, बहुत चालाक। मुझे वह पसंद है। :)
डेविड अरनो

4
मुझे लगता है कि बहुत से लोग इस बात से सहमत नहीं होंगे कि अगर रिटर्न के साथ और कुछ कैसे संभाला जाए, और कुछ तो यह भी कह सकते हैं कि इसे हर परिदृश्य में एक ही नहीं होना चाहिए। मेरे पास स्वयं एक मजबूत प्राथमिकता नहीं है, लेकिन मैं निश्चित रूप से इसे करने के कई अन्य तरीकों के पीछे तर्क देख सकता हूं।
जुगल

6
जाहिर है, if (!doorNotOpen)भयानक है। इसलिए नाम जितना संभव हो उतना सकारात्मक होना चाहिए। if (! doorClosed)पूरी तरह से ठीक है।
डेविड श्वार्ट्ज

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

45

1. खाली elseबयानों के पक्ष में एक तर्क ।

मैं अक्सर उपयोग करते हैं (और इसके लिए तर्क देते हैं) उस पहले निर्माण के लिए कुछ खाली है, एक और खाली। यह कोड के पाठकों (दोनों मानव और स्वचालित विश्लेषण उपकरण) को संकेत देता है कि प्रोग्रामर ने स्थिति में कुछ सोचा है। लापता elseबयान जो मौजूद होना चाहिए था, लोगों की मौत हो गई, दुर्घटनाग्रस्त वाहन, और लाखों डॉलर खर्च हुए। मिसरा-सी, उदाहरण के लिए, कम से कम एक टिप्पणी को यह कहते हुए अनिवार्य करता है कि लापता अंतिम if (condition_1) {do_this;} else if (condition_2) {do_that;} ... else if (condition_n) {do_something_else;}क्रम एक अनुक्रम में जानबूझकर है । अन्य उच्च विश्वसनीयता मानक आगे भी चलते हैं: कुछ अपवादों के साथ, अन्य विवरणों को याद करना मना है।

एक अपवाद एक सरल टिप्पणी है, की तर्ज पर कुछ /* Else not required */। यह उसी इरादे का संकेत देता है जैसे तीन रेखा खाली होती है। एक और अपवाद जहां खाली जगह की आवश्यकता नहीं है, वह यह है कि यह कोड के पाठकों और स्वचालित रूप से विश्लेषण उपकरणों के लिए स्पष्ट रूप से स्पष्ट है जो कि खाली और अधिक शानदार है। उदाहरण के लिए, if (condition) { do_stuff; return; }इसी तरह, के बदले में throw somethingया goto some_label1 के मामले में एक खाली अन्य की आवश्यकता नहीं है return

2. if (condition)अधिक पसंद करने के लिए एक तर्क if (!condition)

यह एक मानवीय कारक वस्तु है। कॉम्प्लेक्स बुलियन लॉजिक कई लोगों को परेशान करता है। एक अनुभवी प्रोग्रामर के बारे में भी सोचना होगा if (!(complex || (boolean && condition))) do_that; else do_this;। कम से कम, इस के रूप में फिर से लिखना if (complex || (boolean && condition)) do_this; else do_that;

3. इसका मतलब यह नहीं है कि किसी को खाली thenबयान पसंद करना चाहिए ।

दूसरा खंड कहता है कि "तू पसंद है" के बजाय "पसंद" करता है। यह एक नियम के बजाय एक दिशानिर्देश है। सकारात्मक दिशानिर्देशों को पसंद करने के लिए उस दिशानिर्देश का कारण यह ifहै कि कोड स्पष्ट और स्पष्ट होना चाहिए। एक खाली तब खंड (उदा if (condition) ; else do_something;) , इसका उल्लंघन करता है। यह प्रोग्रामिंग को बाधित करता है, जिससे प्रोग्रामर का सबसे अधिक अनुभवी होने के बावजूद बैक अप लेने और फिर से ifइसके नकारात्मक रूप में स्थिति को पढ़ने के लिए । इसलिए इसे पहले से नकारात्मक रूप में लिखें और दूसरे कथन को छोड़ दें (या ऐसा करने के लिए अनिवार्य है या उस प्रभाव के लिए टिप्पणी करें)।



1 मैंने लिखा है कि तब उस खंड का अंत हो जाता है return, throwया उसे gotoकिसी और की आवश्यकता नहीं होती है। यह स्पष्ट है कि अन्य खंड की आवश्यकता नहीं है। लेकिन इससे क्या goto? एक तरफ के रूप में, सुरक्षा-महत्वपूर्ण प्रोग्रामिंग नियम कभी-कभी जल्दी वापसी को अस्वीकार कर देते हैं, और लगभग हमेशा अपवादों को फेंकने से इनकार करते हैं। वे हालांकि gotoएक प्रतिबंधित रूप (जैसे, goto cleanup1;) में अनुमति देते हैं । यह प्रतिबंधित उपयोग gotoकुछ स्थानों पर पसंदीदा अभ्यास है। उदाहरण के लिए, लिनक्स कर्नेल इस तरह के gotoबयानों का हिस्सा है।


6
!यह भी आसानी से अनदेखा है। यह बहुत ट्रिब्यूट है।
Thorbjørn रावन एंडरसन

4
नहीं, एक खाली और यह स्पष्ट नहीं करता है कि प्रोग्रामर ने इसमें कुछ सोचा है। यह अधिक भ्रम की ओर जाता है "क्या कुछ बयानों की योजना बनाई गई थी और वे भूल गए थे या एक खाली खंड क्यों है?" एक टिप्पणी बहुत स्पष्ट है।
साइमन

9
@ साइमन: एक विशिष्ट रूप है else { /* Intentionally empty */ }, या उन पंक्तियों के साथ कुछ। खाली और स्थिर विश्लेषक को संतुष्ट करता है जो नियमों के उल्लंघन के लिए नासमझ दिखता है। टिप्पणी पाठकों को सूचित करती है कि खाली अन्य जानबूझकर है। फिर, अनुभवी प्रोग्रामर आमतौर पर टिप्पणी को अनावश्यक के रूप में छोड़ देते हैं - लेकिन खाली नहीं। उच्च विश्वसनीयता प्रोग्रामिंग स्वयं का एक डोमेन है। निर्माण बाहरी लोगों के बजाय अजीब लगते हैं। इन निर्माणों का उपयोग हार्ड नॉक, नॉक के स्कूल से सबक लेने के कारण किया जाता है जो जीवन और मृत्यु या $$$$$$$$ के बहुत कठिन होते हैं।
डेविड हैमेन

2
मुझे समझ में नहीं आता है कि तब खाली होना क्‍लॉज एक बुरी चीज है जब खाली क्‍लॉज नहीं होते हैं (यह मानते हुए कि हम उस स्‍टाइल को चुनते हैं)। मैं देख सकता हूंif (target == source) then /* we need to do nothing */ else updateTarget(source)
बर्गी

2
@ ThorbjørnRavnAndersen nope, notC ++ में एक कीवर्ड है, जैसा कि अन्य बिटवाइज़ और लॉजिकल ऑपरेटर हैं। वैकल्पिक ऑपरेटर प्रतिनिधित्व देखें ।
रुस्लान

31

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

if (condition) {
    // No action needed because ...
} else {
    do_else_action()
}

if (condition) {
    do_if_action()
} else {
    // No action needed because ...
}

लेकिन नहीं:

if (condition) {
    do_if_action()
} else {
    // I was told that an if always should have an else ...
}

5
इस। मुझे कथन if test succeeds -> no action needed -> else -> action neededका शब्दार्थ बहुत भिन्न प्रतीत होता है if it applies that the opposite of a test outcome is true then an action is needed। मुझे मार्टिन फाउलर का उद्धरण याद आ रहा है: "कोई भी कोड कंप्यूटर को समझ सकता है, अच्छे प्रोग्रामर लिख सकते हैं जो कोड मनुष्य समझ सकते हैं"।
तसोस पापेनिलियनौ

2
@TasosPapastylianou यह धोखा है। 'यदि परीक्षण सफल होता है -> कोई क्रिया की आवश्यकता नहीं है' का विपरीत है 'यदि परीक्षण सफल नहीं होता है -> कार्रवाई की आवश्यकता है'। आपने इसे लगभग 10 शब्दों के साथ गद्देदार किया।
जेरी बी

@JerryB यह "परीक्षण" पर निर्भर करता है। कभी-कभी नकारात्मकता (भाषाई रूप से) सीधी होती है, लेकिन कभी-कभी ऐसा नहीं होता है और इससे भ्रम पैदा होगा। उन मामलों में, "परिणाम के सत्य होने के विपरीत" नकारात्मक / विपरीत के बारे में बात करना स्पष्ट है "परिणाम सच नहीं हो रहा है"; हालाँकि बात यह है कि यह 'खाली' चरण की शुरुआत करने के लिए भी स्पष्ट होगा, या चर नामों के अर्थ को उल्टा कर देगा। यह "डे मॉर्गन" स्थितियों में विशिष्ट है: उदाहरण के if ((missing || corrupt) && !backup) -> skip -> else do stuffलिए दूर है (+ अलग-अलग निहित इरादे)if ((!missing && !corrupt) || backup) -> do stuff
टासोस पापस्टीलियनौ

1
@TasosPapastylianou आप लिख सकते हैं if(!((missing || corrupt) && !backup)) -> do stuffया बेहतर if((aviable && valid) || backup) -> do stuff। (लेकिन एक वास्तविक उदाहरण में आपको यह जांचना होगा कि क्या बैकअप उपयोग करने से पहले वैध है)
12431234123412341234123

2
@ टैसोसपापस्टीलियनौ जहां मैंने क्या कहा वहां दोहरा नकारात्मकता है? ज़रूर, यदि आप एक चर नाम के रूप में अनियंत्रित का उपयोग कर रहे थे, तो आपके पास एक स्पष्ट बिंदु होगा। हालांकि जब आप इस तरह के मिश्रित बूलियन ऑपरेटरों के लिए आते हैं, तो इसमें उपयोग करने के लिए अस्थायी चर रखना बेहतर हो सकता है if: file_ok = !missing && !corrupt; if(file_ok || backup) do_stuff();जो मुझे व्यक्तिगत रूप से लगता है कि यह और भी स्पष्ट करता है।
बाल्ड्रिक

23

बाकी सभी समान हैं, संक्षिप्तता पसंद करते हैं।

आप क्या नहीं लिखते हैं, किसी को भी पढ़ना और समझना नहीं है।

जबकि स्पष्ट होना उपयोगी हो सकता है, यह केवल मामला है अगर यह अनुचित निष्पक्षता के बिना स्पष्ट करता है कि आपने जो लिखा है वह वास्तव में वही है जो आप लिखना चाहते थे।


इसलिए, खाली शाखाओं से बचें, वे न केवल बेकार हैं, बल्कि असामान्य भी हैं और इस तरह भ्रम पैदा करते हैं।

इसके अलावा, यदि आप सीधे शाखा से बाहर निकलते हैं तो एक और शाखा लिखने से बचें।

जब भी आप स्विच-केस के माध्यम से गिरते हैं // FALLTHRU, और एक टिप्पणी या एक खाली ब्लॉक का उपयोग करते हुए जहां आपको एक खाली कथन की आवश्यकता होती है, वहां एक उपयोगी आवेदन की खोजबीन की जाएगी for(a;b;c) /**/;


7
// FALLTHRUयूजी, SCREAMING CAPS में या txtspk abbrevs के साथ नहीं। अन्यथा, मैं इस अभ्यास से सहमत हूं और इसका पालन करता हूं।
कॉडी ग्रे

7
@CodyGray - यह एक ऐसा स्थान है जहाँ SHOUTING एक अच्छा विचार है। अधिकांश स्विच स्टेटमेंट प्रत्येक केस को समाप्त करते हैं break। विफलता है कि breakकुछ शानदार सॉफ्टवेयर विफलताओं के लिए नेतृत्व किया है। एक टिप्पणी जो कोड के पाठकों को चिल्लाती है कि पतन के माध्यम से जानबूझकर एक अच्छी बात है। स्थैतिक विश्लेषण उपकरण इस विशिष्ट पैटर्न की तलाश कर सकते हैं और स्थिति के माध्यम से गिरावट के बारे में शिकायत नहीं करते हैं यह इसे और भी बेहतर बनाता है।
डेविड हैमेन

1
@Wossname: मैंने अभी-अभी अपना चेक किया है vim, और यह किसी भी प्रकार की भिन्नता को नहीं पहचानता है FALLTHRU। और मुझे लगता है, अच्छे कारण के लिए: TODOऔर FIXMEटिप्पणियां ऐसी टिप्पणियाँ हैं जिन्हें संक्षिप्त करने की आवश्यकता है क्योंकि आप git grepअपने कोड में आपके कौन से ज्ञात दोषों को पूछने में सक्षम होना चाहते हैं , और वे कहाँ स्थित हैं। एक गिरावट एक दोष नहीं है, और इसके लिए कोई कारण नहीं है, ऐसा क्या है।
अप्रैल को cmaster

4
@ दाविद हमेनमेन नहीं, चिल्लाना एक अच्छा विचार नहीं है: यदि आपके पास एक अपेक्षित ब्रेक के स्थान पर एक / / निर्णायक है, तो किसी भी डेवलपर को तुरंत समझने के लिए पर्याप्त होना चाहिए। इसके अलावा, // नतीजा एक दोष के बारे में बात नहीं करता है, यह बस संकेत देता है कि परिस्थितियों पर विचार किया गया है, और यह कि ब्रेक; जो गायब प्रतीत होता है, वास्तव में वहाँ नहीं होने का इरादा है। यह एक विशुद्ध रूप से सूचनात्मक उद्देश्य है, और इसके बारे में चिल्लाने के लिए कुछ भी नहीं है।
सेमीस्टर

1
@cmaster - यह चिल्लाना एक अच्छा विचार नहीं है आपकी राय है। अन्य लोगों की राय अलग है। और सिर्फ इसलिए कि आपके विम का कॉन्फ़िगरेशन पहचान FALLTHRUनहीं करता है इसका मतलब यह नहीं है कि अन्य लोगों ने ऐसा करने के लिए विम को कॉन्फ़िगर नहीं किया है।
डेविड हैमेन

6

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

हालांकि, मैं वास्तव में आपके उदाहरणों के बारे में पसंद नहीं करता, रिक्त ELSE द्वारा लिया गया पूरी तरह अनावश्यक ऊर्ध्वाधर स्थान है। ऐसा करने के लिए कोई कारण नहीं है। यह तर्क में कुछ भी नहीं जोड़ता है, यह दस्तावेज़ को मदद नहीं करता है कि कोड क्या कर रहा है, और यह पठनीयता को बिल्कुल भी नहीं बढ़ाता है। वास्तव में, मेरा तर्क है कि जोड़ा गया ऊर्ध्वाधर स्थान संभवतः पठनीयता को कम कर सकता है।


2
यह अनावश्यक ऊर्ध्वाधर स्थान हमेशा ब्रेसिज़ का उपयोग करने के लिए और लापता होने के लिए, और इंडेंटेशन के लिए ऑलमैन शैली का उपयोग करने के लिए जनादेश का एक परिणाम है।
डेविड हैमेन

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

व्यक्तिगत शैली: मैं किस ब्रेस स्टाइल का उपयोग करता हूं (ऑलमैन, 1 टीबी, ...), मैं हमेशा ब्रेसिज़ का उपयोग करता हूं।
डेविड हैमेन

जटिल स्थितियां या जिन्हें आप समझते हैं, उन्हें समझना मुश्किल हो सकता है, लगभग हमेशा अपने स्वयं के तरीकों / कार्यों में फिर से विभाजित करके हल किया जा सकता है। ऐसा कुछ if(hasWriteAccess(user,file))जटिल हो सकता है, लेकिन एक नज़र में आप जानते हैं कि परिणाम क्या होना चाहिए। यहां तक ​​कि अगर यह सिर्फ एक दो स्थितियां हैं, उदाहरण if(user.hasPermission() && !file.isLocked())के लिए एक उपयुक्त नाम के साथ एक विधि कॉल बिंदु भर में हो जाता है, तो नकारात्मक एक समस्या से कम हो जाते हैं।
क्रिस श्नाइडर

माना। फिर, मैं जब भी संभव हो,
रिफैक्टिंग

5

स्पष्ट elseब्लॉक

मैं सभी बयानों को कवर करने वाले एक कंबल बयान के रूप में इससे सहमत नहीं हूं, ifलेकिन कई बार ऐसा होता है जब elseआदत से बाहर ब्लॉक जोड़ना अच्छी बात है।

एक ifबयान, मेरे दिमाग में, वास्तव में दो अलग-अलग कार्य शामिल हैं।

अगर हमें कुछ करना है, तो यहां करें।

इस तरह की सामग्री स्पष्ट रूप से एक भाग की जरूरत नहीं है else

    if (customer.hasCataracts()) {
        appointmentSuggestions.add(new CataractAppointment(customer));
    }
    if (customer.isDiabetic()) {
        customer.assignNurse(DiabeticNurses.pickBestFor(customer));
    }

और कुछ मामलों में जोड़ने पर जोर देकर elseगुमराह किया जा सकता है।

    if (k > n) {
        return BigInteger.ZERO;
    }
    if (k <= 0 || k == n) {
        return BigInteger.ONE;
    }

के रूप में ही नहीं है

    if (k > n) {
        return BigInteger.ZERO;
    } else {
        if (k <= 0 || k == n) {
            return BigInteger.ONE;
        }
    }

भले ही यह कार्यात्मक रूप से समान हो। ifएक खाली के साथ पहला लिखना elseआपको दूसरे परिणाम तक ले जा सकता है जो अनावश्यक रूप से बदसूरत है।

यदि हम एक विशिष्ट स्थिति की जाँच कर रहे हैं, तो elseउस घटना को कवर करने के लिए आपको याद दिलाने के लिए एक खाली जोड़ना अक्सर एक अच्छा विचार है

        // Count wins/losses.
        if (doors[firstChoice] == Prize.Car) {
            // We would have won without switching!
            winWhenNotSwitched += 1;
        } else {
            // We win if we switched to the car!
            if (doors[secondChoice] == Prize.Car) {
                // We picked right!
                winWhenSwitched += 1;
            } else {
                // Bad choice.
                lost += 1;
            }
        }

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


के लिए टेस्ट true, के लिए नहींfalse

फिर से यह सामान्य स्तर पर अच्छी सलाह है लेकिन कई मामलों में यह अनावश्यक रूप से जटिल और कम पठनीय होता है।

हालांकि कोड की तरह

    if(!customer.canBuyAlcohol()) {
        // ...
    }

पाठक को परेशान कर रहा है, लेकिन इसे बना रहा है

    if(customer.canBuyAlcohol()) {
        // Do nothing.
    } else {
        // ...
    }

कम से कम जितना बुरा है, उतना बुरा नहीं है।

मैंने कई साल पहले BCPL में कोडित किया था और उस भाषा में एक IFखंड और एक UNLESSखंड है, ताकि आप अधिक महत्वपूर्ण रूप से कोड कर सकें:

    unless(customer.canBuyAlcohol()) {
        // ...
    }

जो काफी बेहतर है, लेकिन अभी भी सही नहीं है।


मेरी व्यक्तिगत प्रक्रिया

आम तौर पर, जब मैं नया कोड लिख रहा होता हूं, तो अक्सर मुझे याद दिलाने के elseलिए एक ifस्टेटमेंट में एक खाली ब्लॉक जोड़ देता हूं कि मैंने अभी तक उस घटना को कवर नहीं किया है। यह मुझे DFSजाल से बचने में मदद करता है और यह सुनिश्चित करता है कि जब मैं कोड की समीक्षा करता हूं तो मुझे लगता है कि करना बाकी है। हालांकि, मैं आमतौर पर TODOट्रैक रखने के लिए एक टिप्पणी जोड़ता हूं ।

  if (returnVal == JFileChooser.APPROVE_OPTION) {
    handleFileChosen();
  } else {
    // TODO: Handle case where they pressed Cancel.
  }

मुझे लगता है कि आम तौर पर मैं elseअपने कोड में शायद ही कभी उपयोग करता हूं क्योंकि यह अक्सर कोड गंध का संकेत दे सकता है।


"खाली" ब्लॉकों की आपकी हैंडलिंग, स्टिंग को लागू करते समय मानक स्टबिंग कोड की तरह पढ़ती है ...
डेडुप्लिकेटर

unlessब्लॉक एक अच्छा सुझाव है, और शायद ही BCPL तक ही सीमित।
tchrist

@TobySpeight उफ़। यह किसी भी तरह मेरा ध्यान आकर्षित करता है कि मैंने जो कुछ लिखा ...था वह वास्तव में था return। (वास्तव में, के साथ k=-1, n=-2पहला रिटर्न लिया जाता है, लेकिन यह काफी हद तक
लूट है

आधुनिक पर्ल ifऔर है unless। क्या अधिक है, यह उन्हें एक बयान के बाद भी अनुमति देता है, इसलिए आप कह सकते हैं print "Hello world!" if $born;या print "Hello world!" unless $dead;दोनों बिल्कुल वही करेंगे जो आपको लगता है कि वे करते हैं।
बजे एक सीवी

1

पहले बिंदु के लिए, मैंने एक ऐसी भाषा का उपयोग किया है, जो IF स्टेटमेंट्स को इस तरह इस्तेमाल करने के लिए मजबूर करती है (ओपल में, मेनफ्रेम सिस्टम पर GUI फ्रंट एंड लगाने के लिए मेनफ्रेम स्क्रीन के पीछे की भाषा), और IF के लिए केवल एक लाइन के साथ और ईएलएसई। यह एक सुखद अनुभव नहीं था!

मैं उम्मीद करूंगा कि कोई भी कंपाइलर ऐसे अतिरिक्त ईएलएसई क्लॉज को ऑप्टिमाइज़ करेगा। लेकिन लाइव कोड के लिए यह कुछ भी नहीं जोड़ रहा है (विकास में यह आगे के कोड के लिए एक उपयोगी मार्कर हो सकता है)।

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

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

नकारात्मक तर्क कम पठनीय होते हैं, हालांकि इस तरह के एक सरल IF स्टेटमेंट पर ऐसा नहीं है।


2
मैं देख रहा हूँ, तो यह था कुछ बिंदु पर आम बात।
पाटसन

@Patsuan - हाँ, एक हद तक। हालाँकि यह तब था जब मेनफ्रेम असेम्बलर परफॉर्मेंस क्रिटिकल कोड के लिए एक गंभीर विकल्प था।
किकस्टार्ट

1
"बहुत पहले ... यह स्वीकार किया गया था कि नकारात्मक जाँच कम कुशल थी।" खैर, वे हैं जब तक संकलक का अनुकूलन नहीं if !A then B; else Cहोता है if A then C; else B। हालत की उपेक्षा कम्प्यूटिंग एक अतिरिक्त सीपीयू निर्देश है। (हालांकि आप कहते हैं, यह काफी कम कुशल होने की संभावना नहीं है ।)
डेविड रिचरबी

@DavidRicherby और अगर हम सामान्य रूप से बात कर रहे हैं, तो कुछ भाषाएँ ऐसी अनुकूलन को वास्तव में कठिन बना सकती हैं। उदाहरण के लिए, ओवरलोड !और ==ऑपरेटरों के साथ C ++ लें । ऐसा नहीं है कि किसी को वास्तव में ऐसा करना चाहिए , आपको बुरा लगता है ...
एक CVn

1

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

नकारात्मक से बचने के बारे में मुद्दा कुछ और ध्यान देने योग्य है, हालांकि: आमतौर पर, जब भी आपको बूलियन मूल्य का उपयोग करने की आवश्यकता होती है, तो आपको इसे सेट करने के लिए कोड के कुछ ब्लॉकों को संचालित करने की आवश्यकता होती है, और कुछ अन्य ब्लॉकों को संचालित करने के लिए जब यह सेट नहीं होता है। जैसे, यदि आप नो-निगेटिव नियम लागू करते हैं, तो आप या तो if() {} else {...}स्टेटमेंट्स (खाली ifब्लॉक के साथ!) लागू करते हैं, या आप प्रत्येक बूलियन के लिए एक दूसरा बूलियन बनाते हैं जिसमें उसका नकारात्मक मूल्य होता है। दोनों विकल्प खराब हैं, क्योंकि वे आपके पाठकों को भ्रमित करते हैं।

एक सहायक नीति यह है: बूलियन के नाम के भीतर कभी भी एक नकारात्मक रूप का उपयोग न करें, और एकल के रूप में नकारात्मकता व्यक्त करें !। जैसा कथन if(!doorLocked)पूर्णतया स्पष्ट है, वैसा ही कथन जैसा कि if(!doorUnlocked)गाँठ दिमाग। बाद के प्रकार की अभिव्यक्ति वह चीज है जिसे आपको हर कीमत पर बचने की आवश्यकता है, न कि !किसी if()स्थिति में एक की उपस्थिति ।


0

मैं कहूंगा कि यह निश्चित रूप से बुरा अभ्यास है। अन्य कथनों को जोड़ने से आपके कोड में व्यर्थ लाइनों का एक पूरा गुच्छा जुड़ने वाला है जो कुछ भी नहीं करते हैं और इसे पढ़ना और भी कठिन बना देते हैं।


1
मैंने सुना है कि आपने कभी भी एक नियोक्ता के लिए काम नहीं किया है जो प्रति अवधि उत्पादित
एसएलओसी के

0

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

void foo()
{
    if (condition) return;

    doStuff();
    ...
}

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


0

एक बिंदु है जब "हमेशा एक और क्लॉज होता है" तर्क पर विचार करें जिसे मैंने किसी अन्य उत्तर में नहीं देखा है: यह एक कार्यात्मक प्रोग्रामिंग शैली में समझ में आ सकता है। की तरह।

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

var even = if (n % 2 == 0) {
  return "even";
} else {
  return "odd";
}

अब, सी शैली या सी शैली से प्रेरित भाषाओं में वाक्य रचना (जैसे जावा, सी # और जावास्क्रिप्ट, बस कुछ नाम रखने के लिए) यह अजीब लग रहा है। हालाँकि यह बहुत अधिक परिचित लगता है जब इस तरह लिखा जाता है:

var even = (n % 2 == 0) ? "even" : "odd";

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


0

... अगर एक बयान को दूसरे बयान के बाद किया जाना चाहिए, चाहे उसमें कुछ डाला जाए या नहीं।

मैं असहमत if (a) { } else { b(); }के रूप में फिर से लिखा जाना चाहिए if (!a) { b(); }और if (a) { b(); } else { }के रूप में फिर से लिखा जाना चाहिए if (a) { b(); }

हालांकि, यह इंगित करने योग्य है कि मेरे पास शायद ही कभी एक खाली शाखा है। ऐसा इसलिए है क्योंकि आम तौर पर मैं लॉग इन करता हूं कि मैं अन्यथा खाली शाखा में चला गया। इस तरह मैं लॉग संदेशों से पूरी तरह से विकसित हो सकता हूं। मैं शायद ही कभी डिबगर का उपयोग करता हूं। उत्पादन वातावरण में आपको डीबगर नहीं मिलता है; आपके द्वारा विकसित किए जाने वाले उपकरणों के साथ उत्पादन समस्याओं का निवारण करने में सक्षम होना अच्छा है।

दूसरे, झूठे के बजाय सच्चे मूल्यों के लिए परीक्षण करना बेहतर है। इसका मतलब है कि 'डोरऑप्ड' वेरिएबल के बजाय 'डोर क्लोज्ड' वेरिएबल का परीक्षण करना बेहतर है

मेरी इस बारे में मिश्रित भावनायें है। होने का एक नुकसान doorClosedऔर doorOpenedयह संभावित रूप से उन शब्दों / शब्दों की संख्या को दोगुना कर देता है जिनके बारे में आपको जानकारी होनी चाहिए। एक और नुकसान समय के साथ है doorClosedऔर doorOpenedबदल सकता है (आपके बाद आने वाले अन्य डेवलपर्स) और आप दो गुणों के साथ समाप्त हो सकते हैं जो अब एक दूसरे के सटीक नकारात्मक नहीं हैं। नकारात्मकताओं से बचने के बजाय, मैं व्यावसायिक उपयोगकर्ताओं की शब्दावली और मुझे दी गई आवश्यकताओं के लिए कोड की भाषा (वर्ग नाम, चर नाम, आदि) को महत्व देता हूं। मैं एक से बचने के लिए एक नया शब्द नहीं बनाना चाहता!यदि उस शब्द का केवल एक डेवलपर के लिए अर्थ है जो व्यवसाय उपयोगकर्ता समझ नहीं पाएंगे। मैं चाहता हूं कि डेवलपर्स उपयोगकर्ताओं और आवश्यकताओं को लिखने वाले लोगों के समान भाषा बोलें। अब यदि नई शर्तें मॉडल को सरल बनाती हैं, तो यह महत्वपूर्ण है, लेकिन आवश्यकताओं को अंतिम रूप देने से पहले इसे संभालना चाहिए, इसके बाद नहीं। कोडिंग शुरू करने से पहले विकास को इस समस्या को संभालना चाहिए।

मुझे अपनी वृत्ति पर संदेह है।

खुद से सवाल करते रहना अच्छा है।

क्या यह एक अच्छा / बुरा / "कोई फर्क नहीं पड़ता" अभ्यास है?

कुछ हद तक यह बहुत मायने नहीं रखता है। अपने कोड की समीक्षा करें और अपनी टीम के अनुकूल बनाएं। यह आमतौर पर सही बात है। यदि आपकी टीम में हर कोई एक निश्चित तरीके से कोड करना चाहता है, तो संभवत: यह उस तरह से करना सबसे अच्छा है (1 व्यक्ति को बदलना - अपने आप को - लोगों के समूह को बदलने की तुलना में कम कहानी बिंदुओं को लेता है)।

क्या यह आम बात है?

मैं कभी भी खाली शाखा देखकर याद नहीं कर सकता। मैं लोगों को नकारात्मकता से बचने के लिए गुणों को जोड़ते हुए देखता हूं, हालांकि।


0

मैं केवल प्रश्न के दूसरे भाग को संबोधित करने जा रहा हूं और यह औद्योगिक प्रणालियों में काम करने और वास्तविक दुनिया में उपकरणों में हेरफेर करने के मेरे दृष्टिकोण से आता है।

हालाँकि यह एक जवाब के बजाय एक विस्तारित टिप्पणी में है।

जब यह कहा गया है

दूसरे, झूठे के बजाय सच्चे मूल्यों के लिए परीक्षण करना बेहतर है। इसका मतलब है कि 'डोरऑप्ड' वेरिएबल के बजाय 'डोर क्लोज्ड' वेरिएबल का परीक्षण करना बेहतर है

उनका तर्क है कि यह स्पष्ट करता है कि कोड क्या कर रहा है।

मेरे दृष्टिकोण से यह धारणा यहाँ बनाई जा रही है कि दरवाजा राज्य एक द्विआधारी राज्य है जब वास्तव में यह कम से कम एक सहायक राज्य है:

  1. दरवाजा खुला है।
  2. दरवाजा न तो पूरी तरह से खुला है और न ही पूरी तरह से बंद है।
  3. दरवाज़ा बंद है।

इस प्रकार जहां एक एकल, बाइनरी डिजिटल सेंसर स्थित है, उसके आधार पर आप केवल दो अवधारणाओं में से एक को अधिभूत कर सकते हैं:

  1. यदि सेंसर दरवाजे के खुले किनारे पर है: दरवाजा या तो खुला है या खुला नहीं है
  2. यदि सेंसर दरवाजे के बंद पक्ष पर है: दरवाजा या तो बंद है या बंद नहीं है।

और आप इन अवधारणाओं को एक बाइनरी नकार के उपयोग के माध्यम से इंटरचेंज नहीं कर सकते हैं। इस प्रकार doorClosedऔर !doorOpenedसंभावित रूप से पर्यायवाची नहीं हैं और यह ढोंग करने का कोई भी प्रयास नहीं है कि वे समानार्थी हैं यह गलत सोच है जो वास्तव में मौजूद सिस्टम की तुलना में सिस्टम स्टेट के अधिक से अधिक ज्ञान को मानता है।

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


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

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

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

दूसरे का एक उदाहरण एक साधारण मोटर चालित एक्ट्यूएटर होगा। जब एक्ट्यूएटर पूरी तरह से बाहर हो जाता है तो आप मोटर को आगे बढ़ाने से रोकते हैं। और जब एक्ट्यूएटर पूरी तरह से हो तो आप रिवर्स में मोटर को चलाने से रोकते हैं।

मूल रूप से सेंसर की संख्या और प्रकार आवश्यक कार्यक्षमता को प्राप्त करने के लिए आवश्यक आवश्यकताओं के विश्लेषण के खिलाफ सेंसर की लागत विश्लेषण चलाने के लिए नीचे आता है।


"मेरे दृष्टिकोण से यह धारणा यहाँ बनाई जा रही है कि दरवाजा राज्य एक द्विआधारी राज्य है जब वास्तव में यह कम से कम एक त्रिगुटी अवस्था है:" और "आप दरवाजे के बंद होने या नहीं बंद होने के आधार पर ओवन के संचालन को सक्षम करते हैं। । आपको परवाह नहीं है कि दरवाजा कितना खुला है। " एक दूसरे के विपरीत। इसके अलावा, मुझे नहीं लगता कि यह सवाल दरवाजे और सेंसर के बारे में है।
संभल

@Sanchises कथन विरोधाभासी नहीं हैं क्योंकि आपने उन्हें संदर्भ से बाहर कर दिया है। पहला कथन इस संदर्भ में है कि एक त्रिगुटीय राज्य के दो विपरीत बाइनरी मापों को द्विआधारी निषेध के माध्यम से नहीं बदला जा सकता है। दूसरा कथन इस संदर्भ में है कि सही ढंग से काम करने के लिए एक आवेदन के लिए एक टर्नरी राज्य का केवल आंशिक ज्ञान पर्याप्त हो सकता है। दरवाजे के रूप में, ओपी सवाल ने संदर्भित किया कि दरवाजे खुले और बंद हैं। मैं सिर्फ एक स्पष्ट धारणा की ओर इशारा कर रहा हूं जो डेटा के इलाज के तरीके को प्रभावित कर सकता है।
पीटर एम

-1

कंक्रीट शैली के नियम हमेशा खराब होते हैं। दिशानिर्देश अच्छे हैं, लेकिन अंत में अक्सर ऐसे मामले होते हैं जहां आप कुछ ऐसा करके सामान साफ ​​कर सकते हैं जो दिशानिर्देशों का पालन नहीं करता है।

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

जैसा कि कहीं और उल्लेख किया गया है, दूसरे ब्लॉक का होना यह दर्शाने के लिए बहुत उपयोगी है कि आप स्पष्ट रूप से दूसरे मामले में कुछ नहीं करना चाहते हैं। बहुत सारे कार्यात्मक प्रोग्रामिंग करने के बाद (जहां अन्य की आवश्यकता होती है), मैंने सीखा है कि आपको हमेशा लिखते समय विचार करना चाहिए कि क्या लिख ​​रहा है, हालांकि @OldCurmudgeon उल्लेख के अनुसार वास्तव में दो अलग-अलग उपयोग के मामले हैं। एक के पास दूसरा होना चाहिए, एक का नहीं होना चाहिए। अफसोस की बात है कि कुछ ऐसा नहीं है जिसे आप हमेशा एक नज़र में बता सकते हैं, एक लाइनर के साथ अकेले रहने दें, इसलिए हठधर्मी 'हमेशा एक और ब्लॉक रखें'।

'कोई नकारात्मक नहीं' के रूप में, फिर से, पूर्ण नियम खराब हैं। खाली होना अगर अजीब हो सकता है, खासकर अगर यह उस प्रकार का है यदि उसे किसी और की आवश्यकता नहीं है, तो यह सब लिखने के बजाय एक! या a == असत्य बुरा है। उस ने कहा, बहुत सारे मामले हैं जहां नकारात्मक समझ में आता है। एक सामान्य उदाहरण एक मूल्य कैशिंग होगा:

static var cached = null

func getCached() {
    if !cached {
        cached = (some calculation, etc)
    }

    return cached
}

यदि वास्तविक (मानसिक / अंग्रेजी) तर्क में एक नकारात्मक शामिल है, तो यदि कथन होना चाहिए।

हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.