Array.prototype.reduceRight()
Baseline Widely available
This feature is well established and works across many devices and browser versions. It’s been available across browsers since July 2015.
La méthode reduceRight()
applique une fonction sur un accumulateur et chaque valeur d'un tableau (de la droite vers la gauche) de sorte à réduire le tableau en une seule valeur.
Exemple interactif
Voir également Array.prototype.reduce()
pour une méthode qui réduit de gauche à droite.
Syntaxe
arr.reduceRight(callback[, valeurInitiale])
Paramètres
callback
-
La fonction à éxécuter sur chaque valeur de la liste. Elle utilise quatres arguments :
accumulator
-
La valeur précédemment retournée par le dernier appel de la fonction
callback
, ouvaleurInitial
si elle est fournie. (Voir ci-après.) valeurCourante
-
La valeur de l'élément courant dans le tableau.
index
-
L'index de l'élément du tableau actuellement manipulé.
array
-
Le tableau sur lequel
reduceRight()
est appelée.
valeurInitiale
Facultatif-
C'est l'objet à utiliser comme accumulateur/premier argument lors du premier appel de la fonction
callback
. Si aucune valeur n'est fournie, c'est le dernier élément du tableau qui sera utilisé. Si on appellereduce()
oureduceRight()
sur un tableau vide sans fournir de valeur initiale, on aura une exceptionTypeError
.
Valeur de retour
La valeur obtenue grâce à la fonction de réduction.
Description
reduceRight
exécute la fonction callback
une fois pour chaque élément présent dans le tableau, les éléments vides sont ignorés. La fonction callback
utilise quatre arguments : la valeur initiale (ou la valeur retournée par le précédent appel de la fonction callback
), la valeur de l'élément courant, l'index de l'élément courant, et le tableau qui est parcouru.
L'usage de reduceRight
avec définition d'un callback
devrait ressembler à ceci :
array.reduceRight(function (accumulator, valeurCourante, index, array) {
// ...
});
La première fois que la fonction de callback est appelée, accumulator
et valeurCourante
peuvent correspondre à un ou deux éléments. Si valeurInitiale
est fournie lors de l'appel à reduceRight
, alors accumulator
sera égale à valeurInitiale
et valeurCourante
sera égale à la dernière valeur de la liste. Si valeurInitiale
n'est pas fournie, alors accumulator
sera égale à la dernière valeur de la liste, et valeurCourante
sera alors égale à l'avant-dernière valeur du tableau.
Si on utilise la méthode reduceRight
de la façon suivante :
[0, 1, 2, 3, 4].reduceRight(
function (accumulator, valeurCourante, index, array) {
return accumulator + valeurCourante;
},
);
La fonction callback
sera appelée quatre fois, avec les arguments et les valeurs de retour de chaque appel suivant :
callback |
accumulator |
valeurCourante |
index |
array |
Valeur renvoyée |
---|---|---|---|---|---|
premier appel | 4 | 3 | 3 | [0,1,2,3,4] |
7 |
second appel | 7 | 2 |
2 |
[0,1,2,3,4] |
9 |
troisième appel | 9 | 1 | 1 | [0,1,2,3,4] |
10 |
quatrième appel | 10 | 0 | 0 | [0,1,2,3,4] |
10 |
La valeur retournée par reduceRight
sera alors celle du dernier appel de la fonction callback
(10
).
Si vous fournissez une valeur initiale comme second argument à l'appel de reduceRight
, le résultat sera alors le suivant :
[0, 1, 2, 3, 4].reduceRight(function (
accumulator,
valeurCourante,
index,
array,
) {
return accumulator + valeurCourante;
}, 10);
accumulator |
valeurCourante |
index |
array |
Valeur renvoyée | |
---|---|---|---|---|---|
premier appel | 10 |
4 | 4 | [0,1,2,3,4] |
14 |
second appel | 14 | 3 | 3 | [0,1,2,3,4] |
17 |
troisième appel | 17 | 2 |
2 |
[0,1,2,3,4] |
19 |
quatrième appel | 19 | 1 | 1 | [0,1,2,3,4] |
20 |
cinquième appel | 20 | 0 | 0 | [0,1,2,3,4] |
20 |
La valeur renvoyée par reduceRight
sera ici 20
.
Exemples
Additionner toutes les valeurs d'une liste
var total = [0, 1, 2, 3].reduceRight(function (a, b) {
return a + b;
});
// total == 6
Aplatir une liste de listes
var aplati = [
[0, 1],
[2, 3],
[4, 5],
].reduceRight(function (a, b) {
return a.concat(b);
}, []);
// aplati [4, 5, 2, 3, 0, 1]
Différence entre reduce
et reduceRight
var a = ["1", "2", "3", "4", "5"];
var gauche = a.reduce(function (prev, cur) {
return prev + cur;
});
var droite = a.reduceRight(function (prev, cur) {
return prev + cur;
});
console.log(gauche); // "12345"
console.log(droite); // "54321"
Composition de fonctions à l'aide de reduce
La composition de fonctions consiste en l'enchaînement de n fonctions l'une après l'autre (où les appels sont généralement exécutés de droite à gauche.
/**
*
* h(x) = f(g(x))
*
* https://fr.wikipedia.org/wiki/Composition_de_fonctions
*/
const compose =
(...args) =>
(value) =>
args.reduceRight((acc, fn) => fn(acc), value);
// On incrémente un nombre passé en argument
const inc = (n) => n + 1;
// On double la valeur passée en argument
const double = (n) => n * 2;
// On compose double(inc(x))
compose(double, inc)(2); // 6
// On compose inc(double(x))
compose(inc, double)(2); // 5
Spécifications
Specification |
---|
ECMAScript Language Specification # sec-array.prototype.reduceright |
Compatibilité des navigateurs
BCD tables only load in the browser