Comment puis-je convertir cette fonction fléchée en fonction standard?

Vous pouvez utiliser https://babeljs.io/ pour compiler de ce nouveau javscript vers un "ancien" javascript . Vous pouvez l'essayer directement sur sa page d'accueil.

Voici le résultat qu'il donne:

var isValid = function isValid(arr, arr2) {
  var sum = function sum(array, n) {
    return array.reduce(function (a, an) {
      return a + (an === n);
    }, 0);
  };

  return !arr2.some(function (n) {
    return !arr.some(function (an) {
      return an === n && sum(arr, an) === sum(arr2, n);
    });
  });
};

Votre hypothèse est correcte pour la fonction externe. La première ligne à l'intérieur deviendrait:

let foo = single_arg => alert(1);
let foo2 = (arg1, arg2) => alert(2);

Découvrez les fonctions fléchées et en quoi elles diffèrent des déclarations de fonctions conventionnelles. Pour la plupart (mais pas complètement), ce ne sont que des fonctions syntaxiques par rapport aux fonctions conventionnelles.

Elles diffèrent le plus nettement en termes de contexte, c'est-à-dire ce que ceci indique à l'intérieur du corps de la fonction . Les fonctions fléchées s'exécutent toujours dans le contexte externe prédominant dans lequel la fonction a été déclarée. Fonctions conventionnelles, par ex. via bind () , peut être rejoint dans un contexte différent.

    let sum = (array, n) => array.reduce((a, an) => a + (an === n), 0);  

Alors que diriez-vous de ce sucre? Cela peut sembler déroutant au début, surtout lorsque vous avez plusieurs fonctions fléchées sur une seule ligne. Une chose clé à retenir est qu'il s'agit simplement de raccourcis implicites pour les choses que vous deviez coder manuellement.

let foo3 = a => {
    return a+1;
};

Est la même chose que

foo(1); //2

(Le levage sera différent, mais c'est un peu au-delà de la portée de cette réponse.)

Une chose que nous pouvons dire de ce qui précède est que, où la partie après => est une seule déclaration, il est interprété comme une valeur de retour, sans que nous ayons à écrire return .

function foo2(a) { return a + 1; }

C'est parfait pour les fonctions simples qui font un travail exprimable en un ligne de code. Si vous avez besoin de fonctions plus détaillées, insérez le code dans {} comme d'habitude.

let foo = a => a+1;

Cela fonctionne à nouveau de la même manière que le foo code> et foo2 ci-dessus.

Et donc, enfin, décomposer cette ligne effrayante:

let foo = function() {
    let bar = () => this;
    return bar();
}.bind('a');
foo(); //'a', because foo()'s context is 'a'

Il dit:

• attribuer une fonction à la variable de portée locale sum
• il accepte deux arguments, array et n
• il a un travail à faire, exprimable comme une seule ligne de code et donc pas besoin de lier { et } pour le corps de la fonction. Ce travail consiste à appeler reduction () et à renvoyer (implicitement) la valeur
• Le premier argument pour réduire , le rappel, accepte deux arguments, a et an
• Ce rappel, comme celui à réduire , n’a qu’une tâche à faire, et cette tâche consiste à renvoyer la valeur de a + (an === n) code>

Un dernier mot sur le sucre, que vous avez peut-être repéré ci-dessus, est que, avec les fonctions fléchées, si un seul argument est accepté, vous n'avez pas besoin de le mettre entre crochets. Cependant, plusieurs arguments sont séparés par des virgules, comme d'habitude.

function sum(array, n) {
    return array.reduce(function(a, an) {
        return a + (an === n);
    }, 0);

J'espère que cela vous aidera.