Comment compiler plusieurs fonctions dans la chaîne de fonction en Javascript?

voix
0

Je veux être en mesure de fournir une fonction de compilation (pour un framework web je travaille) dans une « chaîne de fonction » comme on le voit dans la plupart des cadres web. Quelle est la manière la plus simple de faire ça? Disons que j'ai une liste de fonctions:

const middleware = [
function(data, next){
    console.log(data); 
    next()
},
function(data, next) {
   return;
}, function(data, next) { }];

Dans le cas ci - dessus, le comportement idéal serait pour la première fonction de déclenchement, le passé en paramètre nextpour déclencher la fonction suivante, puis la chaîne à la fin en raison de la returndéclaration. Comment pourrais - je compiler ce à une fonction?

Créé 13/01/2020 à 21:52
source utilisateur
Dans d'autres langues...                            


3 réponses

voix
0

pas à 100% sur cela, mais je crois que si vous créez une variable pour le produit fini après la première fonction, vous pouvez alors appliquer la 2ème fonction et passer de la première à la deuxième fonction

Créé 13/01/2020 à 21:58
source utilisateur

voix
0

Vous pouvez simplement réduire la gamme de fonctions:

functionList.reduce((output, fn) => fn(output), undefined);

Cela les exécuter dans l'ordre, en passant le résultat de l'appel précédent en tant que paramètre à l'appel suivant, se terminant en fin de compte le résultat final du dernier appel de fonction.

À titre d'exemple, si vous faites cela avec ce que votre functionList:

[
  () => 4,
  n => n+5,
  n => `$${n}`,
  amt => amt + '.00'
]

Le résultat sera $9.00

Créé 13/01/2020 à 22:10
source utilisateur

voix
0

Ok, je l'ai trouvé une réponse - vous pouvez utiliser le code suivant, je me suis adapté de koa-Compose. Pour compiler la chaîne middleware vous pouvez utiliser la fonction suivante:

function compiler(middleware) {
  // return function to execute compiled middleware chain
  return function(data, next) {
    // set pointer to 0 to match middleware index to track if next()
    // is called twice in one middleware
    let pointer = 0;
    function dispatch(i) {
      // check if pointer is larger than i, indicating next() was called more than once
      if (i < pointer)
        return Promise.reject(
          new Error("next() called multiple times in one middleware function.")
        );
      // set pointer to next index
      pointer = i + 1;
      // grab current function
      let fn = middleware[i];
      // if out of middleware, assign the next function from the parameters to be executed next
      if (i === middleware.length) fn = next;
      // if no function (out of middleware and no provided parameter), end middleware execution
      if (!fn) return Promise.resolve();
      try {
        // run next function, binding the second parameter to the next middleware in the chain
        return Promise.resolve(fn(data, dispatch.bind(null, i + 1)));
      } catch (err) {
        return Promise.reject(err);
      }
    }
    // start function on first middleware
    return dispatch(0);
  };
};

Vous pouvez compiler les fonctions middleware et l'exécuter comme ce qui suit:

const funcs = [
     function(data, next){
          console.log(data); next();
     }, function(data, next){
        console.log('done');
     }];
const compiled = compiler(funcs);

// execute compiled middleware chain
compiled();
Créé 15/01/2020 à 17:43
source utilisateur

Cookies help us deliver our services. By using our services, you agree to our use of cookies. Learn more