JavaScript 五大常見函數

時間 2019-11-10

原文原文鏈接

在 JavaScript 中有一些問題會被拿出來常常討論，這些問題每一個人都有不一樣的思路，想要理解這些問題，最好的方法就是本身實現一遍，話很少說，開始正題。html

數組扁平化

數組扁平化有不少方法，但最終最好的方法就是遞歸，實現一個指定深度的扁平化方法，這樣基本的套路都會了解。前端

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 ]

遞歸實現很簡潔易懂，就是將每一項遍歷，若是某一項爲數組，則讓該項繼續調用，這裏指定了 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) // => [1, 2, 3]
curried(1, 2)(3) // => [1, 2, 3]
curried(1, 2, 3) // => [1, 2, 3]

上面的代碼不難看出，每次判斷參數的個數，與被柯里化的函數參數個數比較，若是小於就繼續返回函數，不然就執行。app

防抖

防抖按照個人理解就是無論你觸發多少次，都等到你最後觸發後過一段你指定的時間才觸發。按照這個解釋，寫一個基本版的。函數

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

如今有個要求就是剛開始的時候也觸發，最後一次也觸發，而且能夠配置，先寫個測試頁面方便測試功能，每次按空格鍵就會讓數字加1，來測試防抖和節流函數。測試

<!DOCTYPE html>
<html lang="zh-cmn-Hans">
<head>
    <style>
        #container{text-align: center; color: #333; font-size: 30px;}
    </style>
</head>
<body>
    <div id="container"></div>
    <script>
      var count = 1
      var container = document.getElementById('container')
      function getUserAction(e) {
        // 空格
        if (e.keyCode === 32) {
          container.innerHTML = count++
        }
      }
      // document.onkeydown = debounce(getUserAction, 1000, false, true)
      document.onkeydown = throttle(getUserAction, 1000, true, true)
      function debounce(func, wait, leading, trailing) {}
      function throttle(func, wait, leading, trailing) {}
    </script>
</body>
</html>

經過 leading 和 trailing 兩個參數來決定開始和結束是否執行，若是 leading 爲 true，則沒次按空格都會執行一次，若是 trailing 爲 true，則每次結束都會將最後一次觸發執行。以防抖函數距離，若是二者都爲 true，則第一次按空格會加 1，而後快速按空格，此時裏面的 getUserAction 並不會執行，而是等到鬆手後再執行，加入 trailing 爲 false，則鬆手後不會執行。this

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

解釋一下，每次記錄上次調用的時間，與如今的時間對比，小於間隔的話，第一次執行後以後就不會執行，大於間隔或在間隔時間後調用了，則重置 flag，能夠與上面那個基本版的對比着看。code

節流

節流就是，無論怎麼觸發，都是按照指定的間隔來執行，一樣給個基本版。htm

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

對象拷貝

對象拷貝都知道分爲深拷貝和淺拷貝，黑科技手段就是使用

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

對於基本類型直接返回，對於引用類型，遍歷遞歸調用 clone 方法。