अगर-else if-किसी और भाव

Question

यहाँ है कोड के कुछ नमूना लाइन की एक बड़ी संख्या को अनुकूल कैसे करें ..

if(loc > 0 || cat > 0 || price > 0 || jsBed <= bedroom || jsBuilt >= built) {  
/// Condition to checn all true 
    return true; 
} else if(loc < 0 || cat > 0 || price > 0 || jsBed <= bedroom || jsBuilt >= built) { 
    /////// 1 false other are true 

} else if(loc > 0 || cat < 0 || price > 0 || jsBed <= bedroom || jsBuilt >= built) { 

} 

इन हालत को संभालने के लिए कैसे। अगर मेरे पास 5 कथन है। तो यह लगभग 12+ स्थिति एक-एक करके होनी चाहिए .. यदि मैं सभी 5 संयोजनों की जांच कर रहा हूं तो यह कोड की अधिक लाइनों पर जा रहा है, क्या हमारे पास सभी शर्तों की जांच करने के लिए कोई बेहतर विकल्प है।

Answer 1

आप जावास्क्रिप्ट में एक पूर्णांक के रूप में एक बूलियन अभिव्यक्ति का इलाज है, यह (false के लिए) 0 या 1 (true के लिए) के लिए मूल्यांकन करेंगे। तो अगर आप की स्थिति योग कर सकता है और उसके बाद कितने सही थे जांच करने के लिए एक स्विच-मामले निर्माण का उपयोग करें:

var numTrue = 
    (loc > 0) + (cat > 0) + (price > 0) + (jsBed <= bedroom) + (jsBuilt >= built); 

switch(numTrue) { 
    case 0: 
     // do something if no condition is met 
     break; 
    case 1: 
     // do something else if one condition is met 
     break; 
    // etc... 
} 

Answer 2

के बाद से अपने 3 की स्थिति तय कर रहे हैं, आप उन्हें पहली हो सकता है, दूसरों के द्वारा पीछा किया, जो करने के लिए परिवर्तित किया जा सकता स्विच केस।

if(price > 0 || jsBed <= bedroom || jsBuilt >= built) { 
    var locCheck = (loc > 0) ? 1 : 0; 
    var catCheck = (cat > 0) ? 1 : 0; 
    switch(locCheck + catCheck){ 
     case 0: 
      break; 
     case 1: 
      break; 
     case 2: 
      break; 
     default: 
      break; 
    } 
} 

Answer 3

edit1: जावास्क्रिप्ट, नहीं जावा के लिए संशोधित किया। ओह ...

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

कंक्रीट में 5 चर और 2 चर प्रत्येक चर हैं? मैंने बाइनरी प्रतिनिधित्व में संख्याओं के साथ एक टेबल सेट किया है। यदि वहां 2 विकल्प हैं (या कुछ पर) चर 2 आपको संख्याओं (आधार 10) का उपयोग करना है। आप एक विधि में तरह

const locVal = (loc > 0 ? 0x1 : 0x0) << 0; 
const catVal = (cat < 0 ? 0x1 : 0x0) << 1; 
const priceVal= (price < 0 ? 0x1 : 0x0) << 2; 
ect 

द्विआधारी मूल्यों का उपयोग कर सकते हैं तो तुम समूह उन्हें कर सकते हैं:

function foo(trueCond, level) { 
    return (trueCond ? 0b1 : 0b0) << level; 
} 

जो

const locVal = foo(loc > 0, 0); 
const catVal = foo(cat > 0, 1); 
const priceVal= foo(price > 0, 2) 

बनाता है (मैं अन्य वार्स नहीं दिखाए हैं ...) फिर बाइनरी मान

const total = locVal + catVal + priceVal 

तो फिर तुम अब total में मौजूद बाइनरी अनुक्रम का पूर्णांक मूल्य का प्रतिनिधित्व करता case में मूल्यों की तरह

switch (total) { 
    case 0: // all options negative 
    case 1: // only loc is positive 
    case 2: // only cat is positive 
    case 3: // both loc and cat is positive 
    ect 
} 

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

वहाँ चर प्रति दो से अधिक विकल्प हैं, तो आप (, विधि foo में तरह (trueCond ? 1 : 0) * Math.pow(10, level) का उपयोग करें) 10 के कारकों में काम कर सकते हैं

Answer 4

5 की स्थिति 2 ** 5, अर्थात 32 संयोजन है।

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

var loc=1,cat=0,price=0,jsBed=1,bedroom=0,jsbuilt=0,built=1; 
 

 
let results=[loc > 0,cat > 0,price > 0,jsBed <= bedroom,jsbuilt >= built]; 
 
let bits=results.reduce((accum,current,index)=>accum+(current<<index), 0); 
 
switch(bits){ 
 
case 0: // none 
 
break; 
 
case 3: // first two 
 
break; 
 
case 4: // third one 
 
break; 
 
}

इस स्थिरांक उपयोग करने के लिए स्विच बयान अधिक पठनीय होगा संशोधित है

var loc=0,cat=1,price=0,jsBed=1,bedroom=0,jsbuilt=0,built=1; 
 

 
const locBit=1<<0; 
 
const catBit=1<<1; 
 
const priceBit=1<<2; 
 
const bedBit=1<<3; 
 
const builtBit=1<<4; 
 
let bits=(loc > 0)*locBit | 
 
     (cat > 0)*catBit | 
 
     (price > 0)*priceBit | 
 
     (jsBed <= bedroom)*bedBit | 
 
     (jsbuilt >= built)*builtBit; 
 
switch(bits){ 
 
    case 0: 
 
     console.log("!loc,!cat,!price,!bed,!built"); 
 
     break; 
 
    case catBit|locBit: 
 
     console.log("loc,cat,!price,!bed>!built"); 
 
     break; 
 
    default: 
 
     console.log(bits); 
 
}

आप con का उपयोग कर सकते हैं stants मदद करने के लिए

Answer 5

आप शर्त यह है कि पूरी की जा कभी नहीं होगा है: अगर, हालत cat > 0 || price > 0 || jsBed <= bedroom || jsBuilt >= built बेकार ebcause पहले से ही पहले एक में मुलाकात की है

• किसी और दूसरे पर:

  if(loc > 0 || cat > 0 || price > 0 || jsBed <= bedroom || jsBuilt >= built){  
      /// Condition to checn all true 
      return true; 
  } else if(loc < 0 || cat > 0 || price > 0 || jsBed <= bedroom || jsBuilt >= built) { 
  /////// 1 false other are true 
  
  } else if(loc > 0 || cat < 0 || price > 0 || jsBed <= bedroom || jsBuilt >= built) { 
  
  } 
  

  मूल रूप से। चूंकि आप का उपयोग करते हैं, इसलिए वे पहले से ही पहले ही प्रवेश कर चुके होंगे। तो केवल एक ही बात है जो loc < 0 है।

• पिछले elseif केवल cat < 0 के लिए एक ही प्रासंगिक है।

तो यह

if(loc > 0 || cat > 0 || price > 0 || jsBed <= bedroom || jsBuilt >= built){  
    /// Condition to checn all true 
    return true; 
} else if(loc < 0) { 
/////// 1 false other are true 

} else if(cat < 0) { 

} 

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

नोट: मैं तुम्हें नहीं लिखा हो सकता है कि आप क्या करना चाहते थे, कुछ और या के बजाय भूल लगता है।