数组扁平化，柯里化，防抖，节流，对象拷贝

数组扁平化：使用递归实现

function flattenDepth(array, depth=1) {
          let result = [];
          array.forEach (item => {
            let d = depth;
            if(Array.isArray(item) && d > 0){
              result.push(...(flattenDepth(item, --d)))
            } else {
              result.push(item);
            }
          })
          return result;
        }
        console.log(flattenDepth([[0,1],[2,3],[4,5]],2))
        console.log(flattenDepth([1,[2,[3,[4]],5]]))
        console.log(flattenDepth([1,[2,[3,[4]],5]],2))
        console.log(flattenDepth([1,[2,[3,[4]],5]],3))

将每一项遍历，如果某一项为数组，则让该项继续调用，这里指定了depth作为扁平化的深度，因为这个参数对数组的每一项都要起作用。

柯里化

参数够了就执行，参数不够就返回一个函数，之前的参数存起来，直到够了为止。

function curry(func) {
  var l = func.length;
  return function curried() {
    var args = [].slice.call(arguments);
    if(args.length < l) {
      return function() {
        var argsInner = [].slice.call(arguments)
        return curried.apply(this, args.concat(argsInner))
      }
    } else {
      return func.apply(this, args)
    }
  }
}

var f = function(a,b,c) {
  return console.log([a,b,c])
}
var curried = curry(f);
curried(1)(2)(3)

节流和防抖

函数节流和函数防抖都是对大量频繁调用代码的一种优化。

防抖

不管你触发了多少次，都等到你最后触发后过一段你指定的时间才触发。简单地说，即函数在特定的时间内不被再调用后执行。

实际应用场景

监听窗口大小重绘的操作。
在用户拖拽窗口时，一直在改变窗口的大小，如果我们在 resize 事件中进行一些操作，消耗将是巨大的。而且大多数可能是无意义的执行，因为用户还处于拖拽的过程中。
可以使用函数防抖来优化相关的处理。

// 普通方案
window.addEventListener('resize', () => {
  console.log('trigger');
})

//函数防抖方案
let debounceIdentify = 0;
window.addEventListener('resize', () => {
  debounceIdentify && clearTimeout(debounceIdentity)
  debounceIdentity = setTimeout(() => {
    console.log('trigger')
  }, 300)
})

我们在 resize 事件中添加了一个 300 ms 的延迟执行逻辑。
并且每次事件触发时，都会重新计时，这样保证，函数的执行肯定是在距离上次 resize 事件被触发的 300 ms 后。
两次 resize 事件间隔小于 300 ms 的都被忽略了，这样就会节省很多无意义的事件触发。

输入框的联想

几乎所有的搜索引擎都会对你输入的文字进行预判，并在下方推荐相关的结果。
但是这个联想意味着我们需要将当前用户所输入的文本传递到后端，并获取返回数据，展示在页面中。
如果遇到打字速度快的人，在一小段时间内，会连续发送大量的 ajax 请求到后端。并且当前的数据返回过来后，其实已经失去了展示的意义，因为用户可能从 you 输入到了 young ，这两个单词的相关结果肯定不一样的。
所以我们就在监听用户输入的事件那里做函数防抖处理，在 XXX 秒后发送联想搜索的 ajax 请求。

/**
 * 函数防抖的实现
 * @param  {Function} func   要实现函数节流的原函数
 * @param  {Number}   delay  结束的延迟时间
 * @return {Function}        添加节流功能的函数
 */

function debounce (func, delay) {
  let debounceIdentify = 0
  return (...args) => {
    debounceIdentify && clearTimeout(debounceIdentify)
    debounceIdentify = setTimeout(() => {
      debounceIdentify = 0
      func.apply(this, args)
    }, delay)
  }
}

基本版的：

function debounce(func, wait){
   var timer;
   return function(){
     var context = this;
     var args = arguments;
     clearTimeout(timer);
     timer = setTimeout(function(){
       func.apply(context, args)
     }, wait)
   }
}
function debounce(func, wait, leading, trailing) {
  var timer, lastCall = 0, flag = true
  return function() {
    var context = this
    var args = arguments
    var now = + new Date()
    if (now - lastCall < wait) {
      flag = false
      lastCall = now
    } else {
      flag = true
    }
    if (leading && flag) {
      lastCall = now
      return func.apply(context, args)
    }
    if (trailing) {
      clearTimeout(timer)
      timer = setTimeout(function() {
        flag = true
        func.apply(context, args)
      }, wait)
    }
  }
}

类似函数防抖操作

在一些与用户的交互上，比如提交表单后，一般都会显示一个loading框来提示用户，他提交的表单正在处理中。
但是发送表单请求后就显示loading是一件很不友好的事情，因为请求可能在几十毫秒内就会得到响应。
这样在用户看来就是页面中闪过一团黑色，所以可以在提交表单后添加一个延迟函数，在XXX秒后再显示loading框。
这样在快速响应的场景下，用户是不会看到一闪而过的loading框，当然，一定要记得在接收到数据后去clearTimeout.

let identify = setTimeout(showLoadingModal, 500)
fetch('XXX').then(res => {
  // doing something

  // clear timer
  clearTimeout(identify)
})

节流

不管怎么触发，都是按照指定的时间间隔来执行。简单地说，就是限制函数在一定时间内调用的次数。

在程序中，可以通过限制函数的调用频率，来抑制资源的消耗。

需要实现一个元素拖拽的效果，可以在每次 move 事件中进行重绘 DOM，但是这样做，程序的开销是非常大的。
所以这里用到函数节流的方法，来减少重绘的次数。

//普通方案
$dragable.addEventListener('mousemove', () => {
  console.log('trigger')
})

// 函数节流的实现方案
let throttleIndentify = 0;
$dragable.addEventListener('mousemove', () => {
  if(throttleIndentify) return;
  throttleIndentify = setTimeout(() => throttleIdentify = 0, 500);
  console.log('trigger');
})

这样做的效果是，在拖拽的过程中，能保证 500 ms 内，只能重绘一次 DOM。在同时监听了 mousemove 后，两者最终的效果是一致的，但是在拖拽的过程中，函数节流版触发事件的次数会减少很多，资源相应地会消耗更少。

通用的函数节流实现

// ES6 版
function throttle (func, interval) {
  let identify = 0;
  return (...args) => {
    if (identify) return;
    identify = setTimeout(() => identify = 0, interval);
    func.apply(this, args)
  }
}
function throttle(func, wait){
  var timer;
  return function() {
    var context = this;
    var args = arguments;
    if(!timer) {
      timer = setTimeout(function() {
        timer = null;
        func.apply(context, args)
      },wait)
    }
  }
}
function throttle(func, wait, leading, trailing) {
  var timer, lastCall = 0, flag = true
  return function() {
    var context = this
    var args = arguments
    var now = + new Date()
    flag = now - lastCall > wait
    if (leading && flag) {
      lastCall = now
      return func.apply(context, args)
    }
    if (!timer && trailing && !(flag && leading)) {
      timer = setTimeout(function () {
        timer = null
        lastCall = + new Date()
        func.apply(context, args)
      }, wait)
    } else {
      lastCall = now
    }
  }
}

类似函数节流的操作

平时开发中经常会做的 ajax 请求获取数据，这里可以用到类似函数节流的操作。
在我们发送一个请求到后台时，当返回的数据还没有接收到，我们会添加一个标识，来表明当前有一个请求正在被处理，如果这时用户再触发 ajax 请求，则会直接跳过本次函数的执行。
同样的还有滑动加载更多数据，如果不添加类似的限制，可能会导致发送更多条请求，渲染重复数据。

对象拷贝

对象拷贝分为深拷贝和浅拷贝

JSON.parse(JSON.stringify(obj))
function clone(value, isDeep) {
  if(value === null) return null;
  if(typeof value !== 'object') return value
  if(Array.isArray(value)) {
    if(isDeep) {
      return value.map(item => clone(item, true))    
    }
    return [].concat(value)
  } else {
    if(isDeep) {
      var obj = {};
      Object.keys(value).forEach(item => {
        obj[item] = clone(value[item], true)
      })
      return obj;
    }
    return {...value}
  }
}

var objects = { c: { 'a': 1, e: [1, {f: 2}] }, d: { 'b': 2 } }
var shallow = clone(objects, true)
console.log(shallow.c.e[1]) // { f: 2 }
console.log(shallow.c === objects.c) // false
console.log(shallow.d === objects.d) // false
console.log(shallow === objects) // false