由JavaScript堆栈溢出引出的函数式编程思想

〇、何为堆栈溢出？

每次执行JavaScript代码时，都会分配一定尺寸的栈空间（Windows系统中为1M），每次方法调用时都会在栈里储存一定信息（如参数、局部变量、返回值等等），这些信息再少也会占用一定空间，如果存在较多的此类空间，就会超过线程的栈空间了。
说白了就是就是不顾堆栈中分配的局部数据块大小，向该数据块写入了过多的数据，导致数据越界，结果覆盖了别的数据。

一、引起堆栈溢出的原因？

出现js堆栈溢出的问题一般的情况有两种：

1. 由于过多的函数调用，导致调用堆栈无法容纳这些调用的返回地址，一般在递归中产生。堆栈溢出很可能由无限递归（Infinite recursion）产生，但也可能仅仅是过多的堆栈层级。
2. 代码中引用了jQuery-1.4.2.min.js这个js实现一些动态效果或者是辅助，这个版本的jQuery就存在这样的问题，此时如果允许的话可以考虑更换jQuery引用版本。

二、如何解决堆栈溢出问题

解决方案：
1，引入闭包； 2，引入计时器； 3，尾调优化

---

使用闭包

• 错误代码

    function isEven(num){
       if(num == 0){return true;}
       if(num == 1){return false;}
       return isEven(Math.abs(num)-2);
   }
   console.log(isEven(100000))//堆栈溢出
  

• 引入闭包并优化

  function isEven(num){
      function isEvenInner(num){
          if(num === 0){return true;}
          if(num === 1){return false;}
          return function(){
          return isEvenInner(Math.abs(num)-2);
          }
      }
  
      function simplify(func,num){
          var value=func(num);
          while(typeof value == 'function'){
              value=value();
          }
          return value;
      }
  
      return simplify.bind(null,isEvenInner)(num)
  }
  
  console.log(isEven(100000));//这种方法num太大也不可以
  

---

调用计时器

---

Tail Call Optimize 使用尾调优化，可参考《尾调用优化 -阮一峰》

• 错误代码

  function factorial(n){
    if(n === 1) {return 1;}
      return n*factorial(n-1);
  }
  console.log(factorial(5))
  

• 使用尾递归（尾调用）

遗憾的是，大多数编程语言没有针对尾递归做优化，JavaScript解释器也没有做优化，所以，即使把上面的fact(n)函数改成尾递归方式，也会导致栈溢出。

  function tailFactorial(n, total) {
    if (n === 1) return total;
    return tailFactorial(n - 1, n * total);
  }
  console.log(tailFactorial(5,1))

• 尾调优化（新增简化函数）

  function tailFactorial(n, total) {
    if (n === 1) return total;
    return tailFactorial(n - 1, n * total);
  }
  console.log(tailFactorial(5,1))
  function factorial(n) {
    return tailFactorial(n, 1);
  }
  
  console.log(factorial(10000))
  

• 尾调优化（柯里化）

  function currying(fn,n){//柯里化要绑定的参数
      return function(m){//柯里化的函数，m对应输入的唯一一个参数
          return fn.call(this,m,n)  
  }//柯里化
  }
  var factorial_1=currying(tailFactorial,1);
  console.log(factorial_1(5));
  

• 尾调优化（ES6）

  function factorial(n, total = 1) {
    if (n === 1) return total;
    return factorial(n - 1, n * total);
  }
  
  factorial(5) // 120
  

三、深入理解（关于尾调用优化和柯里化）

写代码的优化有两个方向：1、提高程序性能，2、使代码模块化，减少其耦合性，增加可维护性。如果说尾调用优化是为了提高程序性能，那柯里化就是为了实现代码适用性。

尾调用

PS:ES6尾调用优化只能在严格模式下使用，详见尾调用优化 阮一峰

定义：某个函数的最后一步是调用另一个函数。

function f(x){
  return g(x);
}//尾调用
// 情况一 非尾调用
function f(x){
  let y = g(x);
  return y;
}

// 情况二 非尾调用
function f(x){
  return g(x) + 1;
}
//尾调用不一定出现在函数尾部，只要是最后一步操作即可。
    function f(x) {
  if (x > 0) {
    return m(x)
  }
  return n(x);
}

• 尾调用优化（Tail call optimization）
  如图所示，函数调用会在内存形成调用栈（call stack），尾调用由于是函数的最后一步操作，所以不需要保留外层函数的调用记录，因为调用位置、内部变量等信息都不会再用到了，只要直接用内层函数的调用记录，取代外层函数的调用记录就可以了。
  

  调用栈示意图
  故：

  function f() {
    let m = 1;
    let n = 2;
    return g(m + n);
  }
  f();
  
  // 等同于
  function f() {
    return g(3);
  }
  f();
  
  // 等同于
  g(3);
  

  优点：减小调用栈，节省内存使用。

• 尾递归
  定义：尾调用自身。
  "尾调用优化"对递归操作意义重大。ES6中第一次明确规定，所有 ECMAScript 的实现，都必须部署"尾调用优化"。这就是说，在 ES6 中，只要使用尾递归（在严格模式下），就不会发生栈溢出，相对节省内存
  实例代码见于上。

---

柯里化

定义：柯里化（Currying）是把接受多个参数的函数变换成接受一个单一参数(最初函数的第一个参数)的函数，并且返回接受余下的参数且返回结果的新函数的技术。

柯里化（Currying）是把接受多个参数的函数变换成接受一个单一参数(最初函数的第一个参数)的函数，并且返回接受余下的参数且返回结果的新函数的技术，在直觉上，柯里化声称“如果你固定某些参数，你将得到接受余下参数的一个函数”。