当前位置：首页 > 文章列表 > 文章 > 前端 > 函数 - JavaScript 挑战

函数 - JavaScript 挑战

来源：dev.to 2024-11-02 22:27:39 0浏览收藏

推广推荐

免费电影APP ➜

支持 PC / 移动端，安全直达

从现在开始，努力学习吧！本文《函数 - JavaScript 挑战》主要讲解了等等相关知识点，我会在golang学习网中持续更新相关的系列文章，欢迎大家关注并积极留言建议。下面就先一起来看一下本篇正文内容吧，希望能帮到你！

函数 - JavaScript 挑战

您可以在 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]