Leetcode #Allow One Function Call

Memandangkan fungsi fn, kembalikan fungsi baharu yang sama dengan fungsi asal kecuali ia memastikan fn dipanggil paling banyak sekali.

Kali pertama fungsi yang dikembalikan dipanggil, ia sepatutnya mengembalikan hasil yang sama seperti fn.
Setiap kali ia dipanggil, ia akan kembali tidak ditentukan.

Contoh 1:

Input:

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

Output:

**Explanation:**

konst sekaliFn = sekali(fn);
onceFn(1, 2, 3); // 6
sekaliFn(2, 3, 6); // undefined, fn tidak dipanggil

**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:**

konst sekaliFn = sekali(fn);
sekaliFn(5, 7, 4); // 140
onceFn(2, 3, 6); // undefined, fn tidak dipanggil
sekaliFn(4, 6, 8); // undefined, fn tidak dipanggil

**Constraints:**

`calls` is a valid JSON array

1 <= panggilan.panjang <= 10
1 <= panggilan[i].panjang <= 100
2 <= JSON.stringify(panggilan).panjang <= 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
 */






          

            
        
Atas ialah kandungan terperinci Leetcode #Allow One Function Call. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!