o que é o equivalente a uma reduzir em javascript

votos
0

Eu sou um dev backend recentemente se mudou para o lado js. Eu estava passando por um tutorial e me deparei com a peça abaixo de código.

clickCreate: function(component, event, helper) {
    var validExpense = component.find('expenseform').reduce(function (validSoFar, inputCmp) {
        // Displays error messages for invalid fields
        inputCmp.showHelpMessageIfInvalid();
        return validSoFar && inputCmp.get('v.validity').valid;
    }, true);
    // If we pass error checking, do some real work
    if(validExpense){
        // Create the new expense
        var newExpense = component.get(v.newExpense);
        console.log(Create expense:  + JSON.stringify(newExpense));
        helper.createExpense(component, newExpense);
    }
}

Aqui eu tentei entender muito sobre o que está acontecendo, existe algo chamado reducee outra coisa chamada validSoFar. Eu sou incapaz de entender o que está acontecendo sob o capô. :-(

Eu faço obter os laços regulares stuff como foi feito no Java.

Alguém por favor pode tomar banho alguma luz sobre o que está acontecendo aqui. Eu deveria estar usando isso muito no meu trabalho regular.

obrigado

Publicado 19/09/2018 em 13:24
fonte usuário
Em outras línguas...                            


3 respostas

votos
0

Este é um equivalente razoável:

var validExpense = true;
var inputCmps = component.find('expenseform')
for (var i = 0; i < inputCmps.length; i++) {
    // Displays error messages for invalid fields
    inputCmp.showHelpMessageIfInvalid();
    if (!inputCmp.get('v.validity').valid) {
        validExpense = false;
    }
}
// Now we can use validExpense

Este é um uso um tanto estranha reduce, para ser honesto, porque ele faz mais do que simplesmente reduzir a lista para um único valor. É também produz efeitos colaterais (presumivelmente) na chamada para showHelpMessageIfInvalid().

A ideia de reduceé simples. Dada uma lista de valores que pretende dobrar para baixo um de cada vez em um único valor (do mesmo ou qualquer outro tipo), você fornece uma função que assume o valor dobrado atual eo próximo valor da lista e retorna um novo valor dobrado e você fornecer um valor inicial dobrada, e reducecombina-los chamando a função com cada valor da lista sucessiva eo valor dobrado atual.

Assim, por exemplo,

var items = [
  {name: 'foo', price: 7,  quantity: 3},
  {name: 'bar', price: 5,  quantity: 5},
  {name: 'baz', price: 19, quantity: 1}
]

const totalPrice = items.reduce(
  (total, item) => total + item.price * item.quantity, // folding function
  0  // initial value
); //=> 65
Respondeu 19/09/2018 em 13:45
fonte usuário

votos
0

Não faz sentido usar reduzir lá e ter efeitos colaterais no reduzir. Melhor usar Array.prototype.filter para obter todos os itens de despesas inválidas.

Em seguida, utilizar Array.prototype.forEach para produzir efeito secundário (s) para cada item inválido. Você pode, então, verificar o comprimento da série de itens de despesas inválido para vê-lo sua entrada era válido:

function(component, event, helper) {
  var invalidExpenses = component.find('expenseform').filter(
    function(ex){
      //return not valid (!valid)
      return !ex.get('v.validity').valid
    }
  );
  invalidExpenses.forEach(
    //use forEach if you need a side effect for each thing
    function(ex){
      ex.showHelpMessageIfInvalid();
    }
  );
  // If we pass error checking, do some real work
  if(invalidExpenses.length===0){//no invalid expense items
      // Create the new expense
      var newExpense = component.get("v.newExpense");
      console.log("Create expense: " + JSON.stringify(newExpense));
      helper.createExpense(component, newExpense);
  }
}

A documentação MDN para Array.prototype.reduce tem uma boa descrição e exemplos sobre como usá-lo.

Ele deve tomar uma série de coisas e voltar outra coisa (pode ser diferente tipo de coisa). Mas você não vai encontrar qualquer exemplos lá onde os efeitos colaterais são iniciados na função de redutor.

Respondeu 19/09/2018 em 13:42
fonte usuário

votos
0

A função de reduzir aqui é a iteração através de cada componente de entrada de forma a despesa e incrementalmente mapeando para um booleano. Se você tem dizer três entradas cada um com um verdadeiro validade, a reduzir a função retornaria:

  1. true && true onde o primeiro verdadeiro é o valor inicial passada para reduzir.
  2. true && true e onde o primeiro verdadeiro aqui é o resultado do resultado anterior.
  3. true && true

No final da redução, você é deixado com um único booleano representando a validade do todo, onde pela validade que, se apenas um único componente de entrada é falso, toda a redução será de falsa. Isso ocorre porque validSoFarmantém o controle da validade geral e está mutado, devolvendo o composto da se o formulário é válido até agora e a validade da entrada de corrente na iteração.

Respondeu 19/09/2018 em 13:38
fonte usuário

Cookies help us deliver our services. By using our services, you agree to our use of cookies. Learn more