Hoje, deixe-me apresentar esse método em detalhes, espero que seja útil para você. Este é o uso básico de reduzir: Reduzir é um método no objeto protótipo de array que nos ajuda a operar arrays. Leva outra função como argumento, que pode ser chamada de redutor. O redutor leva dois parâmetros. O primeiro parâmetro param1 é o resultado da última execução do redutor. Se esta for a primeira vez que o redutor é executado, o valor padrão de param1 é o valor do primeiro elemento da matriz. O método reduzir percorre cada elemento do array, assim como em um loop for. E passe o valor atual no loop como parâmetro 2. Depois de percorrer o array, reduzir retornará o resultado calculado pelo último redutor. Vejamos um exemplo detalhado. A seguir, vamos explorar como o código acima é executado. Neste código, o redutor é adicionado. Primeiro, como estamos executando add pela primeira vez, o primeiro elemento 'a' do array será tratado como o primeiro parâmetro de add e então o loop começará a partir do segundo elemento 'b' do array. Desta vez, 'b' é o segundo argumento a ser adicionado. Após o primeiro cálculo, obtemos o resultado 'ab'. Este resultado será armazenado em cache e usado como parâmetro1 no próximo cálculo de adição. Ao mesmo tempo, o terceiro parâmetro 'c' no array será usado como parâmetro2 de add. Da mesma forma, a redução continua pelos elementos do array, executando 'abc' e 'd' como argumentos a serem adicionados. Finalmente, após percorrer o último elemento do array, o resultado do cálculo é retornado. Agora temos o resultado: 'abcde'. Então, podemos ver que reduzir também é uma forma de percorrer um array! Ele pega o valor de cada elemento do array por vez e executa a função redutora. Mas podemos ver que o loop acima não possui aquela beleza harmoniosa. Porque pegamos o primeiro elemento do array, que é 'a', como o parâmetro1 inicial e, em seguida, percorremos o segundo elemento do array para obter o parâmetro2. Na verdade, podemos especificar o segundo parâmetro em reduzir como o valor inicial de param1 da função redutora, de modo que param2 será obtido em um loop começando no primeiro elemento do array. O código é o seguinte: Desta vez, primeiro chamamos o redutor com 's' como param1 e, em seguida, iteramos pelo array começando no primeiro elemento. Portanto, podemos reescrever nosso primeiro trecho de código usando esta sintaxe. A seguir, entraremos no capítulo de programação real para experimentar o poderoso poder da redução. O que você faria se quiséssemos obter a soma de todos os elementos de um array? De modo geral, você pode escrever algo assim: Claro, você pode ter outras maneiras de escrevê-lo, mas contanto que você use um loop for, o código se tornará redundante. Então vamos dar uma olhada no que a função de acumulação acima faz: Defina a soma inicial como zero Obtenha o primeiro elemento da matriz e some-o Armazene em cache o resultado da etapa anterior em soma Retire outros elementos da matriz e execute as operações acima retornar resultado final Podemos ver que quando descrevemos as etapas acima em palavras, é óbvio que está de acordo com o uso de reduzir. Portanto, podemos reescrever o código acima usando reduzir: Se você está acostumado a usar funções de seta, o código acima parecerá mais limpo: Uma linha de código e pronto! É claro que a multiplicação e a acumulação cumulativas são exatamente iguais: Muitas vezes, precisamos adicionar um peso na hora de somar, o que pode refletir melhor a elegância da redução. Se você deseja obter os valores máximo e mínimo de um array, você pode escrever: É o mesmo de antes, se usarmos reduzir podemos fazer isso em uma linha de código. Freqüentemente precisamos contar o número de ocorrências de cada elemento em um array. O método de redução nos ajuda a conseguir isso. Observe que usamos objetos de mapa em vez de objetos para armazenar frequências estatísticas, porque os elementos na matriz podem ser do tipo objeto e as chaves dos objetos podem ser apenas do tipo string ou símbolo. Aqui estão dois exemplos: Da mesma forma, se quiser contar a frequência de cada caractere em uma string, você pode primeiro converter a string em uma matriz de caracteres e, em seguida, seguir o método acima. Como os tipos de caracteres podem ser usados como chaves para objetos, não usaremos um Mapa aqui. Cada elemento do array é acessado sequencialmente por meio de redução. Se descobrirmos que o elemento ainda é um array, chamamos o método flat recursivamente.
Prefácio
var arr = [1, 2, 3];
função redutor(parmar1, parmar2){
}
arr.reduce(redutor) var arr = ['a', 'b', 'c', 'd', 'e'];
função adicionar(x, y) {
retornar x + y;
}
arr.reduce(adicionar)
var arr = ['a', 'b', 'c', 'd', 'e'];
função adicionar(x, y) {
retornar x + y;
}
arr.reduce(adicionar, 's')
var arr = ['a', 'b', 'c', 'd', 'e'];
função adicionar(x, y) {
retornar x + y;
}
arr.reduce(adicionar, '') 1. Acumulação e multiplicação cumulativa
acumulação de função (arr) {
seja soma = 0;
for (seja i = 0; i < arr.length; i++) {
soma = soma + arr[i];
}
soma de retorno;
} acumulação de função (arr) {
função redutor(x, y) {
retornar x + y
}
return arr.reduce(redutor, 0);
} acumulação de função (arr) {
retornar arr.reduce((x, y) => x + y, 0);
}
multiplicação de função (arr) {
retornar arr.reduce((x, y) => x * y, 1);
} pontuações constantes = [
{pontuação: 90, assunto: "HTML", peso: 0,2},
{pontuação: 95, assunto: "CSS", peso: 0,3 },
{pontuação: 85, assunto: "JavaScript", peso: 0,5 }
];
resultado const = pontuações.reduce((x, y) => x + y.score * y.weight, 0); 2. Obtenha os valores máximo e mínimo de um array
função max(arr){
deixe max = arr[0];
for (deixe ele de arr) {
if(ele > máximo) {
máximo = ele;
}
}
retorno máximo;
} seja arr = [3,24, 2,78, 999];
arr.reduce((x, y) => Math.max(x, y));
arr.reduce((x, y) => Math.min(x, y));
3. Calcule a frequência de ocorrência dos elementos do array
function contagemFrequência(arr) {
return arr.reduce(função(resultado, ele){
// Julga se este elemento foi contado antes
if (resultado.get(ele) != indefinido) {
/**
* Se este elemento já foi contado antes,
*aumentar a frequência de sua ocorrência em 1
*/
resultado.set(ele, resultado.get(ele) + 1)
} outro {
/**
* Se este elemento não tiver sido contado antes,
* defina a frequência de sua ocorrência para 1
*/
resultado.set(ele, 1);
}
resultado de retorno;
}, novo Mapa());
}
deixe str = 'olámundo';
split('').reduce((resultado, currentChar) => {
resultado[charAtual] ? resultado[CharAtual] ++ : resultado[CharAtual] = 1;
resultado de retorno;
}, {}) 
4. Achatamento de múltiplas matrizes
função Plana(arr = []) {
retornar arr.reduce((t, v) => t.concat(Array.isArray(v) ? Flat(v) : v), [])
} 