Array.prototype.reduceRight()

BaselineWidely 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éthodereduceRight() 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

const array1 = [  [0, 1],  [2, 3],  [4, 5],];const result = array1.reduceRight((accumulator, currentValue) =>  accumulator.concat(currentValue),);console.log(result);// Expected output: Array [4, 5, 2, 3, 0, 1]

Voir égalementArray.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 fonctioncallback, 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 lequelreduceRight() est appelée.

valeurInitialeFacultatif

C'est l'objet à utiliser comme accumulateur/premier argument lors du premier appel de la fonctioncallback. 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 fonctioncallback une fois pour chaque élément présent dans le tableau, les éléments vides sont ignorés. La fonctioncallback utilise quatre arguments : la valeur initiale (ou la valeur retournée par le précédent appel de la fonctioncallback), la valeur de l'élément courant, l'index de l'élément courant, et le tableau qui est parcouru.

L'usage dereduceRight avec définition d'uncallback devrait ressembler à ceci :

array.reduceRight(function (accumulator, valeurCourante, index, array) {  // ...});

La première fois que la fonction de callback est appelée,accumulator etvaleurCourante peuvent correspondre à un ou deux éléments. SivaleurInitiale est fournie lors de l'appel àreduceRight, alorsaccumulator sera égale àvaleurInitiale etvaleurCourante sera égale à la dernière valeur de la liste. SivaleurInitiale n'est pas fournie, alorsaccumulator sera égale à la dernière valeur de la liste, etvaleurCourante sera alors égale à l'avant-dernière valeur du tableau.

Si on utilise la méthodereduceRight de la façon suivante :

[0, 1, 2, 3, 4].reduceRight(  function (accumulator, valeurCourante, index, array) {    return accumulator + valeurCourante;  },);

La fonctioncallback 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 parreduceRight sera alors celle du dernier appel de la fonctioncallback (10).

Si vous fournissez une valeur initiale comme second argument à l'appel dereduceRight, 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 parreduceRight sera ici20.

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 argumentconst inc = (n) => n + 1;// On double la valeur passée en argumentconst double = (n) => n * 2;// On compose double(inc(x))compose(double, inc)(2); // 6// On compose inc(double(x))compose(inc, double)(2); // 5