JavaScript ES6 * Closure et conservation de valeur de paramètre [Résolu]

[scoch]

Bonjour,

j’essaie, sans succès, d’adapter avec des fonctions fléchées d’ES6 ce code qui permet de conserver une valeur de paramètre en référençant une fonction qui contient une fermeture (closure) :

Exemple qui fonctionne sans fonctions fléchées :

Code

function externe(x) {
   function interne(y) {
      return x + y;
   }
   return interne;
}

let resultat = externe(1)(3);
console.log(resultat); // affiche 4

// référencer la fonction externe avec une valeur en paramètre
// cette valeur est conservée
const fonctionInterne = externe(3);

// appel de la fonction externe avec passage de paramètre
// pour la fonction interne
resultat = fonctionInterne(5);
console.log(resultat); // affiche 8 (3 + 5)
resultat = fonctionInterne(4);
console.log(resultat); // affiche 7 (3 + 4)

Exemple qui ne fonctionne pas avec des fonctions fléchées :

Code

const externe = (x) => {
   const interne = (y) => {
      x + y;
   }
   interne;
}

const fonctionInterne = externe(3);

let resultat = fonctionInterne(5);
console.log(resultat); // TypeError: fonctionInterne is not a function

Edit : j’ai solutionné le problème qui semble venir du fait que, dans ce cas, le retour implicite de valeur ne fonctionne pas. J’ai donc utilisé explicitement return.

La solution :

Code

const externe = (x) => {
   const interne = (y) => {
      return x + y;
   }
   return interne;
}

Si vous avez une idée explication, je suis preneur !
Merci.

Ré édit : titre conforme à la charte

Ce message a été modifié par scoch - 19 Apr 2020, 23:52.

[Jaypee]

On peut ne pas nommer la fonction interne, mais effectivement les deux "return" sont obligatoires, et je n'ai rien lu qui l'explique :

Code

const externe = (x) => { return (y) => { return x + y } }

JP
PS : j'ai lu ceci : Pas de return implicite si les accolades sont utilisées. Donc soit on a { return expression }, soit on a expression seule...
La forme concise ultime est alors :

Code

const externe = (x) => (y) => x + y

Ce message a été modifié par Jaypee - 22 Apr 2020, 13:47.

[scoch]

Pas de return implicite si les accolades sont utilisées.

Exact ! Merci.

[scoch]

La forme concise ultime est alors :

Code

const externe = (x) => (y) => x + y

En cas de paramètre unique les parenthèses ne sont pas nécessaires. La forme concise ultime est donc

Code

const externe = x => y => x + y

[Jaypee]

Magnifique !

JP