और कई मापदंडों

Question

function andMultipleExpr(){
  let logicalAnd;
  let i;
  for (i = 0; i < arguments.length; i++){
    logicalAnd =  arguments[i] && arguments[i+1];
  }
  return logicalAnd;
}

console.log(andMultipleExpr(true, true, false, false));

इस कोड को निष्पादित करने के लिए मैं जो अपेक्षा कर रहा हूं वह है: true && true && false && false और जिसे गलत वापस करना चाहिए ।

Js में वो काम कैसे करे? धन्यवाद

Comments

मैं बस झिझक रहा हूँ। मुझे यकीन है कि अगर मेरे विचार अच्छी तरह से तैयार है चाहता हूँ। अगर कोई बेहतर तरीका है, तो कृपया सुझाव दें।

— हकीम आसा

जब बूलियन्स के बजाय ट्रूथी मूल्यों का उपयोग किया जाता है तो आउटपुट क्या होना चाहिए? यानी andMultipleExpr(1, 1, 0, 0)याandMultipleExpr(1, 1, 1, 1)

— निक zoum

इसके अलावा andMultipleExpr()(कोई मापदंडों के साथ फ़ंक्शन को कॉल करना) का आउटपुट क्या होना चाहिए ?

— निक जोम

ठीक है, उन मामलों को भी ध्यान में रखा जाना चाहिए। :-)

— हकीम आसा

Answer 1

का प्रयोग करें Array.prototype.everyअगर वे सभी सही हैं जाँच करने के लिए सभी से पारित कर दिया तर्क पर;

function andMultipleExpr(...a) {
  if(a.length === 0) return false; // return false when no argument being passed
  return a.every(Boolean);
}

console.log(andMultipleExpr(true, true, false)); // should return false
console.log(andMultipleExpr(true, true, true)); // should return true

Comments

के e => e === trueसाथ बदल सकता हैBoolean

— निक zmm

@nickzoum यह सभी सत्य मूल्यों से मेल खाता है, ओपी सख्ती से तुलना कर रहा है true।

— आर्ची

@ अर्ची - नहीं, वे सच / झूठ की तुलना कर रहे हैं। ===ओपी के कोड में कोई नहीं है। हालांकि आपका everyविचार हाजिर है । लेकिन सिर्फ .every(e => e)काम करता है।

— टीजे क्राउडर

@TJCrowder हाँ बस उस पर ध्यान दिया। जवाब पहले से ही अपडेट। धन्यवाद :)

— आर्ची

यदि आप एक सहायक फ़ंक्शन जोड़ते हैं: const isTrue = x => x === true(या x => !!xसभी सत्य मूल्यों के लिए), तो आप अपने समाधान को संकुचित कर सकते हैं return arguments.every(isTrue)। जो मुझे सुंदर लगता है।

— mbojko

Answer 2

आपको

1. logicalAndसेट से शुरू करेंtrue

2. logicalAndइसे अपडेट करते समय उपयोग करें , इसके बजाय दो प्रविष्टियों का उपयोग करने सेarguments

न्यूनतम परिवर्तन है:

function andMultipleExpr(){
    let logicalAnd = true; // ***
    let i;
    for (i = 0; i < arguments.length; i++){
        logicalAnd = logicalAnd && arguments[i]; // ***
    }
    return logicalAnd;
}
console.log(andMultipleExpr(true, true, false, false));

लेकिन mbojko के समाधान में शॉर्ट- सर्कुलेटिंग (लूप को रोकना जब यह पहली बार एक मिथ्या मूल्य पाता है) का लाभ होता है, जो एक अच्छा विचार जैसा लगता है।

चूंकि आप ES2015 + का उपयोग कर रहे हैं, इसलिए आपको संभवतः एक बचे हुए पैरामीटर का उपयोग करना चाहिए arguments, और आप एक for-ofलूप का उपयोग कर सकते हैं :

function andMultipleExpr(...flags) {
    let logicalAnd = true;
    for (const flag of flags) {
        logicalAnd = logicalAnd && flag;
    }
    return logicalAnd;
}
console.log(andMultipleExpr(true, true, false, false));

आप शॉर्ट-सर्किट भी कर सकते हैं जो कि मब्जो के दृष्टिकोण को ध्यान में रखते हुए

function andMultipleExpr(...flags) {
    for (const flag of flags) {
        if (!flag) {
            return false;
        }
    }
    return true;
}
console.log(andMultipleExpr(true, true, false, false));

कुछ लोग reduceइस पर फेंक सकते हैं , लेकिन आर्ची का everyसमाधान ज्यादा बेहतर है। (लेकिन जब से आपकी तुलना सख्त नहीं है, मैं अभी बनाऊंगा .every(flag => flag)।)

Comments

धन्यवाद। यह मेरे लिए अधिक समझ में आता है :-)

— हकीम आसा

इस मामले में कम बयान में दूसरा पैरामीटर जोड़ने की आवश्यकता नहीं है, डिफ़ॉल्ट रूप से पहला पैरामीटर प्राप्त करना भी काम करेगा।

— निक जोम

@nickzoum - केवल अगर हम मान सकते हैं कि फ़ंक्शन को कभी भी कोई तर्क नहीं कहा जाएगा, क्योंकि [].reduce((a,b)=>a && b)फेंकता है।

— टीजे क्राउडर

Answer 3

प्रारंभिक रिटर्न को कोड को अधिक कुशल और छोटा बनाना चाहिए:

function andMultipleExpr() {
  for (let i = 0; i < arguments.length; i++) {
    if (!arguments[i]) {
      return false;
    }
  }

  return true;
}

Answer 4

मुझे लगता है कि यह ES6 का उपयोग करने का एक बहुत ही छोटा तरीका है Array.prototype.reduce

let andMultipleExpr = (...args) => args.reduce((a, b) => a && b);

console.log(andMultipleExpr(true, true, false, false));

समारोह को कम करने के बारे में अधिक जानकारी के लिए, कृपया MDN पढ़ें

Comments

आप एक सरणी विधि का उपयोग करने के लिए कर रहे हैं, यह है बहुत उपयोग करने के लिए बेहतर everyकी तरह आर्ची किया तुलना में reduce। सरल, और यह शॉर्ट सर्किट।

— टीजे क्राउडर

यह सत्य है। लेकिन हमें रहने दो अब वह चाहता है लेकिन तार्किक या || अब कम करने के साथ, यह सिर्फ बदल जाएगा && से ||

— पैट्रिसोल केनफैक

या everyकरने के लिए some। फिर भी सरल। फिर भी शॉर्ट-सर्किट।

— टीजे क्राउडर

बहुत बढ़िया। आप सही हैं @TJCrowder

— पैट्रिसोल केनफ़ैक

Answer 5

आप Array#everyअंतिम मान ले और वापस कर सकते हैं ।

यह दृष्टिकोण तार्किक और&& का वास्तविक परिणाम देता है ।

दृष्टिकोण का उपयोग करके, पहले पाए गए मिथ्या मूल्य के लिए एक शॉर्ट सर्किट बनाया जाता है। फिर चलना बंद हो जाता है।

function andMultipleExpr(...args) {
    var result; // any return value is configurable for empty args
    args.every(v => result = v);
    return result;
}

console.log(andMultipleExpr(true, true, false, false));
console.log(andMultipleExpr(true, true, 1, 2));
console.log(andMultipleExpr(true, 0, 1, 2));

Answer 6

शायद आप सुनना चाहते हैं कि लूप के साथ क्या गलत हुआ:

for (i = 0; i < arguments.length; i++){
  logicalAnd =  arguments[i] && arguments[i+1];
}

1. यह लूप &&पिछले दो आइटमों को संग्रहीत करता है जो इसका सामना करता है। आदर्श मामले में यह &&सरणी के अंतिम दो तत्वों को मिलाएगा (जो पहले से ही आपकी जरूरत नहीं है)
2. लूप के अंत में उसके शीर्ष पर i=arguments.length-1, यह सरणी के अंतिम तत्व की जांच करेगा, और i+1"अंतिम", जो है के बाद "तत्व" है undefined। तार्किक संबंधों के संदर्भ में, यह माना जाता है false, लेकिन &&ऐसे मामले में स्वयं मूल्य पैदा करता है, और यही कारण है कि फ़ंक्शन undefinedहर समय लौटता है (इसका उल्लेख इस प्रश्न में किया जा सकता है)।

डॉक्स

expr1 && expr2: यदि रिटर्न में expr1परिवर्तित किया जा सकता trueहै expr2; और, रिटर्न expr1।

arr=[true];
console.log("your case:",arr[0] && arr[1]);

console.log("1 && 2:", 1 && 2);

---

इसके बजाय, आपको logicalAndएक संचायक के रूप में उपयोग करना चाहिए , जो &&सभी पिछले तत्वों के परिणाम को इकट्ठा करता है , और एक चाल जो आप उपयोग कर सकते हैं यदि आंशिक &&का परिणाम है false, तो इससे कोई फर्क नहीं पड़ता कि शेष तत्व क्या हैं, अंतिम परिणाम होने जा रहा है false, तो लूप तुरंत बंद हो सकता है:

function andMultipleExpr(){
    let logicalAnd = arguments[0] || false;
    for (let i = 1; i < arguments.length && logicalAnd; i++){
        logicalAnd = logicalAnd && arguments[i];
    }
    return logicalAnd;
}

console.log("():",andMultipleExpr());
console.log("(false):",andMultipleExpr(false));
console.log("(true):",andMultipleExpr(true));
console.log("(true,true):",andMultipleExpr(true,true));
console.log("(true, true, false, false):",andMultipleExpr(true, true, false, false));

और फिर आप इसे आर्ची के उत्तर के लिए अनुकूलित कर सकते हैं : &&-ing आइटम का परिणाम है trueयदि सभी आइटम हैं true, और आपको &&परिणाम की गणना के लिए एक भी ऑपरेशन निष्पादित करने की आवश्यकता नहीं है :

function andMultipleExpr(){
    if(arguments.length===0){
      return false;
    }
    for (let i = 0; i < arguments.length; i++){
      if(!arguments[i]){
        return false;
      }
    }
    return true;
}

console.log("():",andMultipleExpr());
console.log("(false):",andMultipleExpr(false));
console.log("(true):",andMultipleExpr(true));
console.log("(true,true):",andMultipleExpr(true,true));
console.log("(true, true, false, false):",andMultipleExpr(true, true, false, false));

(ऊपर के स्निपेट में मैंने falseखाली तर्क सूची के लिए उत्पादन करने का लक्ष्य रखा है।)