由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),尾调用由于是函数的最后一步操作,所以不需要保留外层函数的调用记录,因为调用位置、内部变量等信息都不会再用到了,只要直接用内层函数的调用记录,取代外层函数的调用记录就可以了。

    由JavaScript堆栈溢出引出的函数式编程思想_第1张图片
    调用栈示意图

    故:

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

你可能感兴趣的:(由JavaScript堆栈溢出引出的函数式编程思想)