函数 - JavaScript 挑战

/**
 * @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]