说在前头

“一切皆对象”不知几何起已成为一种语言的楷模，一种对写法规范的标准，但其实各种语言依然有他们自身的精彩与美丽，更何况当今多数插件的底层，算法仍无法避免面向过程的书写（我们无法否认if else给我们带来的便捷），所以在面向对象化的今天，我仍要聊一聊过程化的极致以及写法的优化

TIPS：偏函数与柯里化的区别就不再概述

---

一、以往的柯里化执行

1、集中式处理

const test = a => {
  a++
  return b => {
    b++
    return c => {
      c++
      return call => call(a, b, c)
    }
  }
}
test(5)(6)(7)((a, b, c) => {
  console.log(a + b + c) // 统一结果处理
})
// 21
复制代码

在同步运算的调用中进行函数处理，达到作用域层层共享的结果，除了嵌套的瑕疵，函数的执行过程还是相当别致的，这儿可以用eval以及typeof ‘function’进行一个递归判断执行，避免层层嵌套，因为有其他更优的写法，我这儿就懒得写了。

---

2、分步式处理

const test = a => {
  a++
  return b => {
    b++
    return c => {
      c++
      return a + b + c // 统一结果处理
    }
  }
}
let call1 = test(5)
let call2 = call1(6)
let call3 = call2(7)
console.log(call3)
// 21
复制代码

这儿的优势在于，将函数传参部分进行return回调，从而外部控制函数的next执行，函数的独立性有一定的降低，便于随时的调用操纵，但业务耦合性有一定增高，需取舍。

---

二、如今的柯里化执行

ES6 出了一个Default Parameters，便于函数的默认传参，例如：

const test = (x = 1) => {
	console.log(x)
}
test()
// 1
test(2)
// 2
复制代码

然而该默认的参数竟可以支持函数的执行，那我们便可对其进行一些脑洞了。

废话不多说，直接上代码

const call1 = obj => { /* 函数抽离 */
  console.log('执行call1')
  return obj.val + 1
}
const call2 = obj => {
  console.log('执行call2')
  return obj.val + 2
}
const call3 = obj => {
  console.log('执行call3')
  return obj.val + 3
}
/* 这里还可以定义 call4， call5， call6...... */
/* 要用的即拿 */
((a = call1({
  val: 5 // 初次传参
}), b = call2({
  val: a // 这边也一样可以进行分布式传参，不必传上一个作用域的值
}), c = call3({
  val: b
})) => {
  console.log('统一结果处理：', a, b, c)
})()
复制代码

这样柯里化的调用就优化完成了。不光是把函数抽离，调用也没有难看的层层嵌套了，作用域也可从回调上进行数据共享，也可分布式传参，最后统一处理。真正意义上做到了即拿即用。

---

关于

make：o︻そ╆OVE▅▅▅▆▇◤（清一色天空）

blog：http://blog.csdn.net/mcky_love

掘金：https://juejin.im/user/59fbe6c66fb9a045186a159a/posts

---

结束语

以上针对的是同步过程处理，如要异步，还是建议链式调用之类的了，用callback处理柯里化，代码结构上还是相当头疼的。

以下是异步嵌套解决方案：

【库】Promise的简便实现，15行代码优雅解决异步嵌套

【库】Generator：8行代码优雅解决异步嵌套