1. 程式人生 > >深入解析JavaScript 五大函式之奧祕

深入解析JavaScript 五大函式之奧祕

在 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
}//歡迎加入前端全棧開發交流圈一起吹水聊天學習交流:864305860
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)
 }//歡迎加入前端全棧開發交流圈一起吹水聊天學習交流:864305860
 }//面向1-3年前端人員
}//幫助突破技術瓶頸,提升思維能力
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)//歡迎加入前端全棧開發交流圈一起吹水聊天學習交流:864305860
 }//面向1-3年前端人員
}//幫助突破技術瓶頸,提升思維能力

現在有個要求就是剛開始的時候也觸發,最後一次也觸發,並且可以配置,先寫個測試頁面方便測試功能,每次按空格鍵就會讓數字加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++
  }
  }//歡迎加入前端全棧開發交流圈一起吹水聊天學習交流:864305860
  // 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)
 }//歡迎加入前端全棧開發交流圈一起學習交流:864305860
 }//面向1-3年前端人員
}//幫助突破技術瓶頸,提升思維能力

因為每次記錄上次呼叫的時間,與現在的時間對比,小於間隔的話,第一次執行後之後就不會執行,大於間隔或在間隔時間後呼叫了,則重置 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)
 }//歡迎加入前端全棧開發交流圈一起學習交流:864305860
 }//面向1-3年前端人員
}//幫助突破技術瓶頸,提升思維能力

同樣和防抖函式一樣加上兩個引數,也可使用上面的例子來測試,其實兩者的程式碼很類似。

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
 }//歡迎加入前端全棧開發交流圈一起學習交流:864305860
 }//面向1-3年前端人員
}//幫助突破技術瓶頸,提升思維能力

物件拷貝

物件拷貝都知道分為深拷貝和淺拷貝,黑科技手段就是使用 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 }
 }
}//歡迎加入前端全棧開發交流圈一起吹水聊天學習交流:864305860
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 方法。

總結

其實對於上面這些方法,總的來說思路就是遞迴和高階函式的使用,其中就有關於閉包的使用,前端就愛問這些問題,最好就是自己實現一遍,這樣有助於理解。感謝您的觀看,如有不足之處,歡迎批評指正。