作者：安静

    1. function curry(fn) {
    2.   // 初始可以接收任意长度的参数
    3.   return function curried(...args) {
    4.     // 参数长度与fn参数对比
    5.     if (args.length < fn.length) {
    6.       // 如果初始传入的参数小于fn的参数，说明只传递了一部分参数
    7.       // 返回一个新函数接收剩余参数
    8.       return function() {
    9.         // 递归调用到参数传递完毕
    10.         return curried(...args.concat(Array.from(arguments)))
    11.       }
    12.     } 
    13.     // 说明参数传递完毕，直接执行fn函数
    14.     return fn.apply(this, args)
    15.   }
    16. }

    作者：xl

    1. function getType(data) {
    2.   let originType = Object.prototype.toString.call(data);
    3.   let index = originType.indexOf(' ');
    4.   let type = originType.slice(index + 1, -1);
    5.   return type.toLowerCase();
    6. }
    8. function currying(fn, ...args) {
    9.   const len = fn.length;
    10.   return function(...params) {
    11.     let _args = [...args, ...params];
    12.     if (_args.length < len) {
    13.       return currying.call(this, fn, ..._args)
    14.     }
    15.     return fn.apply(this, _args);
    16.   }
    17. }

    作者：奥兰度

    1. function  myTypeof(target) {
    2.   return Object.prototype.toString.call(target)
    3. }
    5. function curry(fn, ...args) {
    6.   if (typeof fn !== 'function') throw new Error()
    7.   let len = fn.length;
    8.   return function (...args1) {
    9.     if (args.length + args1.length >= len) {
    10.       return fn.call(this, ...args, ...args1)
    11.     } else {
    12.       return curry.call(this, fn, ...[...args, ...args1])
    13.     }
    14.   }
    15. }
    17. function add(a, b) {
    18.   return a + b
    19. }
    20. const add1 = curry(add, 1)
    21. add1(2) // 1 + 2