Aujourd'hui, permettez-moi de vous présenter cette méthode en détail, j'espère qu'elle vous sera utile. C'est l'utilisation de base de réduire : Réduire est une méthode sur l'objet prototype de tableau qui nous aide à faire fonctionner les tableaux. Il prend une autre fonction comme argument, que l’on peut appeler un réducteur. le réducteur prend deux paramètres. Le premier paramètre param1 est le résultat de la dernière exécution du réducteur. Si c'est la première fois que le réducteur est exécuté, la valeur par défaut de param1 est la valeur du premier élément du tableau. La méthode de réduction parcourt chaque élément du tableau, tout comme dans une boucle for. Et passez la valeur actuelle dans la boucle comme paramètre 2. Après avoir parcouru le tableau, réduire renverra le résultat calculé par le dernier réducteur. Regardons un exemple détaillé. Voyons ensuite comment le code ci-dessus est exécuté. Dans ce code, un réducteur est ajouté. Premièrement, comme nous exécutons add pour la première fois, le premier élément « a » du tableau sera traité comme le premier paramètre de add, puis la boucle commencera à partir du deuxième élément « b » du tableau. Cette fois, « b » est le deuxième argument à ajouter. Après le premier calcul, nous obtenons le résultat 'ab'. Ce résultat sera mis en cache et utilisé comme param1 dans le prochain calcul d'addition. Dans le même temps, le troisième paramètre 'c' du tableau sera utilisé comme param2 de add. De même, la réduction continue à travers les éléments du tableau, en exécutant « abc » et « d » comme arguments à ajouter. Enfin, après avoir parcouru le dernier élément du tableau, le résultat du calcul est renvoyé. Nous avons maintenant le résultat : 'abcde'. Ainsi, nous pouvons voir que réduire est aussi un moyen de parcourir un tableau ! Il prend tour à tour la valeur de chaque élément du tableau et exécute la fonction de réduction. Mais nous pouvons voir que la boucle ci-dessus n’a pas cette beauté harmonieuse. Parce que nous prenons le premier élément du tableau, qui est « a », comme paramètre initial1, puis parcourons le deuxième élément du tableau pour obtenir param2. En fait, on peut spécifier le deuxième paramètre de réduire comme valeur initiale de param1 de la fonction réducteur, de sorte que param2 sera obtenu dans une boucle à partir du premier élément du tableau. Le code est le suivant : Cette fois, nous appelons d'abord le réducteur avec « s » comme param1, puis parcourons le tableau en commençant par le premier élément. Nous pouvons donc réécrire notre premier extrait de code en utilisant cette syntaxe. Ensuite, nous entrerons dans le chapitre de programmation proprement dit pour découvrir le puissant pouvoir de la réduction. Que feriez-vous si nous voulions obtenir la somme de tous les éléments d’un tableau ? D'une manière générale, vous pourriez écrire quelque chose comme ceci : Bien sûr, vous pouvez avoir d’autres façons de l’écrire, mais tant que vous utilisez une boucle for, le code deviendra redondant. Voyons ensuite ce que fait la fonction d’accumulation ci-dessus : Mettre la somme initiale à zéro Récupère le premier élément du tableau et additionne-le Mettre en cache le résultat de l'étape précédente en somme Supprimez tour à tour les autres éléments du tableau et effectuez les opérations ci-dessus renvoyer le résultat final Nous pouvons voir que lorsque nous décrivons les étapes ci-dessus avec des mots, il est évident que cela est conforme à l'utilisation de réduire. Nous pouvons donc réécrire le code ci-dessus en utilisant réduire : Si vous avez l'habitude d'utiliser les fonctions fléchées, le code ci-dessus aura l'air plus clair : Une ligne de code et c'est fait ! Bien entendu, la multiplication et l’accumulation cumulatives sont exactement les mêmes : Plusieurs fois, nous devons ajouter un poids lors de la sommation, ce qui peut mieux refléter l'élégance de la réduction. Si vous souhaitez obtenir les valeurs maximales et minimales d'un tableau, vous pouvez écrire : C'est la même chose qu'avant, si nous utilisons réduire, nous pouvons le faire en une seule ligne de code. Nous devons souvent compter le nombre d’occurrences de chaque élément d’un tableau. La méthode de réduction nous aide à y parvenir. Notez que nous utilisons des objets cartographiques au lieu d'objets pour stocker des fréquences statistiques, car les éléments du tableau peuvent être de type objet et les clés des objets ne peuvent être que de type chaîne ou symbole. Voici deux exemples : De même, si vous souhaitez compter la fréquence de chaque caractère dans une chaîne, vous pouvez d'abord convertir la chaîne en tableau de caractères, puis suivre la méthode ci-dessus. Étant donné que les types de caractères peuvent être utilisés comme clés pour les objets, nous n'utiliserons pas de Map ici. Chaque élément du tableau est accessible séquentiellement via réduire. Si nous constatons que l’élément est toujours un tableau, nous appelons la méthode flat de manière récursive.
Préface
vararr = [1, 2, 3];
réducteur de fonction (parmar1, parmar2){
}
arr.reduce(réducteur) var arr = ['a', 'b', 'c', 'd', 'e'];
fonction ajouter (x, y) {
renvoyer x + y ;
}
arr.réduire(ajouter)
var arr = ['a', 'b', 'c', 'd', 'e'];
fonction ajouter (x, y) {
renvoyer x + y ;
}
arr.reduce(ajouter, 's')
var arr = ['a', 'b', 'c', 'd', 'e'];
fonction ajouter (x, y) {
renvoyer x + y ;
}
arr.réduire(ajouter, '') 1. Accumulation et multiplication cumulative
fonction accumulation(arr) {
soit somme = 0 ;
pour (soit i = 0; i < arr.length; i++) {
somme = somme + arr[i];
}
retourner la somme ;
} fonction accumulation(arr) {
réducteur de fonction (x, y) {
retourner x + y
}
return arr.reduce(réducteur, 0);
} fonction accumulation(arr) {
return arr.reduce((x, y) => x + y, 0);
}
fonction multiplication(arr) {
return arr.reduce((x, y) => x * y, 1);
} scores const = [
{ score : 90, sujet : "HTML", poids : 0,2 },
{ score : 95, sujet : "CSS", poids : 0,3 },
{ score : 85, sujet : "JavaScript", poids : 0,5 }
];
résultat const = scores.reduce((x, y) => x + y.score * y.weight, 0 // 89); 2. Obtenez les valeurs maximales et minimales d'un tableau
fonction max(arr){
laissez max = arr[0];
pour (laisser ele de arr) {
si (ele > max) {
max = élé ;
}
}
renvoyer maximum ;
} soit arr = [3,24, 2,78, 999] ;
arr.reduce((x, y) => Math.max(x, y));
arr.reduce((x, y) => Math.min(x, y));
3. Calculer la fréquence d'apparition des éléments dans le tableau
fonction nombreFréquence(arr) {
return arr.reduce(function(result, ele){
// Juge si cet élément a déjà été compté
if (result.get(ele) != non défini) {
/**
* Si cet élément a déjà été compté,
* augmenter la fréquence de son apparition de 1
*/
result.set(ele, result.get(ele) + 1)
} autre {
/**
* Si cet élément n'a pas été compté auparavant,
* définir la fréquence de son apparition sur 1
*/
result.set(ele, 1);
}
renvoyer le résultat ;
}, nouvelle carte());
}
let str = 'helloworld';
str.split('').reduce((result, currentChar) => {
résultat[currentChar] ? résultat[currentChar] ++ : résultat[currentChar] = 1;
renvoyer le résultat ;
}, {}) 
4. Aplatissement de plusieurs tableaux
fonction Plat(arr = []) {
return arr.reduce((t, v) => t.concat(Array.isArray(v) ? Flat(v) : v), [])
} 