मैं 3 अलग-अलग मानों की तुलना करने की कोशिश कर रहा हूं जो 0 या अधिक हो सकते हैं। क्या इसे कई अन्य-अगर बयानों के साथ करने का एकमात्र तरीका है? मेरे पास अभी यही है लेकिन मुझे लगता है कि एक बेहतर तरीका होना चाहिए:

//just A
if (A > 0 && B == 0 && C == 0){//Do something}
//just B
else if (A == 0 && B > 0 && C == 0){//Do something}
//just C
else if (A == 0 && B == 0 && C > 0){//Do something}

//A + B
else if (A > 0 && B > 0 && C == 0){//Do something}
//A + C
else if (A > 0 && B == 0 && C > 0){//Do something}
//B + C
else if (A == 0 && B > 0 && C > 0){//Do something}

//A + B + C
else if (A > 0 && B > 0 && C > 0){//Do something}

else {//Do something}
2
Jacob Peterson 6 अक्टूबर 2021, 17:13
क्या होता है इसके आधार पर इसे संभालने के शायद अलग-अलग तरीके हैं
 – 
depperm
6 अक्टूबर 2021, 17:17
1
यह निर्भर करता है: क्या आपको "ए शून्य से बड़ा है, लेकिन बी और सी नहीं है" के सभी संयोजनों के बीच अंतर करने की आवश्यकता है या क्या आप केवल यह जानना चाहते हैं कि उनमें से कोई एक बड़ा है या नहीं? आपके प्रश्न का उत्तर देने के लिए अधिक संदर्भ की आवश्यकता है।
 – 
Taxel
6 अक्टूबर 2021, 17:17
//Do something इसके बराबर है: A + B, A + C, ..., A + B + C ?
 – 
Yosvel Quintero Arguelles
6 अक्टूबर 2021, 18:13
हां, मुझे सभी संयोजनों को जानने की जरूरत है..
 – 
Jacob Peterson
6 अक्टूबर 2021, 18:45
मुझे लगता है कि कोई रास्ता नहीं है: यह संयोजन का कुल = 3 + 3 + 1 + 1 = 8 (संभावित मामले) है।
 – 
HoangHieu
6 अक्टूबर 2021, 19:10

4 जवाब

सबसे बढ़िया उत्तर

आप प्रत्येक व्यक्तिगत चेक को 1 या 0 (सही या गलत) के मान के रूप में देख सकते हैं। उदाहरण के लिए यदि ए 2 है, तो ए> 0 -> सत्य -> ​​1. चूंकि जावास्क्रिप्ट में शून्य एक झूठा मान है, A ? 1 : 0 A > 0 ? 1 : 0 के लिए एक शॉर्टहैंड है।

फिर आप शून्य और एक को जोड़ सकते हैं और एक स्ट्रिंग संख्या का उत्पादन कर सकते हैं और उस ऑब्जेक्ट प्रॉपर्टी की कुंजी के रूप में उपयोग कर सकते हैं जिससे आप जिस क्रिया को निष्पादित करना चाहते हैं उसे प्राप्त करने के लिए।

  • कोई नहीं: A == 0 && B == 0 && C == 0 -> झूठा, झूठा, झूठा -> 000
  • बस ए: A > 0 && B == 0 && C == 0 -> सच, झूठा, झूठा -> 100
  • बस सी: A == 0 && B == 0 && C > 0 -> झूठा, झूठा, सच -> 001
  • बस बी: A == 0 && B > 0 && C == 0 -> झूठा, सच, झूठा -> 010
  • बी + सी: A == 0 && B > 0 && C > 0 -> झूठा, सच, सच -> 011
  • ए + सी: A > 0 && B == 0 && C > 0 -> सच, झूठा, सच -> 101
  • ए + बी: A > 0 && B > 0 && C == 0 -> सच, सच, झूठ -> 110
  • ए + बी + सी: A > 0 && B > 0 && C > 0 -> सच, सच, सच -> 111
const variants = {
  [0b000]() {console.log('none/default')},
  [0b001]() {console.log('just C')},
  [0b010]() {console.log('just B')},
  [0b011]() {console.log('B+C')},
  [0b100]() {console.log('just A')},
  [0b101]() {console.log('A+C')},
  [0b110]() {console.log('A+B')},
  [0b111]() {console.log('A+B+C')},
}

const A = 2;
const B = 0;
const C = 99;

const key = (+!!A << 2) + (+!!B << 1) + !!C;

variants[key]();
2
ZER0 6 अक्टूबर 2021, 21:44
यह वास्तव में मेरे लिए कोई मतलब नहीं है ...
 – 
Jacob Peterson
6 अक्टूबर 2021, 18:50
मैंने एक स्पष्टीकरण जोड़ा कि हम बूलियन चेक से शून्य और एक तक कैसे जाते हैं। अब स्पष्ट है?
 – 
Nad Hr
6 अक्टूबर 2021, 20:00
ओह, मैं वास्तव में इसे संपादित करने का इरादा नहीं रखता था, लेकिन केवल सुझाव एक संपादन के लिए। इसे वापस करने के लिए स्वतंत्र महसूस करें!
 – 
ZER0
6 अक्टूबर 2021, 21:45

3

const toBits = (a, b, c) = {
  const toBit = val => val > 0 ? '1' : '0'
  return toBit(a) + toBit(b) + toBit(c)
}

const cases = {
  '000': () => { // do something },
  '001': () => { // do something },
  '010': () => { // do something },
  '011': () => { // do something },
  '100': () => { // do something },
  '101': () => { // do something },
  '110': () => { // do something },
  '111': () => { // do something },
}

const bitsRepresentation = toBits(a, b, c)
const runCase = cases[bitsRepresentation]

runCase()

एक अन्य विकल्प स्विच को थोड़े उल्टे तरीके से उपयोग करना है

const aFlag = a > 0
const bFlag = b > 0
const cFlag = c > 0

switch (true) {
  case (!aFlag && !bFlag && !cFlag):
    // do something  
  case (!aFlag && !bFlag && cFlag):
    // do something  
  case (!aFlag && bFlag && !cFlag):
    // do something  
  case (!aFlag && bFlag && cFlag):
    // do something  
  case (aFlag && !bFlag && !cFlag):
    // do something  
  case (aFlag && !bFlag && cFlag):
    // do something  
  case (aFlag && bFlag && !cFlag):
    // do something  
  case (aFlag && bFlag && cFlag):
    // do something  
  default:
    // do nothing
}
1
Vitaly Kravtsov 6 अक्टूबर 2021, 19:10
आपके द्वारा दिखाया गया पहला विकल्प मुझे समझ में नहीं आया ..
 – 
Jacob Peterson
6 अक्टूबर 2021, 18:52
आप समझ नहीं पा रहे हैं कि बिट्स के साथ विकल्पों का प्रतिनिधित्व कैसे किया जाता है या कार्यों के लिए मूल्यों को कैसे मैप किया जाता है?
 – 
Vitaly Kravtsov
6 अक्टूबर 2021, 19:06

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

aFlag = (A > 0);
bFlag = (B > 0);
cFlag = (C > 0);

//just A
if (aFlag && !bFlag && !cFlag){//Do something}
//just B
else if (!aFlag && bFlag && !cFlag){//Do something}
//just C
else if (!aFlag && !bFlag && cFlag){//Do something}

//A + B
else if (aFlag && bFlag && !cFlag){//Do something}
//A + C
else if (aFlag && !bFlag && cFlag){//Do something}
//B + C
else if (!aFlag && bFlag && cFlag){//Do something}

//A + B + C
else if (aFlag && bFlag && cFlag){//Do something}

else {//Do something}

यह शायद बहुत तेज़ नहीं है, लेकिन कम से कम मेरी राय में, यह देखने में थोड़ा आसान लगता है।

मुझे लगता है कि आप इसे किसी अन्य प्रकार के नेस्टेड में भी बदल सकते हैं यदि कथन, अन्य की एक रैखिक श्रृंखला के बजाय-यदि कथन:

if (A > 0) {
    if (B > 0) {
        if (C > 0) {
            //A + B + C
        } else {
            //A + B
        }
    } else {
        if (C > 0) {
            //A + C
        } else {
            //just A
        }
    }
} else {
    if (B > 0) {
        if (C > 0) {
            //B + C
        } else {
            //just B
        }
    } else {
        if (C > 0) {
            //just C
        } else {
            //None
        }
    }
}

यह वास्तव में गन्दा लग रहा है, लेकिन यह आपके कार्यान्वयन के लिए संभावित 7 के बजाय कुल 3 चेक करेगा।

0
Riggs Markham 6 अक्टूबर 2021, 18:07
1
हां, मुझे उन सभी के बीच अंतर करने की जरूरत है .. मैंने आपके द्वारा दिखाए गए दूसरे विकल्प पर विचार किया लेकिन यह मेरे पास जो था उससे कहीं ज्यादा गन्दा लगता है ..
 – 
Jacob Peterson
6 अक्टूबर 2021, 18:48
ठीक है, यदि आप उनमें से किसी के बीच कोड साझा नहीं कर सकते हैं (उदाहरण के लिए, यदि "ए + बी" "सिर्फ ए" के लिए कोड और "बस बी" के लिए कोड था), ऐसा लगता है कि आपके पास होगा ऐसा कुछ करने के लिए लंबे समय से घुमावदार। मुझे नहीं लगता कि कोई बेहतर विकल्प है। हो सकता है कि आप एक स्विच-केस स्टेटमेंट कर सकें, लेकिन आपको इनपुट के साथ थोड़ा फील करना होगा, और मुझे नहीं लगता कि यह अंत में बहुत बेहतर होगा।
 – 
Riggs Markham
6 अक्टूबर 2021, 19:18

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

यहाँ मेरा सुझाव है:

const sum = A + B + C;
//just A
if (A == sum){//Do something
}
//just B
else if (B == sum){//Do something
}
//just C
else if (C == sum){//Do something
}

//A + B
else if (A + B == sum){//Do something
}
//A + C
else if (A + C  == sum){//Do something
}
//B + C
else if (B + C  == sum){//Do something
}

//A + B + C
else if (A + B + C == sum){//Do something
}

else {//Do something
}

प्रश्न के अनुसार मैं मान रहा हूँ कि आपके पास A, B and C संख्याएँ हैं और 0 से अधिक या बराबर हैं।

0
Nimitt Shah 6 अक्टूबर 2021, 18:27
यह समझ में आता है लेकिन ऐसा लगता है कि मैं वर्तमान में जो कर रहा हूं उसके समान ही है। सुनिश्चित नहीं है कि यह बहुत सुधार है लेकिन धन्यवाद।
 – 
Jacob Peterson
6 अक्टूबर 2021, 18:47
सच है लेकिन अब आपके पास कम शर्तें हैं जो समाधान को तेज बनाती हैं।
 – 
Nimitt Shah
6 अक्टूबर 2021, 18:51