इसे बेहतर बनाने के लिए मैं अपनी स्थिति कैसे सुधार सकता हूं?

Question

मेरी एक शर्त है

if(exists && !isDirectory || !exists)
{}

मैं इसे कैसे संशोधित कर सकता हूं, ताकि यह अधिक समझ में आ सके।

Comments

क्या मौजूद है जो अप्रत्यक्ष रूप से मौजूद है, वह गलत है?

— मार्कटनी

मौजूद है बूल प्रकार, isDirectory भी BOOL टाइप वैरिएबल है

— Spynet

अगर (isDirectory) ... (मौजूद है .. .. मौजूद है) हमेशा सत्य रहेगा।

— शार्क

@ शकर - क्या होगा अगर existsऔर isDirectoryदोनों सच हैं?

— पसवाया

मैंने शीर्षक पढ़ा "मुझे एक व्यक्तित्व समस्या है, क्या मैं इसे ठीक करने के लिए अपने दिमाग को मिटा सकता हूं"। हाँ, मैं थक गया हूँ।

— अन्नान

Answer 1

|| इतना सराहनीय है

if(!exists || (exists && !isDirectory))

समतुल्य है।

अब क्योंकि मौजूद है के दूसरे भाग में हमेशा सच है ||आप ड्रॉप कर सकते हैं &&:

if(!exists || !isDirectory)

या आप एक कदम और आगे बढ़ सकते हैं:

if(!(exists && isDirectory))

Comments

जो कुछ भी निहित था, लेकिन यहां स्पष्ट रूप से उल्लेख नहीं किया गया है, &&इसकी उच्च मिसाल है (कम से कम ज्यादातर प्रसिद्ध भाषाओं में - इससे अधिक अपवाद हो सकते हैं ||। इस प्रकार a && b || cके बराबर है, (a && b) || cलेकिन करने के लिए नहीं a && (b || c)।

— पेटर टॉर्क

मुझे लगता है, !exists || !isDirectoryयह अधिक "समझने योग्य" है, क्योंकि, isDirectoryअगर यह सच नहीं हो सकता है !exists। इसलिए एक मानव के रूप में हम कहेंगे "यदि इसका अस्तित्व नहीं है या यह [अस्तित्व में है और यह] एक निर्देशिका नहीं है"।

— दुआर

मैं पसंद करता हूँ! पिछले एक से अधिक।

— अपूर्व खुरसिया १०

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

— orlp

जो कोई भी '&&', '||', '==', '!' = ', आदि के सापेक्ष पूर्वनिर्धारण पर निर्भर करता है और कोष्ठक का उपयोग करके अपने इरादे स्पष्ट नहीं करता है, जिसे गोली मारने के योग्य है। सभी भाषाओं में, 'a && b' जैसा कुछ c 'यह कहते हुए एक टिप्पणी के बराबर है कि लेखक ने संभवतः कुछ अतिरिक्त वर्ण लिखने से बचने के लिए पूरी बात को अपनी हड़बड़ी में खराब कर दिया।

— ब्रेंडन

Answer 2

एक प्रक्रिया के रूप में, मैं एक सत्य तालिका बनाने का सुझाव देता हूं:

e = exists
d = isDirectory

e | d | (e && !d) || !e
--+---+----------------
0 | 0 | 1
0 | 1 | 1
1 | 0 | 1
1 | 1 | 0

यह NANDऑपरेशन से मेल खाता है , जो कि बस है:

!(exists && isDirectory)

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

---

@Christoffer Hammarström की स्थिति के बारे में एक महत्वपूर्ण बिंदु पाला isDirectoryके राज्य से बंधा जा रहा है exists। यह मानते हुए कि वे एक ही संदर्भ को संदर्भित करते हैं, और यह संभव नहीं है कि एक राज्य है जहां संदर्भ मौजूद नहीं है और एक निर्देशिका है, सत्य तालिका निम्नानुसार लिखी जा सकती है:

e | d | (e && !d) || !e
--+---+----------------
0 | 0 | 1
0 | 1 | n/a
1 | 0 | 1
1 | 1 | 0

इसका n/aउपयोग उस स्थिति का प्रतिनिधित्व करने के लिए किया जाता है जो मायने नहीं रखता है। स्वीकार्य कटौती के परिणामस्वरूप 1या 0राज्यों के लिए परिणाम हो सकते हैं n/a।

इसे ध्यान में रखते हुए, !(exists && isDirectory)अभी भी एक वैध कमी है, जिसके परिणामस्वरूप एक 1है !e && d।

हालांकि, !isDirectoryएक बहुत सरल कमी हो सकता है, जिसका परिणाम 0के लिए !e && d।

Comments

अगला कदम यह महसूस करना है कि isDirectoryनिर्भर करता है exists। यह दोनों एक निर्देशिका नहीं हो सकता है और मौजूद नहीं है।

— क्रिस्टोफर हैमरस्ट्रॉम

@ChristofferHammarstrom, संदर्भ से बाहर मैं यह नहीं मान सकता कि चर एक ही चीज़ को संदर्भित करते हैं, लेकिन यह एक वैध बिंदु है। परिणाम स्तंभ उन n/aस्थानों से भरा होना चाहिए जहां राज्य को प्राप्त करना असंभव है, और समीकरण तदनुसार कम हो गया है।

— zzzzBov

ठीक है, यदि चर दो अलग-अलग संदर्भों को संदर्भित करते हैं, तो वे बहुत अधिक जटिल हैं और उनका नाम बदलने की आवश्यकता है।

— क्रिस्चोफ़र हैमरस्ट्रॉम

लेकिन एक सत्य तालिका बनाना और उसका मूल्यांकन करना एनपी-पूर्ण है!

— थॉमस ईडिंग

@ThomasEding, मेरे पास तब आपके लिए दो उद्धरण हैं, "सिद्धांत रूप में, सिद्धांत और व्यवहार समान हैं, व्यवहार में, वे नहीं हैं।" और "समयपूर्व अनुकूलन सभी बुराई की जड़ है।"

— zzzzBov

Answer 3

बेहतर पठनीयता के लिए, मैं बूलियन स्थितियों को विधियों में निकालना पसंद करता हूं:

if(fileNameUnused())
{...}

public boolean fileNameUnused() {
   return exists && !isDirectory || !exists;
}

या एक बेहतर विधि नाम के साथ। यदि आप इस विधि को ठीक से नाम दे सकते हैं, तो आपके कोड के पाठक को यह पता लगाने की आवश्यकता है कि बूलियन स्थिति का क्या मतलब है।

Comments

उपयोगी नामों के बारे में कुछ कहने के लिए +1। लेकिन कहीं न कहीं आपको सशर्त सुधार करना होगा।

— अपूर्व खुरसिया १०

एक कम चरम विकल्प, जो अभी भी इरादे को व्यक्त करता है, बस इस्तेमाल की जाने वाली स्थिति का नाम है:boolean fileNameUnused = !exists || !isDirectory; if (fileNameUnused) { doSomething(); }

— स्टीवन

Answer 4

आप बस नो-गो केस को नाकाम करने की कोशिश कर सकते हैं और यदि वह दिखाता है तो जमानत दे सकता है।

while(someCondition) {

    if(exists && isDirectory)
        continue;
        // maybe "break", depends on what you're after.

        // the rest of the code
}

या और भी

function processFile(someFile)
{ 
    // ...
    if(exists && isDirectory)
       return false;
    // the rest of the code
    // ...
}

Comments

ब्रेक, जारी नहीं है, और अधिक से अधिक एक वापसी बयान कोड बदबू आ रही है माना जाता है?

— Freiheit

@Freiheit यह संदर्भ पर निर्भर करता है। कभी-कभी इंडेंटेशन को कम करने के लिए एक प्रारंभिक रिटर्न स्टेटमेंट का उपयोग किया जाता है, इस प्रकार पठनीयता को बढ़ाया जाता है।

— बजे मार्को-फिसेट

सर्वश्रेष्ठ उत्तर - जटिल सशर्त समय पढ़ने और उन्हें समझने में बहुत अधिक समय बर्बाद करते हैं। परिणामस्वरूप अक्सर "पढ़ने के रूप में लिया जाता है" कपटी कीड़े के लिए अग्रणी।

— मटनज

Answer 5

आप एक सत्य तालिका का उपयोग कर सकते हैं जैसा कि बताया गया है। दूसरा चरण शब्दों की संख्या को कम करने के लिए केवी-मैप हो सकता है ।

बूलियन बीजगणित के नियमों का उपयोग करना एक और दृष्टिकोण है:

A = मौजूद है
B =! IsDirectory
! A =! मौजूद है

&& = *
|| = +

[संपादित करें]
एक सरल रूपान्तरण, क्योंकि संचालन और या पारस्परिक रूप से वितरण हैं:

मौजूद है & amp; isDirectory || मौजूद!
= A * B +! A
= (A +! A) * (B +! A)
= 1 * (B +! A)
= B +! A
[/ Edit

मौजूद है & amp; isDirectory || मौजूद!
= A * B +! A
= A * B +! A * 1 // पहचान
= A * B +! A * (B + 1) // Annihilator
= A * B +! A * B +! A / / वितरण और पहचान
= B * (A +! A) +! A // वितरण
= B * 1 +! A // पूरक 2
= B +! A // पहचान
=! IsDirectory !! !मौजूद

या दोहरे पूरक के साथ (!! x = x):

A * B +! A
= !! (A * B +! A)
=! (((A * B) * A)
! - (! (A +! B) * A)
=! (!! A * A + ! B * A)
=! (0 +! B * A)
=! (! (B * A)
= B +! A
=! IsDirectory !! !मौजूद

Comments

औपचारिक नियमों का उपयोग करने के लिए +1 (हालांकि मैं कभी भी कॉलेज के पहले वर्ष के बाद इनमें से एक नहीं देखूंगा)।

— नेमंजा बोरिक

wolframalpha.com/input/?i=A+%26%26+B+||+A

— एडी गैसपेरियन

Answer 6

मैं "का उपयोग करना पसंद नहीं करता!" जब अभिव्यक्ति में एक से अधिक स्थितियां हों। मैं इसे और अधिक पठनीय बनाने के लिए कोड की पंक्तियों को जोड़ूंगा।

doesNotExist = !exists;
isFile = exists && !isDirecotry;
if (isFile || doesNotExist) 
   {}

Comments

+1 यह "अगर फ़ाइल है या मौजूद नहीं है" के रूप में पढ़ना आसान बनाता है जो अंग्रेजी के बहुत करीब है।

— फिल

यह एक Refactoring है जिसे Introduce Explain Variable कहा जाता है ।

— एडी गैसपेरियन

Answer 7

जैसा कि पहले संकेत दिया गया है, इस शर्त को कम किया जा सकता है:

if (!(exists && isDirectory))

हालाँकि, मैं शर्त लगाता हूँ कि एक निर्देशिका होने का अर्थ है अस्तित्व। यदि हां, तो हम इस शर्त को कम कर सकते हैं:

if (!isDirectory)