Y múltiples parámetros

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

Lo que espero es ejecutar este código: verdadero && verdadero && false && false y eso debería devolver falso .

¿Cómo hacer que eso funcione en js? Gracias

Use Array.prototype.everyen todos los argumentos pasados ​​para verificar si todos son verdaderos;

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

Necesitas

1. Comience con logicalAndestablecer entrue

2. Úselo logicalAndal actualizarlo, en lugar de utilizar dos entradas dearguments

El cambio mínimo es:

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

Pero la solución de mbojko tiene la ventaja de provocar un cortocircuito (detener el ciclo cuando encuentra por primera vez un valor falso), lo que parece una buena idea.

Dado que está utilizando ES2015 +, probablemente debería usar un parámetro rest en lugar de arguments, y puede usar un for-ofbucle:

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

También puede cortocircuitar eso de acuerdo con el enfoque de mbojko

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

Algunas personas podrían lanzarse reducea esto, pero la everysolución de Archie es mucho mejor. (Pero como su comparación no es estricta, simplemente lo haría .every(flag => flag)).

Los retornos tempranos deberían hacer que el código sea más eficiente y más corto:

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

  return true;
}

Creo que este es un camino muy corto usando ES6 Array.prototype.reduce

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

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

Para obtener más explicaciones sobre la función de reducción, lea MDN

Puede tomar Array#everyy devolver el último valor.

Este enfoque devuelve el resultado real de AND lógico&& .

Al utilizar el enfoque, se crea un cortocircuito para el primer valor falso encontrado. Entonces la iteración se detiene.

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

Quizás quieras escuchar qué salió mal con el bucle:

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

1. Este bucle almacena los &&dos últimos elementos que encuentra. En el caso ideal, reuniría &&los dos últimos elementos de la matriz (que ya no es lo que necesita)
2. además de eso al final del ciclo i=arguments.length-1, verificará el último elemento de la matriz, y i+1es el elemento "después" del último, que es undefined. En términos de relaciones lógicas, se considera false, pero &&produce el valor en sí mismo en ese caso, y es por eso que la función regresa undefinedtodo el tiempo (esto podría haber sido mencionado en la pregunta).

Docs

expr1 && expr2: Si expr1se puede convertir a true, devuelve expr2; De lo contrario, vuelve 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));

y luego puede optimizarlo hacia la respuesta de Archie : el resultado de &&-ing items es truesi todos los ítems son true, y no tiene que ejecutar una sola &&operación para calcular el resultado:

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

(En los fragmentos anteriores, pretendía producir falseuna lista de argumentos vacía).