1
function A(a, b, c) {
2
  // do something
3
}

var _A = createCurry(A);

1
_A(1, 2, 3);
2
_A(1, 2)(3);
3
_A(1)(2, 3);
4
_A(1)(2)(3);
5
A(1, 2, 3);

1
function add(a, b, c) {
2
  return a + b + c;
3
}

1
function _add(a) {
2
  return function(b) {
3
    return function(c) {
4
      return a + b + c;
5
    }
6
  }
7
}

1
add(1, 2, 3);
2
_add(1)(2)(3);

10
function createCurry(func, ...args) {
20
  var wrapper = function(..._args) {
30
    // 如果参数个数小于最初的 func.length，则递归调用，继续收集参数
40
    if (args.length + _args.length < func.length) {
50
      // 合并参数，继续往下传递
60
      return createCurry(func, ...args, ..._args);
70
    }
80

90
    // 参数收集完毕，则执行func
10
    return func.apply(func, [...args, ..._args]);
11
  }
12

13
  return wrapper;
14
}

1
function checkPhone(phoneNumber) {
2
  return /^1[34578]\d{9}$/.test(phoneNumber);
3
}

1
function checkEmail(email) {
2
  return /^(\w)+(\.\w+)*@(\w)+((\.\w+)+)$/.test(email);
3
}

1
function check(reg, targetString) {
2
  return reg.test(targetString);
3
}

1
check(/^1[34578]\d{9}$/, '14900000088');
2
check(/^(\w)+(\.\w+)*@(\w)+((\.\w+)+)$/, 'test@163.com');

1
// 参数的处理方式不同
2
createCurry(check, /^1[34578]\d{9}$/, '183888888')
3
createCurry(check)(/^1[34578]\d{9}$/)('183888888')
4
createCurry(check)(/^1[34578]\d{9}$/, '183888888')

1
var _check = createCurry(check)
2

3
var checkPhone = _check(/^1[34578]\d{9}$/)
4
var checkEmail = _check(/^(\w)+(\.\w+)*@(\w)+((\.\w+)+)$/)

1
checkPhone('183888888');
2
checkEmail('xxxxx@test.com');

1
function getNewArray(array) {
2
  return array.map(function(item) {
3
    return item * 100 + '%'
4
  })
5
}
6

7
getNewArray([1, 2, 3, 0.12]);   // ['100%', '200%', '300%', '12%'];

1
function _map(func, array) {
2
  return array.map(func);
3
}
4

5
var _getNewArray = createCurry(_map);
6

7
var getNewArray = _getNewArray(function(item) {
8
  return item * 100 + '%'
9
})

1
// ['100%', '200%', '300%', '12%'];
2
getNewArray([1, 2, 3, 0.12]); 
3
 
4
// ['1%', '100%']
5
getNewArray([0.01, 1]);

10
// 封装过程
20
function _filter(func, array) {
30
  return array.filter(func);
40
}
50

60
// 我们可以分开写
70
var _find = createCurry(_filter);
80

90
// 也可以合起来写
10
var findNumber = createCurry(_filter)(function(item) {
11
  if (typeof item == 'number') {
12
    return item;
13
  }
14
})
15

1
findNumber([1, 2, 3, '2', '3', 4]);
2
 // [1, 2, 3, 4]

10
// 找出数字为10的倍数的子项
20
var find10 = _find(function(item) {
30
  if (item % 10 === 0) {
40
    return item;
50
  }
60
})
70

80
find10([1, 2, 3, 30, 20, 100]);
90
// [30, 20, 100]
10

11
// 找出数组中大于100的所有数据
12
var findGreater100 = _find(function(item) {
13
  if (item > 100) {
14
    return item;
15
  }
16
})
17

18
findGreater100([1, 2, 101, 300, 2, 122]); // [101, 300, 122]

1
// 实现一个add方法，使计算结果能够满足如下预期：
2
add(1)(2)(3) = 6;
3
add(1, 2, 3)(4) = 10;
4
add(1)(2)(3)(4)(5) = 15;

1
// 大家可以思考一下，如果将args数组的子项展开作为add的参数传入
2
function add(a, b, c, d) {
3
  return a + b + c + d;
4
}
5
var args = [1, 3, 100, 1];

add.apply(null, args);  // 105

add(...args);  // 105

1
function fn() { return 20 }
2
console.log(fn + 10);     // 输出结果 function fn() { return 20 }10

1
function fn() { return 20; }
2
fn.toString = function() { return 30 }
3

4
console.log(fn + 10); // 40

1
function fn() { return 20; }
2
fn.valueOf = function() { return 60 }
3

4
console.log(fn + 10); // 70

1
function fn() { return 20; }
2
fn.valueOf = function() { return 50 }
3
fn.toString = function() { return 30 }
4

5
console.log(fn + 10); // 60

10
function add() {
20
  // 定义一个数组专门用来存储所有的参数
30
  var _args = [].slice.call(arguments);
40

50
  var _adder = function() {
60
    // [].push.apply(_args, [].slice.call(arguments));
70
    _args.push(...arguments);
80
    return _adder;
90
  };
10

11
  // 利用隐式转换的特性，当最后执行时隐式转换，并计算最终的值返回
12
  _adder.toString = function () {
13
    return _args.reduce(function (a, b) {
14
      return a + b;
15
    });
16
  }
17

18
  return _adder;
19
}
20

21

22
var a = add(1)(2)(3)(4);   // f 10
23
var b = add(1, 2, 3, 4);   // f 10
24
var c = add(1, 2)(3, 4);   // f 10
25
var d = add(1, 2, 3)(4);   // f 10
26

27
// 可以利用隐式转换的特性参与计算
28
console.log(a + 10); // 20
29
console.log(b + 20); // 30
30
console.log(c + 30); // 40
31
console.log(d + 40); // 50
32

33
// 也可以继续传入参数，得到的结果再次利用隐式转换参与计算
34
console.log(a(10) + 100);  // 120
35
console.log(b(10) + 100);  // 120
36
console.log(c(10) + 100);  // 120
37
console.log(d(10) + 100);  // 120