摘要：上面的代碼不難看出，每次判斷參數(shù)的個(gè)數(shù)，與被柯里化的函數(shù)參數(shù)個(gè)數(shù)比較，如果小于就繼續(xù)返回函數(shù)，否則就執(zhí)行。同樣和防抖函數(shù)一樣加上兩個(gè)參數(shù)，也可使用上面的例子來(lái)測(cè)試，其實(shí)兩者的代碼很類似。

在 JavaScript 中有一些問(wèn)題會(huì)被拿出來(lái)經(jīng)常討論，這些問(wèn)題每個(gè)人都有不同的思路，想要理解這些問(wèn)題，最好的方法就是自己實(shí)現(xiàn)一遍，話不多說(shuō)，開(kāi)始正題。

數(shù)組扁平化有很多方法，但最終最好的方法就是遞歸，實(shí)現(xiàn)一個(gè)指定深度的扁平化方法，這樣基本的套路都會(huì)了解。

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([1, [2, [3, [4]], 5]])) // [ 1, 2, [ 3, [ 4 ] ], 5 ]
console.log(flattenDepth([1, [2, [3, [4]], 5]], 2)) // [ 1, 2, 3, [ 4 ], 5 ]
console.log(flattenDepth([1, [2, [3, [4]], 5]], 3)) // [ 1, 2, 3, 4, 5 ]

遞歸實(shí)現(xiàn)很簡(jiǎn)潔易懂，就是將每一項(xiàng)遍歷，如果某一項(xiàng)為數(shù)組，則讓該項(xiàng)繼續(xù)調(diào)用，這里指定了 depth 作為扁平化的深度，因?yàn)檫@個(gè)參數(shù)對(duì)數(shù)組的每一項(xiàng)都要起作用，故放在循環(huán)的里面。

函數(shù)的柯里化都被講爛了，每個(gè)人都有自己的理解和實(shí)現(xiàn)方法，一句話解釋就是參數(shù)夠了就執(zhí)行，參數(shù)不夠就返回一個(gè)函數(shù)，之前的參數(shù)存起來(lái)，直到夠了為止。

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) // => [1, 2, 3]
curried(1, 2)(3) // => [1, 2, 3]
curried(1, 2, 3) // => [1, 2, 3]

上面的代碼不難看出，每次判斷參數(shù)的個(gè)數(shù)，與被柯里化的函數(shù)參數(shù)個(gè)數(shù)比較，如果小于就繼續(xù)返回函數(shù)，否則就執(zhí)行。

防抖按照我的理解就是不管你觸發(fā)多少次，都等到你最后觸發(fā)后過(guò)一段你指定的時(shí)間才觸發(fā)。按照這個(gè)解釋，寫一個(gè)基本版的。

function debounce(func, wait) {
  var timer
  return function() {
    var context = this
    var args = arguments
    clearTimeout(timer)
    timer = setTimeout(function() {
      func.apply(context, args)
    }, wait)
  }
}

現(xiàn)在有個(gè)要求就是剛開(kāi)始的時(shí)候也觸發(fā)，最后一次也觸發(fā)，并且可以配置，先寫個(gè)測(cè)試頁(yè)面方便測(cè)試功能，每次按空格鍵就會(huì)讓數(shù)字加1，來(lái)測(cè)試防抖和節(jié)流函數(shù)。

通過(guò) leading 和 trailing 兩個(gè)參數(shù)來(lái)決定開(kāi)始和結(jié)束是否執(zhí)行，如果 leading 為 true，則沒(méi)次按空格都會(huì)執(zhí)行一次，如果 trailing 為 true，則每次結(jié)束都會(huì)將最后一次觸發(fā)執(zhí)行。以防抖函數(shù)距離，如果兩者都為 true，則第一次按空格會(huì)加 1，然后快速按空格，此時(shí)里面的 getUserAction 并不會(huì)執(zhí)行，而是等到松手后再執(zhí)行，加入 trailing 為 false，則松手后不會(huì)執(zhí)行。

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)
    }
  }
}

解釋一下，每次記錄上次調(diào)用的時(shí)間，與現(xiàn)在的時(shí)間對(duì)比，小于間隔的話，第一次執(zhí)行后之后就不會(huì)執(zhí)行，大于間隔或在間隔時(shí)間后調(diào)用了，則重置 flag，可以與上面那個(gè)基本版的對(duì)比著看。

節(jié)流就是，不管怎么觸發(fā)，都是按照指定的間隔來(lái)執(zhí)行，同樣給個(gè)基本版。

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)
    }
  }
}

同樣和防抖函數(shù)一樣加上兩個(gè)參數(shù)，也可使用上面的例子來(lái)測(cè)試，其實(shí)兩者的代碼很類似。

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
    }
  }
}

對(duì)象拷貝都知道分為深拷貝和淺拷貝，黑科技手段就是使用

JSON.parse(JSON.stringify(obj))

還有個(gè)方法就是使用遞歸了

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

對(duì)于基本類型直接返回，對(duì)于引用類型，遍歷遞歸調(diào)用 clone 方法。

其實(shí)對(duì)于上面這些方法，總的來(lái)說(shuō)思路就是遞歸和高階函數(shù)的使用，其中就有關(guān)于閉包的使用，前端就愛(ài)問(wèn)這些問(wèn)題，最好就是自己實(shí)現(xiàn)一遍，這樣有助于理解。