惰性函数

举例一个函数多次求值的写法,

函数内部改变自身的一种机制，函数内部重新写入这个函数；第一步获取时间值运行一次；

var getTimeStamp = function(){
 　　var timeStamp = new Date().getTime()
     getTimeStamp = function(){
       return timeStamp
   }
   return timeStamp
} 

getTimeStamp()

getTimeStamp()

// 改写

var getTimeStamp = function(){
 　　var timeStamp = new Date().getTime()
     getTimeStamp = function(){
       return timeStamp
   }
   return timeStamp() // 这里直接调用
} 

 官方定义：

函数执行的分支只会在第一次调用的时候执行，

在第一次调用的过程中，该函数被覆盖为另一个按照合适方式执行的函数

这样，任何对原函数的调用就不用经过该分支了；

 

使用场景：

例如事件兼容性

不能使用惰性函数

var addEvent = (function (el, type, fn, capture) {
  if (window.addEventListener) {
    return function (type, fn, capture) {
      el.addEventListener(type, fn, capture)
    }
  } else if (window.attachEvent) {
    return function (type, fn, capture) {
      el.attachEvent('on' + type, function () {
        fn.call(el)
      })
    }
  } else {
    return function (el, type, fn) {
      el['on' + type] = fn
    }
  }
})()

使用惰性函数

var addEvent = function (el, type, fn, capture) {
  if (el.addEventListener) {
    addEvent = function (el, type, fn, capture) {
      el.addEventListener(type, fn, capture)
    }
  } else if (el.attachEvent) {
    addEvent = function (el, type, fn) {
      el.attachEvent('on' + type, function () {
        fn.call(el)
      })
    }
  } else {
    addEvent = function (el, type, fn) {
      el['on' + type] = fn
    }
  }
  addEvent(el, type, fn, capture)
}

执行的时候会改变自身，执行1之后不会改变，如下例子

    function test (num) {
      switch (num) {
        case 1:
          test = function () {
            console.log('黑弗雷')
          }
          break;
        case 2:
          test = function () {
            console.log('i love u')
          }
          break;
        case 3:
          test = function () {
            console.log('我爱你')
          }
          break;

      }
      return test() // 最后异步返回执行这个函数
    }

    // test(1)
    test(2)