E vários 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));

O que eu estou esperando é executar este código: true && true && false && false e isso deve retornar false .

Como fazer isso funcionar em js? obrigado

Use Array.prototype.everyem todos os argumentos passados ​​para verificar se todos são verdadeiros;

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

Você precisa

1. Comece com logicalAnddefinido comotrue

2. Use logicalAndao atualizá-lo, em vez de usar duas entradas dearguments

A mudança mínima é:

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

Mas a solução da mbojko tem a vantagem de causar um curto-circuito (interromper o ciclo quando encontrar um valor falso), o que parece uma boa ideia.

Como você está usando o ES2015 +, você provavelmente deve usar um parâmetro rest em vez de argumentse pode usar um 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));

Você também pode causar um curto-circuito, de acordo com a abordagem da mbojko

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

Algumas pessoas podem pensar reducenisso, mas a everysolução de Archie é muito melhor. (Mas, como sua comparação não é rigorosa, é só fazê-lo .every(flag => flag).)

Os retornos antecipados devem tornar o código mais eficiente e mais curto:

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

  return true;
}

Eu acho que essa é uma maneira muito curta de usar o ES6 Array.prototype.reduce

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

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

Para mais explicações sobre a função de redução, leia MDN

Você pode pegar Array#everye retornar o último valor.

Essa abordagem retorna o resultado real do AND lógico&& .

Usando a abordagem, é feito um curto-circuito para o primeiro valor encontrado de falsidade. Então a iteração pára.

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

Talvez você queira ouvir o que deu errado com o loop:

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

1. esse loop armazena os &&dois últimos itens que encontra. No caso ideal, reuniria &&os dois últimos elementos da matriz (que já não é o que você precisa)
2. além disso, no final do loop i=arguments.length-1, ele verifica o último elemento da matriz e i+1é o elemento "depois" do último, que é undefined. Em termos de relações lógicas, é considerado false, mas &&produz o valor em si mesmo, e é por isso que a função retorna undefinedo tempo todo (isso poderia ter sido mencionado na pergunta).

Documentos

expr1 && expr2: Se expr1pode ser convertido em true, retorna expr2; mais, retorna 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, em seguida, você pode otimizá-lo para a resposta de Archie : o resultado de &&itens -ing é truese todos os itens forem truee você não precisa executar uma única &&operação para calcular o 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));

(Nos trechos acima, pretendi produzir falsepara uma lista de argumentos vazia.)