La méthode .reduce() ci-dessous, tirée de cette réponse SO contient de nombreux paramètres (apparemment appelés objets destructurants ).

Quelle fonctionnalité ces paramètres représentent-ils?

let {result} = array.reduce(({arg_1, arg_2, arg_3}, arg_4)=> {
}, {result: [], arg_2: 0, arg_3: undefined})
return result
0
Fellow Stranger 9 août 2016 à 11:30

3 réponses

Meilleure réponse

Array.reduce prend 2 paramètres,

  1. rappeler
  2. valeur initiale

Array.reduce callback obtient 4 paramètres:

  1. previousValue
  2. valeur actuelle
  3. currentIndex
  4. tableau

La valeur de previousValue est initialValue au début de la boucle. Si aucune valeur n'est transmise, le premier élément est considéré comme previousValue et currentValue aura la valeur suivante . À partir d'eux, previousValue contiendra la valeur retournée dans l'itération précédente.

Échantillon

Aucune valeur initiale

var a = [1,2,4,4,5,6,7,8];

a.reduce(function(p,c,i,a){
  console.log(p,c,i,a);
  return c
})

Avec valeur initiale

var a = [1,2,4,4,5,6,7,8];

a.reduce(function(p,c,i,a){
  console.log(p,c,i,a);
  return c
},0)

Référence

Array.reduce

1
Rajesh 9 août 2016 à 08:46

La méthode réduire accepte deux arguments.

Syntaxe:

arr.reduce (rappel [, initialValue])

Ainsi, dans votre exemple, le rappel est utilisé comme premier argument est la fonction flèche. Brisons-le:

1. ({arg_1, arg_2, arg_3}, arg_4)=> {}  //the callback
2. {arg_1: [], arg_2: 0, arg_3: undefined} // the initial value

Et ({arg_1, arg_2, arg_3}, arg_4) possède deux arguments pour la fonction flèche, le premier est déclaré comme objet.

Vous pouvez remarquer que la valeur initiale de arg_4 est manquante.

2
Bhojendra Rauniyar 9 août 2016 à 09:05

Dans le cas où OP trébuche sur la notation destructurante, pour l'exemple donné, le premier paramètre est la valeur initiale (décrite avec le liens fournis des deux premiers commentaires), fonctionnant comme un objet collecteur ou accumulateur. Il est composé des trois premiers arguments d'une autre méthode. Le résultat est écrit par une affectation destructurante, donc, il y aura 3 variables, arg_1, arg_2 et arg_3 dérivées des arguments également nommés de l'objet collecteur finalement retourné.

modifier, car l'exemple de code fourni par l'OP a changé ...

L'exemple suivant prend en compte la référence du code SO lié à l'OP ...

let {slots} = array.reduce(({slots, count, prev}, item)=> {

    // ... do something with slots
    // ...
    // while iterating always needs to return
    // an equally structured collector object

    return {slots, count: count + 1, prev: item}

}, {slots: [], count: 0, prev: undefined})

/*
return slots; // does not really make sense within this shortened example's context.
*/

... est égal à ...

var slots = array.reduce(function (collector, item) {

    var
        slots = collector.slots,
        count = collector.count,
        prev  = collector.prev;

    // ... do something with slots
    // ...
    // while iterating always needs to return
    // an equally structured collector object

    return {slots: slots, count: count + 1, prev: item};

}, {slots: [], count: 0, prev: undefined}).slots;
2
Fellow Stranger 9 août 2016 à 14:25