E più parametri

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

Quello che mi aspetto è di eseguire questo codice: true && true && false && false e che dovrebbe restituire false .

Come farlo funzionare in js? Grazie

Utilizzare Array.prototype.everysu tutti gli argomenti passati per verificare se sono tutti veri;

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

Devi

1. Inizia con logicalAndimpostato sutrue

2. Utilizzare logicalAnddurante l'aggiornamento, anziché utilizzare due voci daarguments

Il minimo cambiamento è:

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

Ma la soluzione di mbojko ha il vantaggio di cortocircuitare (fermare il loop quando trova per la prima volta un valore falso), che sembra una buona idea.

Dato che stai usando ES2015 +, probabilmente dovresti usare un parametro rest piuttosto che arguments, e puoi usare un for-ofloop:

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

Puoi anche cortocircuitare questo in linea con l'approccio di mbojko

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

Alcune persone potrebbero lanciarlo reduce, ma la everysoluzione di Archie è molto migliore. (Ma dal momento che il tuo confronto non è rigoroso, lo farei solo .every(flag => flag).)

I resi anticipati dovrebbero rendere il codice più efficiente e più breve:

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

  return true;
}

Penso che questo sia un modo molto breve con ES6 Array.prototype.reduce

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

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

Per ulteriori spiegazioni sulla funzione di riduzione, leggere MDN

Potresti prendere Array#everye restituire l'ultimo valore.

Questo approccio restituisce il vero risultato di AND logico&& .

Usando l'approccio, viene creato un corto circuito per il primo valore di falsy trovato. Quindi l'iterazione si interrompe.

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

Forse vuoi sentire cosa è andato storto con il loop:

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

1. questo ciclo memorizza gli &&ultimi due oggetti che incontra. Nel caso ideale sarebbero &&insieme gli ultimi due elementi dell'array (che non è già quello di cui hai bisogno)
2. Inoltre, alla fine del ciclo i=arguments.length-1, controllerà l'ultimo elemento dell'array ed i+1è l'elemento "dopo" l'ultimo, che è undefined. In termini di relazioni logiche, si considera false, ma &&in tal caso produce il valore stesso, ed è per questo che la funzione ritorna undefinedcontinuamente (questo avrebbe potuto essere menzionato nella domanda).

Documenti

expr1 && expr2: Se expr1può essere convertito in true, ritorna expr2; altrimenti, ritorna 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));

e quindi puoi ottimizzarlo verso la risposta di Archie : il risultato di &&-ing items è truese tutti gli articoli lo sono true, e non devi eseguire una singola &&operazione per calcolare il risultato:

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

(Nei frammenti sopra ho mirato a produrre falseper un elenco di argomenti vuoto.)