JavaScript 五大常見函數

2024-05-06 16:43:17

字體：大中小

來源：轉載

供稿：網友

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

數組扁平化

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

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]

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

防抖

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

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，則松手后不會執行。

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，可以與上面那個基本版的對比著看。

節流

節流就是，不管怎么觸發，都是按照指定的間隔來執行，同樣給個基本版。

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) // falseconsole.log(shallow.d === objects.d) // falseconsole.log(shallow === objects) // false

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