UND mehrere Parameter

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));

Was ich erwarte, ist, diesen Code auszuführen: true && true && false && false und das sollte false zurückgeben .

Wie macht man das in js? Vielen Dank

Verwenden Sie Array.prototype.everyfür alle übergebenen Argumente, um zu überprüfen, ob sie alle wahr sind.

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

Du brauchst

1. Beginnen Sie mit logicalAndset totrue

2. Verwenden Sie diese logicalAndOption, wenn Sie sie aktualisieren, anstatt zwei Einträge aus zu verwendenarguments

Die minimale Änderung ist:

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));

Aber mbojko Lösung hat den Vorteil eines Kurzschlusses (Anhalten der Schleife , wenn es zuerst einen falsy Wert findet), die wie eine gute Idee zu sein scheint.

Da Sie ES2015 + verwenden, sollten Sie wahrscheinlich einen Rest-Parameter anstelle von verwenden arguments, und Sie können eine for-ofSchleife verwenden:

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

Sie können dies auch im Einklang mit dem Ansatz von mbojko kurzschließen

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

Einige Leute mögen darauf werfen reduce, aber Archies everyLösung ist viel besser. (Aber da Ihr Vergleich nicht streng ist, würde ich es einfach machen .every(flag => flag).)

Frühe Rückgaben sollten den Code sowohl effizienter als auch kürzer machen:

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

  return true;
}

Ich denke, dies ist ein sehr kurzer Weg mit ES6 Array.prototype.reduce

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

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

Weitere Erläuterungen zur Reduzierungsfunktion finden Sie unter MDN

Sie können Array#everyden letzten Wert annehmen und zurückgeben.

Dieser Ansatz gibt das tatsächliche Ergebnis des logischen UND zurück&& .

Unter Verwendung des Ansatzes wird ein Kurzschluss für den zuerst gefundenen falschen Wert hergestellt. Dann stoppt die Iteration.

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));

Vielleicht möchten Sie hören, was mit der Schleife schief gelaufen ist:

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

1. Diese Schleife speichert die &&letzten beiden Elemente, auf die sie stößt. Im Idealfall würden &&die letzten beiden Elemente des Arrays zusammengefügt (was bereits nicht das ist, was Sie brauchen).
2. Darüber hinaus i=arguments.length-1überprüft es am Ende der Schleife das letzte Element des Arrays und i+1ist das Element "nach" dem letzten Element, das ist undefined. In Bezug auf logische Beziehungen wird es berücksichtigt false, &&erzeugt aber in einem solchen Fall den Wert selbst, und deshalb gibt die Funktion die undefinedganze Zeit zurück (dies hätte in der Frage erwähnt werden können).

Docs

expr1 && expr2: Wenn expr1konvertiert werden kann, truewird zurückgegeben expr2; sonst kehrt zurück expr1.

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

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

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));

und dann können Sie es in Richtung Archies Antwort optimieren : Das Ergebnis von &&-ing Elementen ist, truewenn alle Elemente vorhanden sind true, und Sie müssen keine einzige &&Operation ausführen, um das Ergebnis zu berechnen:

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));

(In den obigen Ausschnitten wollte ich falseeine leere Argumentliste erstellen.)