Array.prototype.reduceRight()
=============================

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
-------


```js
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`, ou `valeurInitial` 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 appelle `reduce()` ou `reduceRight()` sur un tableau vide sans fournir de valeur initiale, on aura une exception `TypeError`.

### 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 :


```js
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 :


```js
[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 :


```js
[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


```js
var total = [0, 1, 2, 3].reduceRight(function (a, b) {
  return a + b;
});
// total == 6
```

### Aplatir une liste de listes


```js
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`


```js
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.


```js
/\*\*
 \*
 \* 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 with JavaScript enabled. Enable JavaScript to view data.

Voir aussi
----------

* `Array.prototype.reduce()`