Leetcode #Autoriser un appel de fonction

Étant donné une fonction fn, renvoie une nouvelle fonction identique à la fonction d'origine sauf qu'elle garantit que fn est appelée au plus une fois.

La première fois que la fonction renvoyée est appelée, elle devrait renvoyer le même résultat que fn.
Chaque fois qu'il est appelé par la suite, il devrait renvoyer undefined.

Exemple 1 :

Entrée :

fn = (a,b,c) => (a + b + c), appelle = [[1,2,3],[2,3,6]]

Sortie :

**Explanation:**

const onceFn = once(fn);
une foisFn(1, 2, 3); // 6
une foisFn(2, 3, 6); // non défini, fn n'a pas été appelé

**Example 2:**

**Input:**

 ```fn = (a,b,c) => (a * b * c), calls = [[5,7,4],[2,3,6],[4,6,8]]```


**Output:**

 ```[{"calls":1,"value":140}]```


**Explanation:**

const onceFn = once(fn);
une foisFn(5, 7, 4); // 140
une foisFn(2, 3, 6); // non défini, fn n'a pas été appelé
une foisFn(4, 6, 8); // non défini, fn n'a pas été appelé

**Constraints:**

`calls` is a valid JSON array

1 <= appels.longueur <= 10
1 <= appels[i].length <= 100
2 <= JSON.stringify(calls).length <= 1000

*Solution*

In this case, we are required to create a higher-order function(a function that returns another function) [Read more about high-order functions here](https://www.freecodecamp.org/news/higher-order-functions-explained/#:~:text=JavaScript%20offers%20a%20powerful%20feature,even%20return%20functions%20as%20results.)

We should make sure that the original function `fn` is only called once regardless of how many times the second function is called.

If the function fn has been not called, we should call the function `fn` with the provided arguments `args`. Else, we should return `undefined`


_Code solution_



``` sh
/**
 * @param {Function} fn
 * @return {Function}
 */
var once = function (fn) {
    // if function === called return undefined, 
    // else call fn with provide arguments
    let executed = false;
    let result;

    return function (...args) {
        if (!executed) {
            executed = true;
            result = fn(...args);
            return result;
        } else {
            return undefined;
        }
    }
};

/**
 * let fn = (a,b,c) => (a + b + c)
 * let onceFn = once(fn)
 *
 * onceFn(1,2,3); // 6
 * onceFn(2,3,6); // returns undefined without calling fn
 */






          

            
        
Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!