您可以在 repo github 上找到这篇文章中的所有代码。
功能相关的挑战
参数和参数
/**
* @param {function} fn
* @return {number}
*/
function functionlength(fn) {
return fn.length;
}
// usage example
function myfunction(a, b, c) {
console.log(a, b, c);
}
console.log(functionlength(myfunction)); // => 3
/**
* @param {...any} args
* @return {number}
*/
function numofarguments(...args) {
// return args.length;
return arguments.length;
}
// usage example
console.log(numofarguments(1, 2, 3, 4, 5)); // => 5
console.log(numofarguments()); // => 0
撰写
/**
* @param {...functions} fns
* @return function
*/
function compose(...fns) {
return function (x) {
let result = x;
for (const fn of fns.reverse()) {
result = fn(result);
}
return result;
};
}
// usage example
const add1 = (num) => num + 1;
const double = (num) => num * 2;
const subtract10 = (num) => num - 10;
const composedfn = compose(subtract10, double, add1);
console.log(composedfn(3)); // (3 + 1) * 2 - 10 => -2
柯里化
/**
* @param {function} fn
* @return {function}
*/
function curry(fn) {
return function curried(...args) {
if (args.length >= fn.length) {
return fn.apply(this, args);
}
return curried.bind(this, ...args);
};
}
// usage example
// single parameter case
function add(a, b) {
return a + b;
}
const curriedadd = curry(add);
console.log(curriedadd(3)(4)); // => 7
const alreadyaddedthree = curriedadd(3);
console.log(alreadyaddedthree(4)); // => 7
// fixed parameters case
function addtwo(a, b) {
return a + b;
}
const curriedaddtwo = curry(addtwo);
console.log(curriedaddtwo(3, 4)); // => 7
console.log(curriedaddtwo(3)(4)); // => 7
const alreadyaddedthreeb = curriedadd(3);
console.log(alreadyaddedthreeb(4)); // => 7
//-------------------------------------------
/**
* @param {function} fn
* @return {function}
*/
function curry(fn) {
return function curried(...args) {
const bindfn = curried.bind(this, ...args);
bindfn[symbol.toprimitive] = () => fn.call(this, ...args);
return bindfn;
};
}
// usage example
// non-fixed parameters case
function multiply(...numbers) {
return numbers.reduce((a, b) => a * b, 1);
}
const curriedmultiply = curry(multiply);
const multiplybythree = curriedmultiply(3);
console.log(multiplybythree); // => 3
console.log(multiplybythree(4)); // => 12
const multiplybyfifteen = multiplybythree(5);
console.log(multiplybyfifteen); // => 15
console.log(multiplybyfifteen(2)); // => 30
console.log(curriedmultiply(1)(2)(3)(4)); // => 24
console.log(curriedmultiply(1, 2, 3, 4)); // => 24
备忘录
/**
* @param {function} func
* @return {function}
*/
function memoize(fn) {
const cache = new map();
return function (arg) {
if (cache.has(arg)) {
return cache.get(arg);
}
const result = fn.call(this, arg);
cache.set(arg, result);
return result;
};
}
// usage example
function expensivefunction(n) {
console.log("computing...");
return n * 2;
}
// create a memoized version of the function.
const memoizedexpensivefunction = memoize(expensivefunction);
// first call (computes and caches the result).
console.log(memoizedexpensivefunction(5)); // => computing... 10
// second call with the same argument (returns the cached result).
console.log(memoizedexpensivefunction(5)); // => 10
// third call with a different argument (computes and caches the new result).
console.log(memoizedexpensivefunction(10)); // => computing... 20
// fourth call with the same argument as the third call (returns the cached result).
console.log(memoizedexpensivefunction(10)); // => 20
// ----------------------------------------
// when parameters could be array
/**
* @param {function} fn
* @return {function}
*/
function memoize(fn) {
const cache = new map();
return function (...args) {
const key = json.stringify(args);
if (cache.has(key)) {
return cache.get(key);
}
const result = fn.call(this, ...args);
cache.set(key, result);
return result;
};
}
// usage example
function expensivemul(a, b) {
console.log("computing...");
return a * b;
}
// create a memoized version of the function.
const memoizedexpensivemul = memoize(expensivemul);
// first call (computes and caches the result).
console.log(memoizedexpensivemul(3, 7)); // => computing... 21
// second call with the same argument (returns the cached result).
console.log(memoizedexpensivemul(3, 7)); // => 21
// third call with a different argument (computes and caches the new result).
console.log(memoizedexpensivemul(5, 8)); // => computing... 40
// fourth call with the same argument as the third call (returns the cached result).
console.log(memoizedexpensivemul(5, 8)); // => 40
部分的
/**
* @param {Function} fn
* @param {any[]} args
* @returns {Function}
*/
function partial(fn, ...args) {
return function (...restArgs) {
const copyArgs = args.map((arg) => {
return arg === partial.placeholder ? restArgs.shift() : arg;
});
return fn.call(this, ...copyArgs, ...restArgs);
};
}
partial.placeholder = Symbol();
// Usage example
const func = (...args) => args;
const func123 = partial(func, 1, 2, 3);
console.log(func123(4)); // => [1, 2, 3, 4]
参考
- 伟大的前端
- 参数对象 - mdn
- 参数 - mdn
- 函数组合（计算机科学）- wikipedia.org
- 11。什么是构图？创建管道() - bfe.dev
- 1.实现 curry() - bfe.dev
- 2.实现带有占位符支持的 curry() - bfe.dev
- 柯里化 - wikipedia.org
- 14。实现通用记忆功能 - memo() - bfe.dev
- 122。实现 memoizeone() - bfe.dev
- 记忆 - wikipedia.org
- 部分应用 - wikipedia.org
- 139。实现 _.partial() - bfe.dev
