From bf8e099b9c8b3c60d60b3712b4fc97b052c39887 Mon Sep 17 00:00:00 2001 From: julieng Date: Tue, 3 Aug 2021 08:03:23 +0200 Subject: convert content to md --- .../global_objects/array/reduceright/index.md | 358 ++++++++++----------- 1 file changed, 171 insertions(+), 187 deletions(-) (limited to 'files/fr/web/javascript/reference/global_objects/array/reduceright') diff --git a/files/fr/web/javascript/reference/global_objects/array/reduceright/index.md b/files/fr/web/javascript/reference/global_objects/array/reduceright/index.md index 63222a2191..dbb7001bf8 100644 --- a/files/fr/web/javascript/reference/global_objects/array/reduceright/index.md +++ b/files/fr/web/javascript/reference/global_objects/array/reduceright/index.md @@ -11,199 +11,202 @@ tags: translation_of: Web/JavaScript/Reference/Global_Objects/Array/ReduceRight original_slug: Web/JavaScript/Reference/Objets_globaux/Array/reduceRight --- -
{{JSRef}}
+{{JSRef}} -

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.

+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. -
{{EmbedInteractiveExample("pages/js/array-reduce-right.html")}}
+{{EmbedInteractiveExample("pages/js/array-reduce-right.html")}} +Voir également {{jsxref("Array.prototype.reduce()")}} pour une méthode qui réduit de gauche à droite. +## Syntaxe -

Voir également {{jsxref("Array.prototype.reduce()")}} pour une méthode qui réduit de gauche à droite.

+ arr.reduceRight(callback[, valeurInitiale]) -

Syntaxe

+### Paramètres -
arr.reduceRight(callback[, valeurInitiale])
+- `callback` -

Paramètres

+ - : La fonction à éxécuter sur chaque valeur de la liste. Elle utilise quatres arguments : -
-
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 {{optional_inline}}
-
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 {{jsxref("TypeError")}}.
-
+ - `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. -

Valeur de retour

+- `valeurInitiale` {{optional_inline}} + - : 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 {{jsxref("TypeError")}}. -

La valeur obtenue grâce à la fonction de réduction.

+### Valeur de retour -

Description

+La valeur obtenue grâce à la fonction de réduction. -

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.

+## Description -

L'usage de reduceRight avec définition d'un callback devrait ressembler à ceci :

+`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. -
array.reduceRight(function(accumulator, valeurCourante, index, array) {
+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.

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

+Si on utilise la méthode `reduceRight` de la façon suivante : -
[0, 1, 2, 3, 4].reduceRight(function(accumulator, valeurCourante, index, array) {
+```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 :

+La fonction `callback` sera appelée quatre fois, avec les arguments et les valeurs de retour de chaque appel suivant : - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
callbackaccumulatorvaleurCouranteindexarrayValeur renvoyée
premier appel433[0,1,2,3,4]7
second appel722[0,1,2,3,4]9
troisième appel911[0,1,2,3,4]10
quatrième appel1000[0,1,2,3,4]10
callbackaccumulatorvaleurCouranteindexarrayValeur renvoyée
premier appel433[0,1,2,3,4]7
second appel722[0,1,2,3,4]9
troisième appel911[0,1,2,3,4]10
quatrième appel1000[0,1,2,3,4]10
-

La valeur retournée par reduceRight sera alors celle du dernier appel de la fonction callback (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 :

+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) {
+```js
+[0, 1, 2, 3, 4].reduceRight(function(accumulator, valeurCourante, index, array) {
     return accumulator + valeurCourante;
 }, 10);
-
+``` - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
accumulatorvaleurCouranteindexarrayValeur renvoyée
premier appel1044[0,1,2,3,4]14
second appel1433[0,1,2,3,4]17
troisième appel1722[0,1,2,3,4]19
quatrième appel1911[0,1,2,3,4]20
cinquième appel2000[0,1,2,3,4]20
accumulatorvaleurCouranteindexarrayValeur renvoyée
premier appel1044[0,1,2,3,4]14
second appel1433[0,1,2,3,4]17
troisième appel1722[0,1,2,3,4]19
quatrième appel1911[0,1,2,3,4]20
cinquième appel2000[0,1,2,3,4]20
-

La valeur renvoyée par reduceRight sera ici 20.

+La valeur renvoyée par `reduceRight` sera ici `20`. -

Exemples

+## Exemples -

Additionner toutes les valeurs d'une liste

+### Additionner toutes les valeurs d'une liste -
var total = [0, 1, 2, 3].reduceRight(function(a, b) {
+```js
+var total = [0, 1, 2, 3].reduceRight(function(a, b) {
     return a + b;
 });
 // total == 6
-
+``` -

Aplatir une liste de listes

+### Aplatir une liste de listes -
var aplati = [[0, 1], [2, 3], [4, 5]].reduceRight(function(a, b) {
+```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

+### Différence entre `reduce` et `reduceRight` -
var a = ['1', '2', '3', '4','5']
+```js
+var a = ['1', '2', '3', '4','5']
 var gauche = a.reduce(function(prev, cur) {
   return prev + cur;
 });
@@ -213,67 +216,48 @@ var droite = a.reduceRight(function(prev, cur) {
 });
 
 console.log(gauche); // "12345"
-console.log(droite); // "54321"
+console.log(droite); // "54321" +``` -

Composition de fonctions à l'aide de reduce

+### 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.

+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)
+const compose = (...args) => (value) => args.reduceRight((acc, fn) => fn(acc), value)
 
 // On incrémente un nombre passé en argument
-const inc = (n) => n + 1
+const inc = (n) => n + 1
 
 // On double la valeur passée en argument
-const double = (n) => n * 2
+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

- - - - - - - - - - - - - - - - - - - - - - - - -
SpécificationÉtatCommentaires
{{SpecName('ES5.1', '#sec-15.4.4.22', 'Array.prototype.reduceRight')}}{{Spec2('ES5.1')}}Définition initiale. Implémentée avec JavaScript 1.8.
{{SpecName('ES6', '#sec-array.prototype.reduceright', 'Array.prototype.reduceRight')}}{{Spec2('ES6')}}
{{SpecName('ESDraft', '#sec-array.prototype.reduceright', 'Array.prototype.reduceRight')}}{{Spec2('ESDraft')}}
+``` + +## Spécifications + +| Spécification | État | Commentaires | +| ------------------------------------------------------------------------------------------------------------------------ | ---------------------------- | ----------------------------------------------------- | +| {{SpecName('ES5.1', '#sec-15.4.4.22', 'Array.prototype.reduceRight')}} | {{Spec2('ES5.1')}} | Définition initiale. Implémentée avec JavaScript 1.8. | +| {{SpecName('ES6', '#sec-array.prototype.reduceright', 'Array.prototype.reduceRight')}} | {{Spec2('ES6')}} | | +| {{SpecName('ESDraft', '#sec-array.prototype.reduceright', 'Array.prototype.reduceRight')}} | {{Spec2('ESDraft')}} | | -

Compatibilité des navigateurs

+## Compatibilité des navigateurs -

{{Compat("javascript.builtins.Array.reduceRight")}}

+{{Compat("javascript.builtins.Array.reduceRight")}} -

Voir aussi

+## Voir aussi - +- {{jsxref("Array.prototype.reduce()")}} -- cgit v1.2.3-54-g00ecf